1 /******************************************************************************
2 *
3 * Module Name: aslrestype2s - Serial Large resource descriptors
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2016, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #include "aslcompiler.h"
45 #include "aslcompiler.y.h"
46 #include "amlcode.h"
47
48 #define _COMPONENT ACPI_COMPILER
49 ACPI_MODULE_NAME ("aslrestype2s")
50
51
52 static UINT16
53 RsGetBufferDataLength (
54 ACPI_PARSE_OBJECT *InitializerOp);
55
56 static UINT16
57 RsGetInterruptDataLength (
58 ACPI_PARSE_OBJECT *InitializerOp);
59
60 static BOOLEAN
61 RsGetVendorData (
62 ACPI_PARSE_OBJECT *InitializerOp,
63 UINT8 *VendorData,
64 ACPI_SIZE DescriptorOffset);
65
66 /*
67 * This module contains descriptors for serial buses and GPIO:
68 *
69 * GpioInt
70 * GpioIo
71 * I2cSerialBus
72 * SpiSerialBus
73 * UartSerialBus
74 */
75
76
77 /*******************************************************************************
78 *
79 * FUNCTION: RsGetBufferDataLength
80 *
81 * PARAMETERS: InitializerOp - Current parse op, start of the resource
82 * descriptor
83 *
84 * RETURN: Length of the data buffer
85 *
86 * DESCRIPTION: Get the length of a RawDataBuffer, used for vendor data.
87 *
88 ******************************************************************************/
89
90 static UINT16
RsGetBufferDataLength(ACPI_PARSE_OBJECT * InitializerOp)91 RsGetBufferDataLength (
92 ACPI_PARSE_OBJECT *InitializerOp)
93 {
94 UINT16 ExtraDataSize = 0;
95 ACPI_PARSE_OBJECT *DataList;
96
97
98 /* Find the byte-initializer list */
99
100 while (InitializerOp)
101 {
102 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DATABUFFER)
103 {
104 /* First child is the optional length (ignore it here) */
105
106 DataList = InitializerOp->Asl.Child;
107 DataList = ASL_GET_PEER_NODE (DataList);
108
109 /* Count the data items (each one is a byte of data) */
110
111 while (DataList)
112 {
113 ExtraDataSize++;
114 DataList = ASL_GET_PEER_NODE (DataList);
115 }
116
117 return (ExtraDataSize);
118 }
119
120 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
121 }
122
123 return (ExtraDataSize);
124 }
125
126
127 /*******************************************************************************
128 *
129 * FUNCTION: RsGetInterruptDataLength
130 *
131 * PARAMETERS: InitializerOp - Current parse op, start of the resource
132 * descriptor
133 *
134 * RETURN: Length of the interrupt data list
135 *
136 * DESCRIPTION: Get the length of a list of interrupt DWORDs for the GPIO
137 * descriptors.
138 *
139 ******************************************************************************/
140
141 static UINT16
RsGetInterruptDataLength(ACPI_PARSE_OBJECT * InitializerOp)142 RsGetInterruptDataLength (
143 ACPI_PARSE_OBJECT *InitializerOp)
144 {
145 UINT16 InterruptLength;
146 UINT32 i;
147
148
149 /* Count the interrupt numbers */
150
151 InterruptLength = 0;
152 for (i = 0; InitializerOp; i++)
153 {
154 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
155
156 /* Interrupt list starts at offset 10 (Gpio descriptors) */
157
158 if (i >= 10)
159 {
160 InterruptLength += 2;
161 }
162 }
163
164 return (InterruptLength);
165 }
166
167
168 /*******************************************************************************
169 *
170 * FUNCTION: RsGetVendorData
171 *
172 * PARAMETERS: InitializerOp - Current parse op, start of the resource
173 * descriptor.
174 * VendorData - Where the vendor data is returned
175 * DescriptorOffset - Where vendor data begins in descriptor
176 *
177 * RETURN: TRUE if valid vendor data was returned, FALSE otherwise.
178 *
179 * DESCRIPTION: Extract the vendor data and construct a vendor data buffer.
180 *
181 ******************************************************************************/
182
183 static BOOLEAN
RsGetVendorData(ACPI_PARSE_OBJECT * InitializerOp,UINT8 * VendorData,ACPI_SIZE DescriptorOffset)184 RsGetVendorData (
185 ACPI_PARSE_OBJECT *InitializerOp,
186 UINT8 *VendorData,
187 ACPI_SIZE DescriptorOffset)
188 {
189 ACPI_PARSE_OBJECT *BufferOp;
190 UINT32 SpecifiedLength = ACPI_UINT32_MAX;
191 UINT16 ActualLength = 0;
192
193
194 /* Vendor Data field is always optional */
195
196 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
197 {
198 return (FALSE);
199 }
200
201 BufferOp = InitializerOp->Asl.Child;
202 if (!BufferOp)
203 {
204 AslError (ASL_ERROR, ASL_MSG_SYNTAX, InitializerOp, "");
205 return (FALSE);
206 }
207
208 /* First child is the optional buffer length (WORD) */
209
210 if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
211 {
212 SpecifiedLength = (UINT16) BufferOp->Asl.Value.Integer;
213 }
214
215 /* Insert field tag _VEN */
216
217 RsCreateByteField (InitializerOp, ACPI_RESTAG_VENDORDATA,
218 (UINT16) DescriptorOffset);
219
220 /* Walk the list of buffer initializers (each is one byte) */
221
222 BufferOp = RsCompleteNodeAndGetNext (BufferOp);
223 if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
224 {
225 while (BufferOp)
226 {
227 *VendorData = (UINT8) BufferOp->Asl.Value.Integer;
228 VendorData++;
229 ActualLength++;
230 BufferOp = RsCompleteNodeAndGetNext (BufferOp);
231 }
232 }
233
234 /* Length validation. Buffer cannot be of zero length */
235
236 if ((SpecifiedLength == 0) ||
237 ((SpecifiedLength == ACPI_UINT32_MAX) && (ActualLength == 0)))
238 {
239 AslError (ASL_ERROR, ASL_MSG_BUFFER_LENGTH, InitializerOp, NULL);
240 return (FALSE);
241 }
242
243 if (SpecifiedLength != ACPI_UINT32_MAX)
244 {
245 /* ActualLength > SpecifiedLength -> error */
246
247 if (ActualLength > SpecifiedLength)
248 {
249 AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG, InitializerOp, NULL);
250 return (FALSE);
251 }
252
253 /* ActualLength < SpecifiedLength -> remark */
254
255 else if (ActualLength < SpecifiedLength)
256 {
257 AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT, InitializerOp, NULL);
258 return (FALSE);
259 }
260 }
261
262 return (TRUE);
263 }
264
265
266 /*******************************************************************************
267 *
268 * FUNCTION: RsDoGpioIntDescriptor
269 *
270 * PARAMETERS: Info - Parse Op and resource template offset
271 *
272 * RETURN: Completed resource node
273 *
274 * DESCRIPTION: Construct a long "GpioInt" descriptor
275 *
276 ******************************************************************************/
277
278 ASL_RESOURCE_NODE *
RsDoGpioIntDescriptor(ASL_RESOURCE_INFO * Info)279 RsDoGpioIntDescriptor (
280 ASL_RESOURCE_INFO *Info)
281 {
282 AML_RESOURCE *Descriptor;
283 ACPI_PARSE_OBJECT *InitializerOp;
284 ASL_RESOURCE_NODE *Rnode;
285 char *ResourceSource = NULL;
286 UINT8 *VendorData = NULL;
287 UINT16 *InterruptList = NULL;
288 UINT16 *PinList = NULL;
289 UINT16 ResSourceLength;
290 UINT16 VendorLength;
291 UINT16 InterruptLength;
292 UINT16 DescriptorSize;
293 UINT32 CurrentByteOffset;
294 UINT32 PinCount = 0;
295 UINT32 i;
296
297
298 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
299 CurrentByteOffset = Info->CurrentByteOffset;
300
301 /*
302 * Calculate lengths for fields that have variable length:
303 * 1) Resource Source string
304 * 2) Vendor Data buffer
305 * 3) PIN (interrupt) list
306 */
307 ResSourceLength = RsGetStringDataLength (InitializerOp);
308 VendorLength = RsGetBufferDataLength (InitializerOp);
309 InterruptLength = RsGetInterruptDataLength (InitializerOp);
310
311 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
312 ResSourceLength + VendorLength + InterruptLength;
313
314 /* Allocate the local resource node and initialize */
315
316 Rnode = RsAllocateResourceNode (DescriptorSize +
317 sizeof (AML_RESOURCE_LARGE_HEADER));
318
319 Descriptor = Rnode->Buffer;
320 Descriptor->Gpio.ResourceLength = DescriptorSize;
321 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
322 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
323 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_INT;
324
325 /* Build pointers to optional areas */
326
327 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor,
328 sizeof (AML_RESOURCE_GPIO));
329 PinList = InterruptList;
330 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
331 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
332
333 /* Setup offsets within the descriptor */
334
335 Descriptor->Gpio.PinTableOffset = (UINT16)
336 ACPI_PTR_DIFF (InterruptList, Descriptor);
337
338 Descriptor->Gpio.ResSourceOffset = (UINT16)
339 ACPI_PTR_DIFF (ResourceSource, Descriptor);
340
341 DbgPrint (ASL_DEBUG_OUTPUT,
342 "%16s - Actual: %.2X, Base: %.2X, ResLen: "
343 "%.2X, VendLen: %.2X, IntLen: %.2X\n",
344 "GpioInt", Descriptor->Gpio.ResourceLength,
345 (UINT16) sizeof (AML_RESOURCE_GPIO),
346 ResSourceLength, VendorLength, InterruptLength);
347
348 /* Process all child initialization nodes */
349
350 for (i = 0; InitializerOp; i++)
351 {
352 switch (i)
353 {
354 case 0: /* Interrupt Mode - edge/level [Flag] (_MOD) */
355
356 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
357 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
358 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0);
359 break;
360
361 case 1: /* Interrupt Polarity - Active high/low [Flags] (_POL) */
362
363 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 1, 0);
364 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_POLARITY,
365 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 1, 2);
366 break;
367
368 case 2: /* Share Type - Default: exclusive (0) [Flags] (_SHR) */
369
370 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
371 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
372 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3, 2);
373 break;
374
375 case 3: /* Pin Config [BYTE] (_PPI) */
376
377 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
378 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
379 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
380 break;
381
382 case 4: /* Debounce Timeout [WORD] (_DBT) */
383
384 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
385 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
386 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
387 break;
388
389 case 5: /* ResSource [Optional Field - STRING] */
390
391 if (ResSourceLength)
392 {
393 /* Copy string to the descriptor */
394
395 strcpy (ResourceSource,
396 InitializerOp->Asl.Value.String);
397 }
398 break;
399
400 case 6: /* Resource Index */
401
402 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
403 {
404 Descriptor->Gpio.ResSourceIndex =
405 (UINT8) InitializerOp->Asl.Value.Integer;
406 }
407 break;
408
409 case 7: /* Resource Usage (consumer/producer) */
410
411 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
412 break;
413
414 case 8: /* Resource Tag (Descriptor Name) */
415
416 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
417 break;
418
419 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
420
421 /*
422 * Always set the VendorOffset even if there is no Vendor Data.
423 * This field is required in order to calculate the length
424 * of the ResourceSource at runtime.
425 */
426 Descriptor->Gpio.VendorOffset = (UINT16)
427 ACPI_PTR_DIFF (VendorData, Descriptor);
428
429 if (RsGetVendorData (InitializerOp, VendorData,
430 (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
431 {
432 Descriptor->Gpio.VendorLength = VendorLength;
433 }
434 break;
435
436 default:
437 /*
438 * PINs come through here, repeatedly. Each PIN must be a WORD.
439 * NOTE: there is no "length" field for this, so from ACPI spec:
440 * The number of pins in the table can be calculated from:
441 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
442 * (implies resource source must immediately follow the pin list.)
443 * Name: _PIN
444 */
445 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
446 InterruptList++;
447 PinCount++;
448
449 /* Case 10: First interrupt number in list */
450
451 if (i == 10)
452 {
453 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
454 {
455 /* Must be at least one interrupt */
456
457 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
458 InitializerOp, NULL);
459 }
460
461 /* Check now for duplicates in list */
462
463 RsCheckListForDuplicates (InitializerOp);
464
465 /* Create a named field at the start of the list */
466
467 RsCreateWordField (InitializerOp, ACPI_RESTAG_PIN,
468 CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
469 }
470 break;
471 }
472
473 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
474 }
475
476 MpSaveGpioInfo (Info->MappingOp, Descriptor,
477 PinCount, PinList, ResourceSource);
478 return (Rnode);
479 }
480
481
482 /*******************************************************************************
483 *
484 * FUNCTION: RsDoGpioIoDescriptor
485 *
486 * PARAMETERS: Info - Parse Op and resource template offset
487 *
488 * RETURN: Completed resource node
489 *
490 * DESCRIPTION: Construct a long "GpioIo" descriptor
491 *
492 ******************************************************************************/
493
494 ASL_RESOURCE_NODE *
RsDoGpioIoDescriptor(ASL_RESOURCE_INFO * Info)495 RsDoGpioIoDescriptor (
496 ASL_RESOURCE_INFO *Info)
497 {
498 AML_RESOURCE *Descriptor;
499 ACPI_PARSE_OBJECT *InitializerOp;
500 ASL_RESOURCE_NODE *Rnode;
501 char *ResourceSource = NULL;
502 UINT8 *VendorData = NULL;
503 UINT16 *InterruptList = NULL;
504 UINT16 *PinList = NULL;
505 UINT16 ResSourceLength;
506 UINT16 VendorLength;
507 UINT16 InterruptLength;
508 UINT16 DescriptorSize;
509 UINT32 CurrentByteOffset;
510 UINT32 PinCount = 0;
511 UINT32 i;
512
513
514 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
515 CurrentByteOffset = Info->CurrentByteOffset;
516
517 /*
518 * Calculate lengths for fields that have variable length:
519 * 1) Resource Source string
520 * 2) Vendor Data buffer
521 * 3) PIN (interrupt) list
522 */
523 ResSourceLength = RsGetStringDataLength (InitializerOp);
524 VendorLength = RsGetBufferDataLength (InitializerOp);
525 InterruptLength = RsGetInterruptDataLength (InitializerOp);
526 PinList = InterruptList;
527
528 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
529 ResSourceLength + VendorLength + InterruptLength;
530
531 /* Allocate the local resource node and initialize */
532
533 Rnode = RsAllocateResourceNode (DescriptorSize +
534 sizeof (AML_RESOURCE_LARGE_HEADER));
535
536 Descriptor = Rnode->Buffer;
537 Descriptor->Gpio.ResourceLength = DescriptorSize;
538 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
539 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
540 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_IO;
541
542 /* Build pointers to optional areas */
543
544 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO));
545 PinList = InterruptList;
546 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
547 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
548
549 /* Setup offsets within the descriptor */
550
551 Descriptor->Gpio.PinTableOffset = (UINT16)
552 ACPI_PTR_DIFF (InterruptList, Descriptor);
553
554 Descriptor->Gpio.ResSourceOffset = (UINT16)
555 ACPI_PTR_DIFF (ResourceSource, Descriptor);
556
557 DbgPrint (ASL_DEBUG_OUTPUT,
558 "%16s - Actual: %.2X, Base: %.2X, ResLen: "
559 "%.2X, VendLen: %.2X, IntLen: %.2X\n",
560 "GpioIo", Descriptor->Gpio.ResourceLength,
561 (UINT16) sizeof (AML_RESOURCE_GPIO),
562 ResSourceLength, VendorLength, InterruptLength);
563
564 /* Process all child initialization nodes */
565
566 for (i = 0; InitializerOp; i++)
567 {
568 switch (i)
569 {
570 case 0: /* Share Type [Flags] (_SHR) */
571
572 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
573 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
574 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3);
575 break;
576
577 case 1: /* Pin Config [BYTE] (_PPI) */
578
579 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
580 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
581 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
582 break;
583
584 case 2: /* Debounce Timeout [WORD] (_DBT) */
585
586 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
587 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
588 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
589 break;
590
591 case 3: /* Drive Strength [WORD] (_DRS) */
592
593 Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer;
594 RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH,
595 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength));
596 break;
597
598 case 4: /* I/O Restriction [Flag] (_IOR) */
599
600 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
601 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION,
602 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2);
603 break;
604
605 case 5: /* ResSource [Optional Field - STRING] */
606
607 if (ResSourceLength)
608 {
609 /* Copy string to the descriptor */
610
611 strcpy (ResourceSource,
612 InitializerOp->Asl.Value.String);
613 }
614 break;
615
616 case 6: /* Resource Index */
617
618 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
619 {
620 Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
621 }
622 break;
623
624 case 7: /* Resource Usage (consumer/producer) */
625
626 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
627 break;
628
629 case 8: /* Resource Tag (Descriptor Name) */
630
631 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
632 break;
633
634 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
635 /*
636 * Always set the VendorOffset even if there is no Vendor Data.
637 * This field is required in order to calculate the length
638 * of the ResourceSource at runtime.
639 */
640 Descriptor->Gpio.VendorOffset = (UINT16)
641 ACPI_PTR_DIFF (VendorData, Descriptor);
642
643 if (RsGetVendorData (InitializerOp, VendorData,
644 (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
645 {
646 Descriptor->Gpio.VendorLength = VendorLength;
647 }
648 break;
649
650 default:
651 /*
652 * PINs come through here, repeatedly. Each PIN must be a WORD.
653 * NOTE: there is no "length" field for this, so from ACPI spec:
654 * The number of pins in the table can be calculated from:
655 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
656 * (implies resource source must immediately follow the pin list.)
657 * Name: _PIN
658 */
659 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
660 InterruptList++;
661 PinCount++;
662
663 /* Case 10: First interrupt number in list */
664
665 if (i == 10)
666 {
667 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
668 {
669 /* Must be at least one interrupt */
670
671 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
672 InitializerOp, NULL);
673 }
674
675 /* Check now for duplicates in list */
676
677 RsCheckListForDuplicates (InitializerOp);
678
679 /* Create a named field at the start of the list */
680
681 RsCreateWordField (InitializerOp, ACPI_RESTAG_PIN,
682 CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
683 }
684 break;
685 }
686
687 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
688 }
689
690 MpSaveGpioInfo (Info->MappingOp, Descriptor,
691 PinCount, PinList, ResourceSource);
692 return (Rnode);
693 }
694
695
696 /*******************************************************************************
697 *
698 * FUNCTION: RsDoI2cSerialBusDescriptor
699 *
700 * PARAMETERS: Info - Parse Op and resource template offset
701 *
702 * RETURN: Completed resource node
703 *
704 * DESCRIPTION: Construct a long "I2cSerialBus" descriptor
705 *
706 ******************************************************************************/
707
708 ASL_RESOURCE_NODE *
RsDoI2cSerialBusDescriptor(ASL_RESOURCE_INFO * Info)709 RsDoI2cSerialBusDescriptor (
710 ASL_RESOURCE_INFO *Info)
711 {
712 AML_RESOURCE *Descriptor;
713 ACPI_PARSE_OBJECT *InitializerOp;
714 ASL_RESOURCE_NODE *Rnode;
715 char *ResourceSource = NULL;
716 UINT8 *VendorData = NULL;
717 UINT16 ResSourceLength;
718 UINT16 VendorLength;
719 UINT16 DescriptorSize;
720 UINT32 CurrentByteOffset;
721 UINT32 i;
722
723
724 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
725 CurrentByteOffset = Info->CurrentByteOffset;
726
727 /*
728 * Calculate lengths for fields that have variable length:
729 * 1) Resource Source string
730 * 2) Vendor Data buffer
731 */
732 ResSourceLength = RsGetStringDataLength (InitializerOp);
733 VendorLength = RsGetBufferDataLength (InitializerOp);
734
735 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS) +
736 ResSourceLength + VendorLength;
737
738 /* Allocate the local resource node and initialize */
739
740 Rnode = RsAllocateResourceNode (DescriptorSize +
741 sizeof (AML_RESOURCE_LARGE_HEADER));
742
743 Descriptor = Rnode->Buffer;
744 Descriptor->I2cSerialBus.ResourceLength = DescriptorSize;
745 Descriptor->I2cSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
746 Descriptor->I2cSerialBus.RevisionId = AML_RESOURCE_I2C_REVISION;
747 Descriptor->I2cSerialBus.TypeRevisionId = AML_RESOURCE_I2C_TYPE_REVISION;
748 Descriptor->I2cSerialBus.Type = AML_RESOURCE_I2C_SERIALBUSTYPE;
749 Descriptor->I2cSerialBus.TypeDataLength = AML_RESOURCE_I2C_MIN_DATA_LEN + VendorLength;
750
751 /* Build pointers to optional areas */
752
753 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_I2C_SERIALBUS));
754 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
755
756 DbgPrint (ASL_DEBUG_OUTPUT,
757 "%16s - Actual: %.2X, Base: %.2X, ResLen: "
758 "%.2X, VendLen: %.2X, TypLen: %.2X\n",
759 "I2cSerialBus", Descriptor->I2cSerialBus.ResourceLength,
760 (UINT16) sizeof (AML_RESOURCE_I2C_SERIALBUS), ResSourceLength,
761 VendorLength, Descriptor->I2cSerialBus.TypeDataLength);
762
763 /* Process all child initialization nodes */
764
765 for (i = 0; InitializerOp; i++)
766 {
767 switch (i)
768 {
769 case 0: /* Slave Address [WORD] (_ADR) */
770
771 Descriptor->I2cSerialBus.SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer;
772 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
773 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.SlaveAddress));
774 break;
775
776 case 1: /* Slave Mode [Flag] (_SLV) */
777
778 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 0, 0);
779 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
780 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.Flags), 0);
781 break;
782
783 case 2: /* Connection Speed [DWORD] (_SPE) */
784
785 Descriptor->I2cSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
786 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
787 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.ConnectionSpeed));
788 break;
789
790 case 3: /* Addressing Mode [Flag] (_MOD) */
791
792 RsSetFlagBits16 (&Descriptor->I2cSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
793 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
794 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.TypeSpecificFlags), 0);
795 break;
796
797 case 4: /* ResSource [Optional Field - STRING] */
798
799 if (ResSourceLength)
800 {
801 /* Copy string to the descriptor */
802
803 strcpy (ResourceSource,
804 InitializerOp->Asl.Value.String);
805 }
806 break;
807
808 case 5: /* Resource Index */
809
810 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
811 {
812 Descriptor->I2cSerialBus.ResSourceIndex =
813 (UINT8) InitializerOp->Asl.Value.Integer;
814 }
815 break;
816
817 case 6: /* Resource Usage (consumer/producer) */
818
819 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 1, 1);
820 break;
821
822 case 7: /* Resource Tag (Descriptor Name) */
823
824 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
825 break;
826
827 case 8: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
828
829 RsGetVendorData (InitializerOp, VendorData,
830 CurrentByteOffset + sizeof (AML_RESOURCE_I2C_SERIALBUS));
831 break;
832
833 default: /* Ignore any extra nodes */
834
835 break;
836 }
837
838 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
839 }
840
841 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
842 return (Rnode);
843 }
844
845
846 /*******************************************************************************
847 *
848 * FUNCTION: RsDoSpiSerialBusDescriptor
849 *
850 * PARAMETERS: Info - Parse Op and resource template offset
851 *
852 * RETURN: Completed resource node
853 *
854 * DESCRIPTION: Construct a long "SPI Serial Bus" descriptor
855 *
856 ******************************************************************************/
857
858 ASL_RESOURCE_NODE *
RsDoSpiSerialBusDescriptor(ASL_RESOURCE_INFO * Info)859 RsDoSpiSerialBusDescriptor (
860 ASL_RESOURCE_INFO *Info)
861 {
862 AML_RESOURCE *Descriptor;
863 ACPI_PARSE_OBJECT *InitializerOp;
864 ASL_RESOURCE_NODE *Rnode;
865 char *ResourceSource = NULL;
866 UINT8 *VendorData = NULL;
867 UINT16 ResSourceLength;
868 UINT16 VendorLength;
869 UINT16 DescriptorSize;
870 UINT32 CurrentByteOffset;
871 UINT32 i;
872
873
874 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
875 CurrentByteOffset = Info->CurrentByteOffset;
876
877 /*
878 * Calculate lengths for fields that have variable length:
879 * 1) Resource Source string
880 * 2) Vendor Data buffer
881 */
882 ResSourceLength = RsGetStringDataLength (InitializerOp);
883 VendorLength = RsGetBufferDataLength (InitializerOp);
884
885 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS) +
886 ResSourceLength + VendorLength;
887
888 /* Allocate the local resource node and initialize */
889
890 Rnode = RsAllocateResourceNode (DescriptorSize +
891 sizeof (AML_RESOURCE_LARGE_HEADER));
892
893 Descriptor = Rnode->Buffer;
894 Descriptor->SpiSerialBus.ResourceLength = DescriptorSize;
895 Descriptor->SpiSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
896 Descriptor->SpiSerialBus.RevisionId = AML_RESOURCE_SPI_REVISION;
897 Descriptor->SpiSerialBus.TypeRevisionId = AML_RESOURCE_SPI_TYPE_REVISION;
898 Descriptor->SpiSerialBus.Type = AML_RESOURCE_SPI_SERIALBUSTYPE;
899 Descriptor->SpiSerialBus.TypeDataLength = AML_RESOURCE_SPI_MIN_DATA_LEN + VendorLength;
900
901 /* Build pointers to optional areas */
902
903 VendorData = ACPI_ADD_PTR (UINT8, Descriptor,
904 sizeof (AML_RESOURCE_SPI_SERIALBUS));
905 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
906
907 DbgPrint (ASL_DEBUG_OUTPUT,
908 "%16s - Actual: %.2X, Base: %.2X, ResLen: "
909 "%.2X, VendLen: %.2X, TypLen: %.2X\n",
910 "SpiSerialBus", Descriptor->SpiSerialBus.ResourceLength,
911 (UINT16) sizeof (AML_RESOURCE_SPI_SERIALBUS), ResSourceLength,
912 VendorLength, Descriptor->SpiSerialBus.TypeDataLength);
913
914 /* Process all child initialization nodes */
915
916 for (i = 0; InitializerOp; i++)
917 {
918 switch (i)
919 {
920 case 0: /* Device Selection [WORD] (_ADR) */
921
922 Descriptor->SpiSerialBus.DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer;
923 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
924 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DeviceSelection));
925 break;
926
927 case 1: /* Device Polarity [Flag] (_DPL) */
928
929 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 1, 0);
930 RsCreateBitField (InitializerOp, ACPI_RESTAG_DEVICEPOLARITY,
931 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 1);
932 break;
933
934 case 2: /* Wire Mode [Flag] (_MOD) */
935
936 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
937 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
938 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 0);
939 break;
940
941 case 3: /* Device Bit Length [BYTE] (_LEN) */
942
943 Descriptor->SpiSerialBus.DataBitLength = (UINT8) InitializerOp->Asl.Value.Integer;
944 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
945 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DataBitLength));
946 break;
947
948 case 4: /* Slave Mode [Flag] (_SLV) */
949
950 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 0, 0);
951 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
952 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.Flags), 0);
953 break;
954
955 case 5: /* Connection Speed [DWORD] (_SPE) */
956
957 Descriptor->SpiSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
958 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
959 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ConnectionSpeed));
960 break;
961
962 case 6: /* Clock Polarity [BYTE] (_POL) */
963
964 Descriptor->SpiSerialBus.ClockPolarity = (UINT8) InitializerOp->Asl.Value.Integer;
965 RsCreateByteField (InitializerOp, ACPI_RESTAG_POLARITY,
966 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPolarity));
967 break;
968
969 case 7: /* Clock Phase [BYTE] (_PHA) */
970
971 Descriptor->SpiSerialBus.ClockPhase = (UINT8) InitializerOp->Asl.Value.Integer;
972 RsCreateByteField (InitializerOp, ACPI_RESTAG_PHASE,
973 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPhase));
974 break;
975
976 case 8: /* ResSource [Optional Field - STRING] */
977
978 if (ResSourceLength)
979 {
980 /* Copy string to the descriptor */
981
982 strcpy (ResourceSource,
983 InitializerOp->Asl.Value.String);
984 }
985 break;
986
987 case 9: /* Resource Index */
988
989 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
990 {
991 Descriptor->SpiSerialBus.ResSourceIndex =
992 (UINT8) InitializerOp->Asl.Value.Integer;
993 }
994 break;
995
996 case 10: /* Resource Usage (consumer/producer) */
997
998 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 1, 1);
999 break;
1000
1001 case 11: /* Resource Tag (Descriptor Name) */
1002
1003 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
1004 break;
1005
1006 case 12: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
1007
1008 RsGetVendorData (InitializerOp, VendorData,
1009 CurrentByteOffset + sizeof (AML_RESOURCE_SPI_SERIALBUS));
1010 break;
1011
1012 default: /* Ignore any extra nodes */
1013
1014 break;
1015 }
1016
1017 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1018 }
1019
1020 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
1021 return (Rnode);
1022 }
1023
1024
1025 /*******************************************************************************
1026 *
1027 * FUNCTION: RsDoUartSerialBusDescriptor
1028 *
1029 * PARAMETERS: Info - Parse Op and resource template offset
1030 *
1031 * RETURN: Completed resource node
1032 *
1033 * DESCRIPTION: Construct a long "UART Serial Bus" descriptor
1034 *
1035 ******************************************************************************/
1036
1037 ASL_RESOURCE_NODE *
RsDoUartSerialBusDescriptor(ASL_RESOURCE_INFO * Info)1038 RsDoUartSerialBusDescriptor (
1039 ASL_RESOURCE_INFO *Info)
1040 {
1041 AML_RESOURCE *Descriptor;
1042 ACPI_PARSE_OBJECT *InitializerOp;
1043 ASL_RESOURCE_NODE *Rnode;
1044 char *ResourceSource = NULL;
1045 UINT8 *VendorData = NULL;
1046 UINT16 ResSourceLength;
1047 UINT16 VendorLength;
1048 UINT16 DescriptorSize;
1049 UINT32 CurrentByteOffset;
1050 UINT32 i;
1051
1052
1053 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
1054 CurrentByteOffset = Info->CurrentByteOffset;
1055
1056 /*
1057 * Calculate lengths for fields that have variable length:
1058 * 1) Resource Source string
1059 * 2) Vendor Data buffer
1060 */
1061 ResSourceLength = RsGetStringDataLength (InitializerOp);
1062 VendorLength = RsGetBufferDataLength (InitializerOp);
1063
1064 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) +
1065 ResSourceLength + VendorLength;
1066
1067 /* Allocate the local resource node and initialize */
1068
1069 Rnode = RsAllocateResourceNode (DescriptorSize +
1070 sizeof (AML_RESOURCE_LARGE_HEADER));
1071
1072 Descriptor = Rnode->Buffer;
1073 Descriptor->UartSerialBus.ResourceLength = DescriptorSize;
1074 Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
1075 Descriptor->UartSerialBus.RevisionId = AML_RESOURCE_UART_REVISION;
1076 Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION;
1077 Descriptor->UartSerialBus.Type = AML_RESOURCE_UART_SERIALBUSTYPE;
1078 Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength;
1079
1080 /* Build pointers to optional areas */
1081
1082 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS));
1083 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
1084
1085 DbgPrint (ASL_DEBUG_OUTPUT,
1086 "%16s - Actual: %.2X, Base: %.2X, ResLen: "
1087 "%.2X, VendLen: %.2X, TypLen: %.2X\n",
1088 "UartSerialBus", Descriptor->UartSerialBus.ResourceLength,
1089 (UINT16) sizeof (AML_RESOURCE_UART_SERIALBUS), ResSourceLength,
1090 VendorLength, Descriptor->UartSerialBus.TypeDataLength);
1091
1092 /* Process all child initialization nodes */
1093
1094 for (i = 0; InitializerOp; i++)
1095 {
1096 switch (i)
1097 {
1098 case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */
1099
1100 Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer;
1101 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
1102 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate));
1103 break;
1104
1105 case 1: /* Bits Per Byte [Flags] (_LEN) */
1106
1107 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3);
1108 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH,
1109 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3);
1110 break;
1111
1112 case 2: /* Stop Bits [Flags] (_STB) */
1113
1114 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1);
1115 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS,
1116 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2);
1117 break;
1118
1119 case 3: /* Lines In Use [BYTE] (_LIN) */
1120
1121 Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer;
1122 RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE,
1123 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled));
1124 break;
1125
1126 case 4: /* Endianness [Flag] (_END) */
1127
1128 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0);
1129 RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS,
1130 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7);
1131 break;
1132
1133 case 5: /* Parity [BYTE] (_PAR) */
1134
1135 Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer;
1136 RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY,
1137 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity));
1138 break;
1139
1140 case 6: /* Flow Control [Flags] (_FLC) */
1141
1142 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
1143 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL,
1144 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2);
1145 break;
1146
1147 case 7: /* Rx Buffer Size [WORD] (_RXL) */
1148
1149 Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1150 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX,
1151 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize));
1152 break;
1153
1154 case 8: /* Tx Buffer Size [WORD] (_TXL) */
1155
1156 Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1157 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX,
1158 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize));
1159 break;
1160
1161 case 9: /* ResSource [Optional Field - STRING] */
1162
1163 if (ResSourceLength)
1164 {
1165 /* Copy string to the descriptor */
1166
1167 strcpy (ResourceSource,
1168 InitializerOp->Asl.Value.String);
1169 }
1170 break;
1171
1172 case 10: /* Resource Index */
1173
1174 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1175 {
1176 Descriptor->UartSerialBus.ResSourceIndex =
1177 (UINT8) InitializerOp->Asl.Value.Integer;
1178 }
1179 break;
1180
1181 case 11: /* Resource Usage (consumer/producer) */
1182
1183 RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1);
1184
1185 /*
1186 * Slave Mode [Flag] (_SLV)
1187 *
1188 * Note: There is no SlaveMode argument to the UartSerialBus macro, but
1189 * we add this name anyway to allow the flag to be set by ASL in the
1190 * rare case where there is a slave mode associated with the UART.
1191 */
1192 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
1193 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0);
1194 break;
1195
1196 case 12: /* Resource Tag (Descriptor Name) */
1197
1198 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
1199 break;
1200
1201 case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
1202
1203 RsGetVendorData (InitializerOp, VendorData,
1204 CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS));
1205 break;
1206
1207 default: /* Ignore any extra nodes */
1208
1209 break;
1210 }
1211
1212 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1213 }
1214
1215 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
1216 return (Rnode);
1217 }
1218