1 /******************************************************************************
2 *
3 * Module Name: aslrestype2s - Serial Large resource descriptors
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2015, 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 <contrib/dev/acpica/compiler/aslcompiler.h>
45 #include "aslcompiler.y.h"
46 #include <contrib/dev/acpica/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 + sizeof (AML_RESOURCE_LARGE_HEADER));
317
318 Descriptor = Rnode->Buffer;
319 Descriptor->Gpio.ResourceLength = DescriptorSize;
320 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
321 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
322 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_INT;
323
324 /* Build pointers to optional areas */
325
326 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO));
327 PinList = InterruptList;
328 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
329 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
330
331 /* Setup offsets within the descriptor */
332
333 Descriptor->Gpio.PinTableOffset = (UINT16)
334 ACPI_PTR_DIFF (InterruptList, Descriptor);
335
336 Descriptor->Gpio.ResSourceOffset = (UINT16)
337 ACPI_PTR_DIFF (ResourceSource, Descriptor);
338
339 DbgPrint (ASL_DEBUG_OUTPUT,
340 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, IntLen: %.2X\n",
341 "GpioInt", Descriptor->Gpio.ResourceLength, (UINT16) sizeof (AML_RESOURCE_GPIO),
342 ResSourceLength, VendorLength, InterruptLength);
343
344 /* Process all child initialization nodes */
345
346 for (i = 0; InitializerOp; i++)
347 {
348 switch (i)
349 {
350 case 0: /* Interrupt Mode - edge/level [Flag] (_MOD) */
351
352 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
353 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
354 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0);
355 break;
356
357 case 1: /* Interrupt Polarity - Active high/low [Flags] (_POL) */
358
359 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 1, 0);
360 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_POLARITY,
361 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 1, 2);
362 break;
363
364 case 2: /* Share Type - Default: exclusive (0) [Flags] (_SHR) */
365
366 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
367 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
368 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3, 2);
369 break;
370
371 case 3: /* Pin Config [BYTE] (_PPI) */
372
373 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
374 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
375 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
376 break;
377
378 case 4: /* Debounce Timeout [WORD] (_DBT) */
379
380 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
381 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
382 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
383 break;
384
385 case 5: /* ResSource [Optional Field - STRING] */
386
387 if (ResSourceLength)
388 {
389 /* Copy string to the descriptor */
390
391 strcpy (ResourceSource,
392 InitializerOp->Asl.Value.String);
393 }
394 break;
395
396 case 6: /* Resource Index */
397
398 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
399 {
400 Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
401 }
402 break;
403
404 case 7: /* Resource Usage (consumer/producer) */
405
406 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
407 break;
408
409 case 8: /* Resource Tag (Descriptor Name) */
410
411 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
412 break;
413
414 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
415
416 /*
417 * Always set the VendorOffset even if there is no Vendor Data.
418 * This field is required in order to calculate the length
419 * of the ResourceSource at runtime.
420 */
421 Descriptor->Gpio.VendorOffset = (UINT16)
422 ACPI_PTR_DIFF (VendorData, Descriptor);
423
424 if (RsGetVendorData (InitializerOp, VendorData,
425 (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
426 {
427 Descriptor->Gpio.VendorLength = VendorLength;
428 }
429 break;
430
431 default:
432 /*
433 * PINs come through here, repeatedly. Each PIN must be a DWORD.
434 * NOTE: there is no "length" field for this, so from ACPI spec:
435 * The number of pins in the table can be calculated from:
436 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
437 * (implies resource source must immediately follow the pin list.)
438 * Name: _PIN
439 */
440 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
441 InterruptList++;
442 PinCount++;
443
444 /* Case 10: First interrupt number in list */
445
446 if (i == 10)
447 {
448 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
449 {
450 /* Must be at least one interrupt */
451
452 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
453 InitializerOp, NULL);
454 }
455
456 /* Check now for duplicates in list */
457
458 RsCheckListForDuplicates (InitializerOp);
459
460 /* Create a named field at the start of the list */
461
462 RsCreateDwordField (InitializerOp, ACPI_RESTAG_PIN,
463 CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
464 }
465 break;
466 }
467
468 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
469 }
470
471 MpSaveGpioInfo (Info->MappingOp, Descriptor, PinCount, PinList, ResourceSource);
472 return (Rnode);
473 }
474
475
476 /*******************************************************************************
477 *
478 * FUNCTION: RsDoGpioIoDescriptor
479 *
480 * PARAMETERS: Info - Parse Op and resource template offset
481 *
482 * RETURN: Completed resource node
483 *
484 * DESCRIPTION: Construct a long "GpioIo" descriptor
485 *
486 ******************************************************************************/
487
488 ASL_RESOURCE_NODE *
RsDoGpioIoDescriptor(ASL_RESOURCE_INFO * Info)489 RsDoGpioIoDescriptor (
490 ASL_RESOURCE_INFO *Info)
491 {
492 AML_RESOURCE *Descriptor;
493 ACPI_PARSE_OBJECT *InitializerOp;
494 ASL_RESOURCE_NODE *Rnode;
495 char *ResourceSource = NULL;
496 UINT8 *VendorData = NULL;
497 UINT16 *InterruptList = NULL;
498 UINT16 *PinList = NULL;
499 UINT16 ResSourceLength;
500 UINT16 VendorLength;
501 UINT16 InterruptLength;
502 UINT16 DescriptorSize;
503 UINT32 CurrentByteOffset;
504 UINT32 PinCount = 0;
505 UINT32 i;
506
507
508 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
509 CurrentByteOffset = Info->CurrentByteOffset;
510
511 /*
512 * Calculate lengths for fields that have variable length:
513 * 1) Resource Source string
514 * 2) Vendor Data buffer
515 * 3) PIN (interrupt) list
516 */
517 ResSourceLength = RsGetStringDataLength (InitializerOp);
518 VendorLength = RsGetBufferDataLength (InitializerOp);
519 InterruptLength = RsGetInterruptDataLength (InitializerOp);
520 PinList = InterruptList;
521
522 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
523 ResSourceLength + VendorLength + InterruptLength;
524
525 /* Allocate the local resource node and initialize */
526
527 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
528
529 Descriptor = Rnode->Buffer;
530 Descriptor->Gpio.ResourceLength = DescriptorSize;
531 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
532 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
533 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_IO;
534
535 /* Build pointers to optional areas */
536
537 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO));
538 PinList = InterruptList;
539 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
540 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
541
542 /* Setup offsets within the descriptor */
543
544 Descriptor->Gpio.PinTableOffset = (UINT16)
545 ACPI_PTR_DIFF (InterruptList, Descriptor);
546
547 Descriptor->Gpio.ResSourceOffset = (UINT16)
548 ACPI_PTR_DIFF (ResourceSource, Descriptor);
549
550 DbgPrint (ASL_DEBUG_OUTPUT,
551 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, IntLen: %.2X\n",
552 "GpioIo", Descriptor->Gpio.ResourceLength, (UINT16) sizeof (AML_RESOURCE_GPIO),
553 ResSourceLength, VendorLength, InterruptLength);
554
555 /* Process all child initialization nodes */
556
557 for (i = 0; InitializerOp; i++)
558 {
559 switch (i)
560 {
561 case 0: /* Share Type [Flags] (_SHR) */
562
563 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
564 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
565 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3);
566 break;
567
568 case 1: /* Pin Config [BYTE] (_PPI) */
569
570 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
571 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
572 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
573 break;
574
575 case 2: /* Debounce Timeout [WORD] (_DBT) */
576
577 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
578 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
579 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
580 break;
581
582 case 3: /* Drive Strength [WORD] (_DRS) */
583
584 Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer;
585 RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH,
586 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength));
587 break;
588
589 case 4: /* I/O Restriction [Flag] (_IOR) */
590
591 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
592 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION,
593 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2);
594 break;
595
596 case 5: /* ResSource [Optional Field - STRING] */
597
598 if (ResSourceLength)
599 {
600 /* Copy string to the descriptor */
601
602 strcpy (ResourceSource,
603 InitializerOp->Asl.Value.String);
604 }
605 break;
606
607 case 6: /* Resource Index */
608
609 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
610 {
611 Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
612 }
613 break;
614
615 case 7: /* Resource Usage (consumer/producer) */
616
617 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
618 break;
619
620 case 8: /* Resource Tag (Descriptor Name) */
621
622 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
623 break;
624
625 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
626 /*
627 * Always set the VendorOffset even if there is no Vendor Data.
628 * This field is required in order to calculate the length
629 * of the ResourceSource at runtime.
630 */
631 Descriptor->Gpio.VendorOffset = (UINT16)
632 ACPI_PTR_DIFF (VendorData, Descriptor);
633
634 if (RsGetVendorData (InitializerOp, VendorData,
635 (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
636 {
637 Descriptor->Gpio.VendorLength = VendorLength;
638 }
639 break;
640
641 default:
642 /*
643 * PINs come through here, repeatedly. Each PIN must be a DWORD.
644 * NOTE: there is no "length" field for this, so from ACPI spec:
645 * The number of pins in the table can be calculated from:
646 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
647 * (implies resource source must immediately follow the pin list.)
648 * Name: _PIN
649 */
650 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
651 InterruptList++;
652 PinCount++;
653
654 /* Case 10: First interrupt number in list */
655
656 if (i == 10)
657 {
658 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
659 {
660 /* Must be at least one interrupt */
661
662 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
663 InitializerOp, NULL);
664 }
665
666 /* Check now for duplicates in list */
667
668 RsCheckListForDuplicates (InitializerOp);
669
670 /* Create a named field at the start of the list */
671
672 RsCreateDwordField (InitializerOp, ACPI_RESTAG_PIN,
673 CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
674 }
675 break;
676 }
677
678 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
679 }
680
681 MpSaveGpioInfo (Info->MappingOp, Descriptor, PinCount, PinList, ResourceSource);
682 return (Rnode);
683 }
684
685
686 /*******************************************************************************
687 *
688 * FUNCTION: RsDoI2cSerialBusDescriptor
689 *
690 * PARAMETERS: Info - Parse Op and resource template offset
691 *
692 * RETURN: Completed resource node
693 *
694 * DESCRIPTION: Construct a long "I2cSerialBus" descriptor
695 *
696 ******************************************************************************/
697
698 ASL_RESOURCE_NODE *
RsDoI2cSerialBusDescriptor(ASL_RESOURCE_INFO * Info)699 RsDoI2cSerialBusDescriptor (
700 ASL_RESOURCE_INFO *Info)
701 {
702 AML_RESOURCE *Descriptor;
703 ACPI_PARSE_OBJECT *InitializerOp;
704 ASL_RESOURCE_NODE *Rnode;
705 char *ResourceSource = NULL;
706 UINT8 *VendorData = NULL;
707 UINT16 ResSourceLength;
708 UINT16 VendorLength;
709 UINT16 DescriptorSize;
710 UINT32 CurrentByteOffset;
711 UINT32 i;
712
713
714 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
715 CurrentByteOffset = Info->CurrentByteOffset;
716
717 /*
718 * Calculate lengths for fields that have variable length:
719 * 1) Resource Source string
720 * 2) Vendor Data buffer
721 */
722 ResSourceLength = RsGetStringDataLength (InitializerOp);
723 VendorLength = RsGetBufferDataLength (InitializerOp);
724
725 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS) +
726 ResSourceLength + VendorLength;
727
728 /* Allocate the local resource node and initialize */
729
730 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
731
732 Descriptor = Rnode->Buffer;
733 Descriptor->I2cSerialBus.ResourceLength = DescriptorSize;
734 Descriptor->I2cSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
735 Descriptor->I2cSerialBus.RevisionId = AML_RESOURCE_I2C_REVISION;
736 Descriptor->I2cSerialBus.TypeRevisionId = AML_RESOURCE_I2C_TYPE_REVISION;
737 Descriptor->I2cSerialBus.Type = AML_RESOURCE_I2C_SERIALBUSTYPE;
738 Descriptor->I2cSerialBus.TypeDataLength = AML_RESOURCE_I2C_MIN_DATA_LEN + VendorLength;
739
740 /* Build pointers to optional areas */
741
742 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_I2C_SERIALBUS));
743 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
744
745 DbgPrint (ASL_DEBUG_OUTPUT,
746 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
747 "I2cSerialBus", Descriptor->I2cSerialBus.ResourceLength,
748 (UINT16) sizeof (AML_RESOURCE_I2C_SERIALBUS), ResSourceLength,
749 VendorLength, Descriptor->I2cSerialBus.TypeDataLength);
750
751 /* Process all child initialization nodes */
752
753 for (i = 0; InitializerOp; i++)
754 {
755 switch (i)
756 {
757 case 0: /* Slave Address [WORD] (_ADR) */
758
759 Descriptor->I2cSerialBus.SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer;
760 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
761 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.SlaveAddress));
762 break;
763
764 case 1: /* Slave Mode [Flag] (_SLV) */
765
766 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 0, 0);
767 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
768 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.Flags), 0);
769 break;
770
771 case 2: /* Connection Speed [DWORD] (_SPE) */
772
773 Descriptor->I2cSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
774 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
775 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.ConnectionSpeed));
776 break;
777
778 case 3: /* Addressing Mode [Flag] (_MOD) */
779
780 RsSetFlagBits16 (&Descriptor->I2cSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
781 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
782 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.TypeSpecificFlags), 0);
783 break;
784
785 case 4: /* ResSource [Optional Field - STRING] */
786
787 if (ResSourceLength)
788 {
789 /* Copy string to the descriptor */
790
791 strcpy (ResourceSource,
792 InitializerOp->Asl.Value.String);
793 }
794 break;
795
796 case 5: /* Resource Index */
797
798 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
799 {
800 Descriptor->I2cSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
801 }
802 break;
803
804 case 6: /* Resource Usage (consumer/producer) */
805
806 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 1, 1);
807 break;
808
809 case 7: /* Resource Tag (Descriptor Name) */
810
811 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
812 break;
813
814 case 8: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
815
816 RsGetVendorData (InitializerOp, VendorData,
817 CurrentByteOffset + sizeof (AML_RESOURCE_I2C_SERIALBUS));
818 break;
819
820 default: /* Ignore any extra nodes */
821
822 break;
823 }
824
825 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
826 }
827
828 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
829 return (Rnode);
830 }
831
832
833 /*******************************************************************************
834 *
835 * FUNCTION: RsDoSpiSerialBusDescriptor
836 *
837 * PARAMETERS: Info - Parse Op and resource template offset
838 *
839 * RETURN: Completed resource node
840 *
841 * DESCRIPTION: Construct a long "SPI Serial Bus" descriptor
842 *
843 ******************************************************************************/
844
845 ASL_RESOURCE_NODE *
RsDoSpiSerialBusDescriptor(ASL_RESOURCE_INFO * Info)846 RsDoSpiSerialBusDescriptor (
847 ASL_RESOURCE_INFO *Info)
848 {
849 AML_RESOURCE *Descriptor;
850 ACPI_PARSE_OBJECT *InitializerOp;
851 ASL_RESOURCE_NODE *Rnode;
852 char *ResourceSource = NULL;
853 UINT8 *VendorData = NULL;
854 UINT16 ResSourceLength;
855 UINT16 VendorLength;
856 UINT16 DescriptorSize;
857 UINT32 CurrentByteOffset;
858 UINT32 i;
859
860
861 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
862 CurrentByteOffset = Info->CurrentByteOffset;
863
864 /*
865 * Calculate lengths for fields that have variable length:
866 * 1) Resource Source string
867 * 2) Vendor Data buffer
868 */
869 ResSourceLength = RsGetStringDataLength (InitializerOp);
870 VendorLength = RsGetBufferDataLength (InitializerOp);
871
872 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS) +
873 ResSourceLength + VendorLength;
874
875 /* Allocate the local resource node and initialize */
876
877 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
878
879 Descriptor = Rnode->Buffer;
880 Descriptor->SpiSerialBus.ResourceLength = DescriptorSize;
881 Descriptor->SpiSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
882 Descriptor->SpiSerialBus.RevisionId = AML_RESOURCE_SPI_REVISION;
883 Descriptor->SpiSerialBus.TypeRevisionId = AML_RESOURCE_SPI_TYPE_REVISION;
884 Descriptor->SpiSerialBus.Type = AML_RESOURCE_SPI_SERIALBUSTYPE;
885 Descriptor->SpiSerialBus.TypeDataLength = AML_RESOURCE_SPI_MIN_DATA_LEN + VendorLength;
886
887 /* Build pointers to optional areas */
888
889 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_SPI_SERIALBUS));
890 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
891
892 DbgPrint (ASL_DEBUG_OUTPUT,
893 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
894 "SpiSerialBus", Descriptor->SpiSerialBus.ResourceLength,
895 (UINT16) sizeof (AML_RESOURCE_SPI_SERIALBUS), ResSourceLength,
896 VendorLength, Descriptor->SpiSerialBus.TypeDataLength);
897
898 /* Process all child initialization nodes */
899
900 for (i = 0; InitializerOp; i++)
901 {
902 switch (i)
903 {
904 case 0: /* Device Selection [WORD] (_ADR) */
905
906 Descriptor->SpiSerialBus.DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer;
907 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
908 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DeviceSelection));
909 break;
910
911 case 1: /* Device Polarity [Flag] (_DPL) */
912
913 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 1, 0);
914 RsCreateBitField (InitializerOp, ACPI_RESTAG_DEVICEPOLARITY,
915 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 1);
916 break;
917
918 case 2: /* Wire Mode [Flag] (_MOD) */
919
920 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
921 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
922 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 0);
923 break;
924
925 case 3: /* Device Bit Length [BYTE] (_LEN) */
926
927 Descriptor->SpiSerialBus.DataBitLength = (UINT8) InitializerOp->Asl.Value.Integer;
928 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
929 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DataBitLength));
930 break;
931
932 case 4: /* Slave Mode [Flag] (_SLV) */
933
934 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 0, 0);
935 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
936 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.Flags), 0);
937 break;
938
939 case 5: /* Connection Speed [DWORD] (_SPE) */
940
941 Descriptor->SpiSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
942 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
943 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ConnectionSpeed));
944 break;
945
946 case 6: /* Clock Polarity [BYTE] (_POL) */
947
948 Descriptor->SpiSerialBus.ClockPolarity = (UINT8) InitializerOp->Asl.Value.Integer;
949 RsCreateByteField (InitializerOp, ACPI_RESTAG_POLARITY,
950 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPolarity));
951 break;
952
953 case 7: /* Clock Phase [BYTE] (_PHA) */
954
955 Descriptor->SpiSerialBus.ClockPhase = (UINT8) InitializerOp->Asl.Value.Integer;
956 RsCreateByteField (InitializerOp, ACPI_RESTAG_PHASE,
957 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPhase));
958 break;
959
960 case 8: /* ResSource [Optional Field - STRING] */
961
962 if (ResSourceLength)
963 {
964 /* Copy string to the descriptor */
965
966 strcpy (ResourceSource,
967 InitializerOp->Asl.Value.String);
968 }
969 break;
970
971 case 9: /* Resource Index */
972
973 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
974 {
975 Descriptor->SpiSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
976 }
977 break;
978
979 case 10: /* Resource Usage (consumer/producer) */
980
981 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 1, 1);
982 break;
983
984 case 11: /* Resource Tag (Descriptor Name) */
985
986 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
987 break;
988
989 case 12: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
990
991 RsGetVendorData (InitializerOp, VendorData,
992 CurrentByteOffset + sizeof (AML_RESOURCE_SPI_SERIALBUS));
993 break;
994
995 default: /* Ignore any extra nodes */
996
997 break;
998 }
999
1000 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1001 }
1002
1003 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
1004 return (Rnode);
1005 }
1006
1007
1008 /*******************************************************************************
1009 *
1010 * FUNCTION: RsDoUartSerialBusDescriptor
1011 *
1012 * PARAMETERS: Info - Parse Op and resource template offset
1013 *
1014 * RETURN: Completed resource node
1015 *
1016 * DESCRIPTION: Construct a long "UART Serial Bus" descriptor
1017 *
1018 ******************************************************************************/
1019
1020 ASL_RESOURCE_NODE *
RsDoUartSerialBusDescriptor(ASL_RESOURCE_INFO * Info)1021 RsDoUartSerialBusDescriptor (
1022 ASL_RESOURCE_INFO *Info)
1023 {
1024 AML_RESOURCE *Descriptor;
1025 ACPI_PARSE_OBJECT *InitializerOp;
1026 ASL_RESOURCE_NODE *Rnode;
1027 char *ResourceSource = NULL;
1028 UINT8 *VendorData = NULL;
1029 UINT16 ResSourceLength;
1030 UINT16 VendorLength;
1031 UINT16 DescriptorSize;
1032 UINT32 CurrentByteOffset;
1033 UINT32 i;
1034
1035
1036 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
1037 CurrentByteOffset = Info->CurrentByteOffset;
1038
1039 /*
1040 * Calculate lengths for fields that have variable length:
1041 * 1) Resource Source string
1042 * 2) Vendor Data buffer
1043 */
1044 ResSourceLength = RsGetStringDataLength (InitializerOp);
1045 VendorLength = RsGetBufferDataLength (InitializerOp);
1046
1047 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) +
1048 ResSourceLength + VendorLength;
1049
1050 /* Allocate the local resource node and initialize */
1051
1052 Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
1053
1054 Descriptor = Rnode->Buffer;
1055 Descriptor->UartSerialBus.ResourceLength = DescriptorSize;
1056 Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
1057 Descriptor->UartSerialBus.RevisionId = AML_RESOURCE_UART_REVISION;
1058 Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION;
1059 Descriptor->UartSerialBus.Type = AML_RESOURCE_UART_SERIALBUSTYPE;
1060 Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength;
1061
1062 /* Build pointers to optional areas */
1063
1064 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS));
1065 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
1066
1067 DbgPrint (ASL_DEBUG_OUTPUT,
1068 "%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
1069 "UartSerialBus", Descriptor->UartSerialBus.ResourceLength,
1070 (UINT16) sizeof (AML_RESOURCE_UART_SERIALBUS), ResSourceLength,
1071 VendorLength, Descriptor->UartSerialBus.TypeDataLength);
1072
1073 /* Process all child initialization nodes */
1074
1075 for (i = 0; InitializerOp; i++)
1076 {
1077 switch (i)
1078 {
1079 case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */
1080
1081 Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer;
1082 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
1083 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate));
1084 break;
1085
1086 case 1: /* Bits Per Byte [Flags] (_LEN) */
1087
1088 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3);
1089 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH,
1090 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3);
1091 break;
1092
1093 case 2: /* Stop Bits [Flags] (_STB) */
1094
1095 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1);
1096 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS,
1097 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2);
1098 break;
1099
1100 case 3: /* Lines In Use [BYTE] (_LIN) */
1101
1102 Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer;
1103 RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE,
1104 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled));
1105 break;
1106
1107 case 4: /* Endianness [Flag] (_END) */
1108
1109 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0);
1110 RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS,
1111 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7);
1112 break;
1113
1114 case 5: /* Parity [BYTE] (_PAR) */
1115
1116 Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer;
1117 RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY,
1118 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity));
1119 break;
1120
1121 case 6: /* Flow Control [Flags] (_FLC) */
1122
1123 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
1124 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL,
1125 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2);
1126 break;
1127
1128 case 7: /* Rx Buffer Size [WORD] (_RXL) */
1129
1130 Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1131 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX,
1132 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize));
1133 break;
1134
1135 case 8: /* Tx Buffer Size [WORD] (_TXL) */
1136
1137 Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1138 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX,
1139 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize));
1140 break;
1141
1142 case 9: /* ResSource [Optional Field - STRING] */
1143
1144 if (ResSourceLength)
1145 {
1146 /* Copy string to the descriptor */
1147
1148 strcpy (ResourceSource,
1149 InitializerOp->Asl.Value.String);
1150 }
1151 break;
1152
1153 case 10: /* Resource Index */
1154
1155 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1156 {
1157 Descriptor->UartSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
1158 }
1159 break;
1160
1161 case 11: /* Resource Usage (consumer/producer) */
1162
1163 RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1);
1164
1165 /*
1166 * Slave Mode [Flag] (_SLV)
1167 *
1168 * Note: There is no SlaveMode argument to the UartSerialBus macro, but
1169 * we add this name anyway to allow the flag to be set by ASL in the
1170 * rare case where there is a slave mode associated with the UART.
1171 */
1172 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
1173 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0);
1174 break;
1175
1176 case 12: /* Resource Tag (Descriptor Name) */
1177
1178 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
1179 break;
1180
1181 case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
1182
1183 RsGetVendorData (InitializerOp, VendorData,
1184 CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS));
1185 break;
1186
1187 default: /* Ignore any extra nodes */
1188
1189 break;
1190 }
1191
1192 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1193 }
1194
1195 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
1196 return (Rnode);
1197 }
1198