14 * All rights reserved.
15 *
16 * 2. License
17 *
18 * 2.1. This is your license from Intel Corp. under its intellectual property
19 * rights. You may have additional license terms from the party that provided
20 * you this software, covering your right to use that party's intellectual
21 * property rights.
22 *
23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24 * copy of the source code appearing in this file ("Covered Code") an
25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26 * base code distributed originally by Intel ("Original Intel Code") to copy,
27 * make derivatives, distribute, use and display any portion of the Covered
28 * Code in any form, with the right to sublicense such rights; and
29 *
30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31 * license (with the right to sublicense), under only those claims of Intel
32 * patents that are infringed by the Original Intel Code, to make, use, sell,
33 * offer to sell, and import the Covered Code and derivative works thereof
34 * solely to the minimum extent necessary to exercise the above copyright
35 * license, and in no event shall the patent license extend to any additions
36 * to or modifications of the Original Intel Code. No other license or right
37 * is granted directly or by implication, estoppel or otherwise;
38 *
39 * The above copyright and patent license is granted only if the following
40 * conditions are met:
41 *
42 * 3. Conditions
43 *
44 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45 * Redistribution of source code of any substantial portion of the Covered
46 * Code or modification with rights to further distribute source must include
47 * the above Copyright Notice, the above License, this list of Conditions,
48 * and the following Disclaimer and Export Compliance provision. In addition,
49 * Licensee must cause all Covered Code to which Licensee contributes to
50 * contain a file documenting the changes Licensee made to create that Covered
51 * Code and the date of any change. Licensee must include in that file the
52 * documentation of any changes made by any predecessor Licensee. Licensee
53 * must include a prominent statement that the modification is derived,
54 * directly or indirectly, from Original Intel Code.
55 *
56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57 * Redistribution of source code of any substantial portion of the Covered
58 * Code or modification without rights to further distribute source must
59 * include the following Disclaimer and Export Compliance provision in the
60 * documentation and/or other materials provided with distribution. In
61 * addition, Licensee may not authorize further sublicense of source of any
62 * portion of the Covered Code, and must include terms to the effect that the
63 * license from Licensee to its licensee is limited to the intellectual
64 * property embodied in the software Licensee provides to its licensee, and
65 * not to intellectual property embodied in modifications its licensee may
66 * make.
67 *
68 * 3.3. Redistribution of Executable. Redistribution in executable form of any
69 * substantial portion of the Covered Code or modification must reproduce the
70 * above Copyright Notice, and the following Disclaimer and Export Compliance
71 * provision in the documentation and/or other materials provided with the
72 * distribution.
73 *
74 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * Intel Code.
76 *
77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78 * Intel shall be used in advertising or otherwise to promote the sale, use or
79 * other dealings in products derived from or relating to the Covered Code
80 * without prior written authorization from Intel.
81 *
82 * 4. Disclaimer and Export Compliance
83 *
84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
87 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
88 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * PARTICULAR PURPOSE.
91 *
92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * LIMITED REMEDY.
100 *
101 * 4.3. Licensee shall not export, either directly or indirectly, any of this
102 * software or system incorporating such software without first obtaining any
103 * required license or other approval from the U. S. Department of Commerce or
104 * any other agency or department of the United States Government. In the
105 * event Licensee exports any such software from the United States or
106 * re-exports any such software from a foreign destination, Licensee shall
107 * ensure that the distribution and export/re-export of the software is in
108 * compliance with all laws, regulations, orders, or other restrictions of the
109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110 * any of its subsidiaries will export/re-export any technical data, process,
111 * software, or service, directly or indirectly, to any country for which the
112 * United States government or any agency thereof requires an export license,
113 * other governmental approval, or letter of assurance, without first obtaining
114 * such license, approval or letter.
115 *
116 *****************************************************************************/
117
118
119#include "aslcompiler.h"
120#include "aslcompiler.y.h"
121
122#define _COMPONENT ACPI_COMPILER
123 ACPI_MODULE_NAME ("aslrestype2")
124
125
126/*******************************************************************************
127 *
128 * FUNCTION: RsGetStringDataLength
129 *
130 * PARAMETERS: InitializerOp - Start of a subtree of init nodes
131 *
132 * RETURN: Valid string length if a string node is found
133 *
134 * DESCRIPTION: In a list of peer nodes, find the first one that contains a
135 * string and return the length of the string.
136 *
137 ******************************************************************************/
138
139UINT32
140RsGetStringDataLength (
141 ACPI_PARSE_OBJECT *InitializerOp)
142{
143
144 while (InitializerOp)
145 {
146 if (InitializerOp->Asl.ParseOpcode == PARSEOP_STRING_LITERAL)
147 {
148 return (strlen (InitializerOp->Asl.Value.String) + 1);
149 }
150 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
151 }
152
153 return 0;
154}
155
156
157/*******************************************************************************
158 *
159 * FUNCTION: RsDoDwordIoDescriptor
160 *
161 * PARAMETERS: Op - Parent resource descriptor parse node
162 * CurrentByteOffset - Offset into the resource template AML
163 * buffer (to track references to the desc)
164 *
165 * RETURN: Completed resource node
166 *
167 * DESCRIPTION: Construct a long "DwordIO" descriptor
168 *
169 ******************************************************************************/
170
171ASL_RESOURCE_NODE *
172RsDoDwordIoDescriptor (
173 ACPI_PARSE_OBJECT *Op,
174 UINT32 CurrentByteOffset)
175{
176 ASL_RESOURCE_DESC *Descriptor;
177 ACPI_PARSE_OBJECT *InitializerOp;
178 ASL_RESOURCE_NODE *Rnode;
179 UINT32 StringLength = 0;
180 UINT32 OptionIndex = 0;
181 UINT32 i;
182
183
184 InitializerOp = Op->Asl.Child;
185 StringLength = RsGetStringDataLength (InitializerOp);
186
187 Rnode = RsAllocateResourceNode (sizeof (ASL_DWORD_ADDRESS_DESC) +
188 StringLength);
189
190 Descriptor = Rnode->Buffer;
191 Descriptor->Das.DescriptorType = ACPI_RDESC_TYPE_DWORD_ADDRESS_SPACE;
192 Descriptor->Das.ResourceType = ACPI_RESOURCE_TYPE_IO_RANGE;
193
194 /*
195 * Initial descriptor length -- may be enlarged if there are
196 * optional fields present
197 */
198 Descriptor->Das.Length = (UINT16) (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
199 ASL_RESDESC_OFFSET (Das.ResourceType));
200
201 /*
202 * Process all child initialization nodes
203 */
204 for (i = 0; InitializerOp; i++)
205 {
206 switch (i)
207 {
208 case 0: /* Resource Type */
209
210 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 0, 1);
211 break;
212
213 case 1: /* MinType */
214
215 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 2, 0);
216 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
217 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 2);
218 break;
219
220 case 2: /* MaxType */
221
222 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 3, 0);
223 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
224 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 3);
225 break;
226
227 case 3: /* DecodeType */
228
229 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 1, 0);
230 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
231 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 1);
232 break;
233
234 case 4: /* Range Type */
235
236 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 0, 3);
237 RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
238 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 0);
239 break;
240
241 case 5: /* Address Granularity */
242
243 Descriptor->Das.Granularity = (UINT32) InitializerOp->Asl.Value.Integer;
244 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
245 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Granularity));
246 break;
247
248 case 6: /* Address Min */
249
250 Descriptor->Das.AddressMin = (UINT32) InitializerOp->Asl.Value.Integer;
251 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
252 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMin));
253 break;
254
255 case 7: /* Address Max */
256
257 Descriptor->Das.AddressMax = (UINT32) InitializerOp->Asl.Value.Integer;
258 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
259 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMax));
260 break;
261
262 case 8: /* Translation Offset */
263
264 Descriptor->Das.TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer;
265 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
266 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.TranslationOffset));
267 break;
268
269 case 9: /* Address Length */
270
271 Descriptor->Das.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
272 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
273 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressLength));
274 break;
275
276 case 10: /* ResSourceIndex [Optional Field - BYTE] */
277
278 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
279 {
280 Descriptor->Das.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
281 OptionIndex++;
282 Descriptor->Das.Length++;
283 }
284 break;
285
286 case 11: /* ResSource [Optional Field - STRING] */
287
288 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
289 (InitializerOp->Asl.Value.String))
290 {
291 if (StringLength)
292 {
293 Descriptor->Das.Length = (UINT16) (Descriptor->Das.Length + StringLength);
294
295 strcpy ((char *) &Descriptor->Das.OptionalFields[OptionIndex],
296 InitializerOp->Asl.Value.String);
297 }
298 }
299 break;
300
301 case 12: /* ResourceTag */
302
303 UtAttachNamepathToOwner (Op, InitializerOp);
304 break;
305
306 case 13: /* Type */
307
308 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 4, 0);
309 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
310 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 4);
311 break;
312
313 case 14: /* Translation Type */
314
315 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 5, 0);
316 RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
317 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 5);
318 break;
319
320 default:
321
322 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
323 break;
324 }
325
326 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
327 }
328
329 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
330 ASL_RESDESC_OFFSET (Das.DescriptorType))
331 + OptionIndex + StringLength;
332 return (Rnode);
333}
334
335
336/*******************************************************************************
337 *
338 * FUNCTION: RsDoDwordMemoryDescriptor
339 *
340 * PARAMETERS: Op - Parent resource descriptor parse node
341 * CurrentByteOffset - Offset into the resource template AML
342 * buffer (to track references to the desc)
343 *
344 * RETURN: Completed resource node
345 *
346 * DESCRIPTION: Construct a long "DwordMemory" descriptor
347 *
348 ******************************************************************************/
349
350ASL_RESOURCE_NODE *
351RsDoDwordMemoryDescriptor (
352 ACPI_PARSE_OBJECT *Op,
353 UINT32 CurrentByteOffset)
354{
355 ASL_RESOURCE_DESC *Descriptor;
356 ACPI_PARSE_OBJECT *InitializerOp;
357 ASL_RESOURCE_NODE *Rnode;
358 UINT32 StringLength = 0;
359 UINT32 OptionIndex = 0;
360 UINT32 i;
361
362
363 InitializerOp = Op->Asl.Child;
364 StringLength = RsGetStringDataLength (InitializerOp);
365
366 Rnode = RsAllocateResourceNode (sizeof (ASL_DWORD_ADDRESS_DESC) +
367 StringLength);
368
369 Descriptor = Rnode->Buffer;
370 Descriptor->Das.DescriptorType = ACPI_RDESC_TYPE_DWORD_ADDRESS_SPACE;
371 Descriptor->Das.ResourceType = ACPI_RESOURCE_TYPE_MEMORY_RANGE;
372
373 /*
374 * Initial descriptor length -- may be enlarged if there are
375 * optional fields present
376 */
377 Descriptor->Das.Length = (UINT16) (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
378 ASL_RESDESC_OFFSET (Das.ResourceType));
379
380 /*
381 * Process all child initialization nodes
382 */
383 for (i = 0; InitializerOp; i++)
384 {
385 switch (i)
386 {
387 case 0: /* Resource Type */
388
389 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 0, 1);
390 break;
391
392 case 1: /* DecodeType */
393
394 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 1, 0);
395 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
396 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 1);
397 break;
398
399 case 2: /* MinType */
400
401 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 2, 0);
402 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
403 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 2);
404 break;
405
406 case 3: /* MaxType */
407
408 RsSetFlagBits (&Descriptor->Das.Flags, InitializerOp, 3, 0);
409 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
410 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Flags), 3);
411 break;
412
413 case 4: /* Memory Type */
414
415 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 1, 0);
416 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
417 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 1);
418 break;
419
420 case 5: /* Read/Write Type */
421
422 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 0, 1);
423 RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
424 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 0);
425 break;
426
427 case 6: /* Address Granularity */
428
429 Descriptor->Das.Granularity = (UINT32) InitializerOp->Asl.Value.Integer;
430 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
431 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.Granularity));
432 break;
433
434 case 7: /* Min Address */
435
436 Descriptor->Das.AddressMin = (UINT32) InitializerOp->Asl.Value.Integer;
437 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
438 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMin));
439 break;
440
441 case 8: /* Max Address */
442
443 Descriptor->Das.AddressMax = (UINT32) InitializerOp->Asl.Value.Integer;
444 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
445 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressMax));
446 break;
447
448 case 9: /* Translation Offset */
449
450 Descriptor->Das.TranslationOffset = (UINT32) InitializerOp->Asl.Value.Integer;
451 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
452 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.TranslationOffset));
453 break;
454
455 case 10: /* Address Length */
456
457 Descriptor->Das.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
458 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
459 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.AddressLength));
460 break;
461
462 case 11: /* ResSourceIndex [Optional Field - BYTE] */
463
464 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
465 {
466 Descriptor->Das.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
467 OptionIndex++;
468 Descriptor->Das.Length++;
469 }
470 break;
471
472 case 12: /* ResSource [Optional Field - STRING] */
473
474 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
475 (InitializerOp->Asl.Value.String))
476 {
477 if (StringLength)
478 {
479 Descriptor->Das.Length = (UINT16) (Descriptor->Das.Length + StringLength);
480
481 strcpy ((char *) &Descriptor->Das.OptionalFields[OptionIndex],
482 InitializerOp->Asl.Value.String);
483 }
484 }
485 break;
486
487 case 13: /* ResourceTag */
488
489 UtAttachNamepathToOwner (Op, InitializerOp);
490 break;
491
492
493 case 14: /* Address Range */
494
495 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 3, 0);
496 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
497 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 3);
498 break;
499
500 case 15: /* Type */
501
502 RsSetFlagBits (&Descriptor->Das.SpecificFlags, InitializerOp, 5, 0);
503 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
504 CurrentByteOffset + ASL_RESDESC_OFFSET (Das.SpecificFlags), 5);
505 break;
506
507 default:
508
509 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
510 break;
511 }
512
513 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
514 }
515
516 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Das.OptionalFields[0]) -
517 ASL_RESDESC_OFFSET (Das.DescriptorType))
518 + OptionIndex + StringLength;
519 return (Rnode);
520}
521
522
523/*******************************************************************************
524 *
525 * FUNCTION: RsDoQwordIoDescriptor
526 *
527 * PARAMETERS: Op - Parent resource descriptor parse node
528 * CurrentByteOffset - Offset into the resource template AML
529 * buffer (to track references to the desc)
530 *
531 * RETURN: Completed resource node
532 *
533 * DESCRIPTION: Construct a long "QwordIO" descriptor
534 *
535 ******************************************************************************/
536
537ASL_RESOURCE_NODE *
538RsDoQwordIoDescriptor (
539 ACPI_PARSE_OBJECT *Op,
540 UINT32 CurrentByteOffset)
541{
542 ASL_RESOURCE_DESC *Descriptor;
543 ACPI_PARSE_OBJECT *InitializerOp;
544 ASL_RESOURCE_NODE *Rnode;
545 UINT32 StringLength = 0;
546 UINT32 OptionIndex = 0;
547 UINT32 i;
548
549
550 InitializerOp = Op->Asl.Child;
551 StringLength = RsGetStringDataLength (InitializerOp);
552
553 Rnode = RsAllocateResourceNode (sizeof (ASL_QWORD_ADDRESS_DESC) +
554 StringLength);
555
556 Descriptor = Rnode->Buffer;
557 Descriptor->Qas.DescriptorType = ACPI_RDESC_TYPE_QWORD_ADDRESS_SPACE;
558 Descriptor->Qas.ResourceType = ACPI_RESOURCE_TYPE_IO_RANGE;
559
560 /*
561 * Initial descriptor length -- may be enlarged if there are
562 * optional fields present
563 */
564 Descriptor->Qas.Length = (UINT16) (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
565 ASL_RESDESC_OFFSET (Qas.ResourceType));
566 /*
567 * Process all child initialization nodes
568 */
569 for (i = 0; InitializerOp; i++)
570 {
571 switch (i)
572 {
573 case 0: /* Resource Type */
574
575 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 0, 1);
576 break;
577
578 case 1: /* MinType */
579
580 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 2, 0);
581 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
582 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 2);
583 break;
584
585 case 2: /* MaxType */
586
587 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 3, 0);
588 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
589 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 3);
590 break;
591
592 case 3: /* DecodeType */
593
594 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 1, 0);
595 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
596 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 1);
597 break;
598
599 case 4: /* Range Type */
600
601 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 0, 3);
602 RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
603 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 0);
604 break;
605
606 case 5: /* Address Granularity */
607
608 Descriptor->Qas.Granularity = InitializerOp->Asl.Value.Integer;
609 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
610 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Granularity));
611 break;
612
613 case 6: /* Address Min */
614
615 Descriptor->Qas.AddressMin = InitializerOp->Asl.Value.Integer;
616 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
617 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMin));
618 break;
619
620 case 7: /* Address Max */
621
622 Descriptor->Qas.AddressMax = InitializerOp->Asl.Value.Integer;
623 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
624 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMax));
625 break;
626
627 case 8: /* Translation Offset */
628
629 Descriptor->Qas.TranslationOffset = InitializerOp->Asl.Value.Integer;
630 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
631 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.TranslationOffset));
632 break;
633
634 case 9: /* Address Length */
635
636 Descriptor->Qas.AddressLength = InitializerOp->Asl.Value.Integer;
637 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
638 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressLength));
639 break;
640
641 case 10: /* ResSourceIndex [Optional Field - BYTE] */
642
643 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
644 {
645 Descriptor->Qas.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
646 OptionIndex++;
647 Descriptor->Qas.Length++;
648 }
649 break;
650
651 case 11: /* ResSource [Optional Field - STRING] */
652
653 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
654 (InitializerOp->Asl.Value.String))
655 {
656 if (StringLength)
657 {
658 Descriptor->Qas.Length = (UINT16) (Descriptor->Qas.Length + StringLength);
659
660 strcpy ((char *) &Descriptor->Qas.OptionalFields[OptionIndex],
661 InitializerOp->Asl.Value.String);
662 }
663 }
664 break;
665
666 case 12: /* ResourceTag */
667
668 UtAttachNamepathToOwner (Op, InitializerOp);
669 break;
670
671 case 13: /* Type */
672
673 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 4, 0);
674 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
675 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 4);
676 break;
677
678 case 14: /* Translation Type */
679
680 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 5, 0);
681 RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
682 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 5);
683 break;
684
685 default:
686
687 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
688 break;
689 }
690
691 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
692 }
693
694 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
695 ASL_RESDESC_OFFSET (Qas.DescriptorType))
696 + OptionIndex + StringLength;
697 return (Rnode);
698}
699
700
701/*******************************************************************************
702 *
703 * FUNCTION: RsDoQwordMemoryDescriptor
704 *
705 * PARAMETERS: Op - Parent resource descriptor parse node
706 * CurrentByteOffset - Offset into the resource template AML
707 * buffer (to track references to the desc)
708 *
709 * RETURN: Completed resource node
710 *
711 * DESCRIPTION: Construct a long "QwordMemory" descriptor
712 *
713 ******************************************************************************/
714
715ASL_RESOURCE_NODE *
716RsDoQwordMemoryDescriptor (
717 ACPI_PARSE_OBJECT *Op,
718 UINT32 CurrentByteOffset)
719{
720 ASL_RESOURCE_DESC *Descriptor;
721 ACPI_PARSE_OBJECT *InitializerOp;
722 ASL_RESOURCE_NODE *Rnode;
723 UINT32 StringLength = 0;
724 UINT32 OptionIndex = 0;
725 UINT32 i;
726
727
728 InitializerOp = Op->Asl.Child;
729 StringLength = RsGetStringDataLength (InitializerOp);
730
731 Rnode = RsAllocateResourceNode (sizeof (ASL_QWORD_ADDRESS_DESC) +
732 StringLength);
733
734 Descriptor = Rnode->Buffer;
735 Descriptor->Qas.DescriptorType = ACPI_RDESC_TYPE_QWORD_ADDRESS_SPACE;
736 Descriptor->Qas.ResourceType = ACPI_RESOURCE_TYPE_MEMORY_RANGE;
737
738 /*
739 * Initial descriptor length -- may be enlarged if there are
740 * optional fields present
741 */
742 Descriptor->Qas.Length = (UINT16) (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
743 ASL_RESDESC_OFFSET (Qas.ResourceType));
744 /*
745 * Process all child initialization nodes
746 */
747 for (i = 0; InitializerOp; i++)
748 {
749 switch (i)
750 {
751 case 0: /* Resource Type */
752
753 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 0, 1);
754 break;
755
756 case 1: /* DecodeType */
757
758 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 1, 0);
759 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
760 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 1);
761 break;
762
763 case 2: /* MinType */
764
765 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 2, 0);
766 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
767 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 2);
768 break;
769
770 case 3: /* MaxType */
771
772 RsSetFlagBits (&Descriptor->Qas.Flags, InitializerOp, 3, 0);
773 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
774 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Flags), 3);
775 break;
776
777 case 4: /* Memory Type */
778
779 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 1, 0);
780 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
781 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 1);
782 break;
783
784 case 5: /* Read/Write Type */
785
786 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 0, 1);
787 RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
788 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 0);
789 break;
790
791 case 6: /* Address Granularity */
792
793 Descriptor->Qas.Granularity = InitializerOp->Asl.Value.Integer;
794 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
795 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.Granularity));
796 break;
797
798 case 7: /* Min Address */
799
800 Descriptor->Qas.AddressMin = InitializerOp->Asl.Value.Integer;
801 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
802 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMin));
803 break;
804
805 case 8: /* Max Address */
806
807 Descriptor->Qas.AddressMax = InitializerOp->Asl.Value.Integer;
808 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
809 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressMax));
810 break;
811
812 case 9: /* Translation Offset */
813
814 Descriptor->Qas.TranslationOffset = InitializerOp->Asl.Value.Integer;
815 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
816 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.TranslationOffset));
817 break;
818
819 case 10: /* Address Length */
820
821 Descriptor->Qas.AddressLength = InitializerOp->Asl.Value.Integer;
822 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
823 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.AddressLength));
824 break;
825
826 case 11: /* ResSourceIndex [Optional Field - BYTE] */
827
828 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
829 {
830 Descriptor->Qas.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
831 OptionIndex++;
832 Descriptor->Qas.Length++;
833 }
834 break;
835
836 case 12: /* ResSource [Optional Field - STRING] */
837
838 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
839 (InitializerOp->Asl.Value.String))
840 {
841 if (StringLength)
842 {
843 Descriptor->Qas.Length = (UINT16) (Descriptor->Qas.Length + StringLength);
844
845 strcpy ((char *) &Descriptor->Qas.OptionalFields[OptionIndex],
846 InitializerOp->Asl.Value.String);
847 }
848 }
849 break;
850
851 case 13: /* ResourceTag */
852
853 UtAttachNamepathToOwner (Op, InitializerOp);
854 break;
855
856
857 case 14: /* Address Range */
858
859 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 3, 0);
860 RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
861 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 3);
862 break;
863
864 case 15: /* Type */
865
866 RsSetFlagBits (&Descriptor->Qas.SpecificFlags, InitializerOp, 5, 0);
867 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
868 CurrentByteOffset + ASL_RESDESC_OFFSET (Qas.SpecificFlags), 5);
869 break;
870
871 default:
872
873 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
874 break;
875 }
876
877 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
878 }
879
880 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Qas.OptionalFields[0]) -
881 ASL_RESDESC_OFFSET (Qas.DescriptorType))
882 + OptionIndex + StringLength;
883 return (Rnode);
884}
885
886
887/*******************************************************************************
888 *
889 * FUNCTION: RsDoWordIoDescriptor
890 *
891 * PARAMETERS: Op - Parent resource descriptor parse node
892 * CurrentByteOffset - Offset into the resource template AML
893 * buffer (to track references to the desc)
894 *
895 * RETURN: Completed resource node
896 *
897 * DESCRIPTION: Construct a long "WordIO" descriptor
898 *
899 ******************************************************************************/
900
901ASL_RESOURCE_NODE *
902RsDoWordIoDescriptor (
903 ACPI_PARSE_OBJECT *Op,
904 UINT32 CurrentByteOffset)
905{
906 ASL_RESOURCE_DESC *Descriptor;
907 ACPI_PARSE_OBJECT *InitializerOp;
908 ASL_RESOURCE_NODE *Rnode;
909 UINT32 StringLength = 0;
910 UINT32 OptionIndex = 0;
911 UINT32 i;
912
913
914 InitializerOp = Op->Asl.Child;
915 StringLength = RsGetStringDataLength (InitializerOp);
916
917 Rnode = RsAllocateResourceNode (sizeof (ASL_WORD_ADDRESS_DESC) +
918 StringLength);
919
920 Descriptor = Rnode->Buffer;
921 Descriptor->Was.DescriptorType = ACPI_RDESC_TYPE_WORD_ADDRESS_SPACE;
922 Descriptor->Was.ResourceType = ACPI_RESOURCE_TYPE_IO_RANGE;
923
924 /*
925 * Initial descriptor length -- may be enlarged if there are
926 * optional fields present
927 */
928 Descriptor->Was.Length = (UINT16) (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
929 ASL_RESDESC_OFFSET (Was.ResourceType));
930
931 /*
932 * Process all child initialization nodes
933 */
934 for (i = 0; InitializerOp; i++)
935 {
936 switch (i)
937 {
938 case 0: /* Resource Type */
939
940 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 0, 1);
941 break;
942
943 case 1: /* MinType */
944
945 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 2, 0);
946 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
947 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 2);
948 break;
949
950 case 2: /* MaxType */
951
952 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 3, 0);
953 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
954 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 3);
955 break;
956
957 case 3: /* DecodeType */
958
959 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 1, 0);
960 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
961 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 1);
962 break;
963
964 case 4: /* Range Type */
965
966 RsSetFlagBits (&Descriptor->Was.SpecificFlags, InitializerOp, 0, 3);
967 RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
968 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.SpecificFlags), 0);
969 break;
970
971 case 5: /* Address Granularity */
972
973 Descriptor->Was.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
974 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
975 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Granularity));
976 break;
977
978 case 6: /* Address Min */
979
980 Descriptor->Was.AddressMin = (UINT16) InitializerOp->Asl.Value.Integer;
981 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
982 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMin));
983 break;
984
985 case 7: /* Address Max */
986
987 Descriptor->Was.AddressMax = (UINT16) InitializerOp->Asl.Value.Integer;
988 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
989 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMax));
990 break;
991
992 case 8: /* Translation Offset */
993
994 Descriptor->Was.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
995 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
996 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.TranslationOffset));
997 break;
998
999 case 9: /* Address Length */
1000
1001 Descriptor->Was.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
1002 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1003 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressLength));
1004 break;
1005
1006 case 10: /* ResSourceIndex [Optional Field - BYTE] */
1007
1008 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1009 {
1010 Descriptor->Was.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1011 OptionIndex++;
1012 Descriptor->Was.Length++;
1013 }
1014 break;
1015
1016 case 11: /* ResSource [Optional Field - STRING] */
1017
1018 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1019 (InitializerOp->Asl.Value.String))
1020 {
1021 if (StringLength)
1022 {
1023 Descriptor->Was.Length = (UINT16) (Descriptor->Was.Length +StringLength);
1024
1025 strcpy ((char *) &Descriptor->Was.OptionalFields[OptionIndex],
1026 InitializerOp->Asl.Value.String);
1027 }
1028 }
1029 break;
1030
1031 case 12: /* ResourceTag */
1032
1033 UtAttachNamepathToOwner (Op, InitializerOp);
1034 break;
1035
1036 case 13: /* Type */
1037
1038 RsSetFlagBits (&Descriptor->Was.SpecificFlags, InitializerOp, 4, 0);
1039 RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
1040 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.SpecificFlags), 4);
1041 break;
1042
1043 case 14: /* Translation Type */
1044
1045 RsSetFlagBits (&Descriptor->Was.SpecificFlags, InitializerOp, 5, 0);
1046 RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
1047 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.SpecificFlags), 5);
1048 break;
1049
1050 default:
1051
1052 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1053 break;
1054 }
1055
1056 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1057 }
1058
1059 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
1060 ASL_RESDESC_OFFSET (Was.DescriptorType))
1061 + OptionIndex + StringLength;
1062 return (Rnode);
1063}
1064
1065
1066/*******************************************************************************
1067 *
1068 * FUNCTION: RsDoWordBusNumberDescriptor
1069 *
1070 * PARAMETERS: Op - Parent resource descriptor parse node
1071 * CurrentByteOffset - Offset into the resource template AML
1072 * buffer (to track references to the desc)
1073 *
1074 * RETURN: Completed resource node
1075 *
1076 * DESCRIPTION: Construct a long "WordBusNumber" descriptor
1077 *
1078 ******************************************************************************/
1079
1080ASL_RESOURCE_NODE *
1081RsDoWordBusNumberDescriptor (
1082 ACPI_PARSE_OBJECT *Op,
1083 UINT32 CurrentByteOffset)
1084{
1085 ASL_RESOURCE_DESC *Descriptor;
1086 ACPI_PARSE_OBJECT *InitializerOp;
1087 ASL_RESOURCE_NODE *Rnode;
1088 UINT32 StringLength = 0;
1089 UINT32 OptionIndex = 0;
1090 UINT32 i;
1091
1092
1093 InitializerOp = Op->Asl.Child;
1094 StringLength = RsGetStringDataLength (InitializerOp);
1095
1096 Rnode = RsAllocateResourceNode (sizeof (ASL_WORD_ADDRESS_DESC) +
1097 StringLength);
1098
1099 Descriptor = Rnode->Buffer;
1100 Descriptor->Was.DescriptorType = ACPI_RDESC_TYPE_WORD_ADDRESS_SPACE;
1101 Descriptor->Was.ResourceType = ACPI_RESOURCE_TYPE_BUS_NUMBER_RANGE;
1102
1103 /*
1104 * Initial descriptor length -- may be enlarged if there are
1105 * optional fields present
1106 */
1107 Descriptor->Was.Length = (UINT16) (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
1108 ASL_RESDESC_OFFSET (Was.ResourceType));
1109
1110 /*
1111 * Process all child initialization nodes
1112 */
1113 for (i = 0; InitializerOp; i++)
1114 {
1115 switch (i)
1116 {
1117 case 0: /* Resource Type */
1118
1119 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 0, 1);
1120 break;
1121
1122 case 1: /* MinType */
1123
1124 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 2, 0);
1125 RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1126 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 2);
1127 break;
1128
1129 case 2: /* MaxType */
1130
1131 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 3, 0);
1132 RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1133 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 3);
1134 break;
1135
1136 case 3: /* DecodeType */
1137
1138 RsSetFlagBits (&Descriptor->Was.Flags, InitializerOp, 1, 0);
1139 RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1140 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Flags), 1);
1141 break;
1142
1143 case 4: /* Address Granularity */
1144
1145 Descriptor->Was.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
1146 RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1147 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.Granularity));
1148 break;
1149
1150 case 5: /* Min Address */
1151
1152 Descriptor->Was.AddressMin = (UINT16) InitializerOp->Asl.Value.Integer;
1153 RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1154 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMin));
1155 break;
1156
1157 case 6: /* Max Address */
1158
1159 Descriptor->Was.AddressMax = (UINT16) InitializerOp->Asl.Value.Integer;
1160 RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1161 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressMax));
1162 break;
1163
1164 case 7: /* Translation Offset */
1165
1166 Descriptor->Was.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
1167 RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1168 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.TranslationOffset));
1169 break;
1170
1171 case 8: /* Address Length */
1172
1173 Descriptor->Was.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
1174 RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1175 CurrentByteOffset + ASL_RESDESC_OFFSET (Was.AddressLength));
1176 break;
1177
1178 case 9: /* ResSourceIndex [Optional Field - BYTE] */
1179
1180 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1181 {
1182 Descriptor->Was.OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1183 OptionIndex++;
1184 Descriptor->Was.Length++;
1185 }
1186 break;
1187
1188 case 10: /* ResSource [Optional Field - STRING] */
1189
1190 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1191 (InitializerOp->Asl.Value.String))
1192 {
1193 if (StringLength)
1194 {
1195 Descriptor->Was.Length = (UINT16) (Descriptor->Was.Length + StringLength);
1196
1197 strcpy ((char *) &Descriptor->Was.OptionalFields[OptionIndex],
1198 InitializerOp->Asl.Value.String);
1199 }
1200 }
1201 break;
1202
1203 case 11: /* ResourceTag */
1204
1205 UtAttachNamepathToOwner (Op, InitializerOp);
1206 break;
1207
1208 default:
1209
1210 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1211 break;
1212 }
1213
1214 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1215 }
1216
1217 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Was.OptionalFields[0]) -
1218 ASL_RESDESC_OFFSET (Was.DescriptorType))
1219 + OptionIndex + StringLength;
1220 return (Rnode);
1221}
1222
1223
1224/*******************************************************************************
1225 *
1226 * FUNCTION: RsDoInterruptDescriptor
1227 *
1228 * PARAMETERS: Op - Parent resource descriptor parse node
1229 * CurrentByteOffset - Offset into the resource template AML
1230 * buffer (to track references to the desc)
1231 *
1232 * RETURN: Completed resource node
1233 *
1234 * DESCRIPTION: Construct a long "Interrupt" descriptor
1235 *
1236 ******************************************************************************/
1237
1238ASL_RESOURCE_NODE *
1239RsDoInterruptDescriptor (
1240 ACPI_PARSE_OBJECT *Op,
1241 UINT32 CurrentByteOffset)
1242{
1243 ASL_RESOURCE_DESC *Descriptor;
1244 ASL_RESOURCE_DESC *Rover = NULL;
1245 ACPI_PARSE_OBJECT *InitializerOp;
1246 ASL_RESOURCE_NODE *Rnode;
1247 UINT32 StringLength = 0;
1248 UINT32 OptionIndex = 0;
1249 UINT32 i;
1250 BOOLEAN HasResSourceIndex = FALSE;
1251 UINT8 ResSourceIndex = 0;
1252 UINT8 *ResSourceString = NULL;
1253
1254
1255 InitializerOp = Op->Asl.Child;
1256 StringLength = RsGetStringDataLength (InitializerOp);
1257 if (StringLength)
1258 {
1259 /* Make room for the ResourceSourceIndex */
1260
1261 OptionIndex++;
1262 }
1263
1264 /* Count the interrupt numbers */
1265
1266 for (i = 0; InitializerOp; i++)
1267 {
1268 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
1269 if (i <= 6)
1270 {
1271 continue;
1272 }
1273
1274 OptionIndex += 4;
1275 }
1276
1277 InitializerOp = Op->Asl.Child;
1278 Rnode = RsAllocateResourceNode (sizeof (ASL_EXTENDED_XRUPT_DESC) +
1279 OptionIndex + StringLength);
1280 Descriptor = Rnode->Buffer;
1281 Descriptor->Exx.DescriptorType = ACPI_RDESC_TYPE_EXTENDED_XRUPT;
1282
1283 /*
1284 * Initial descriptor length -- may be enlarged if there are
1285 * optional fields present
1286 */
1287 Descriptor->Exx.Length = 2; /* Flags and table length byte */
1288 Descriptor->Exx.TableLength = 0;
1289
1290 Rover = ACPI_CAST_PTR (ASL_RESOURCE_DESC, (&(Descriptor->Exx.InterruptNumber[0])));
1291
1292 /*
1293 * Process all child initialization nodes
1294 */
1295 for (i = 0; InitializerOp; i++)
1296 {
1297 switch (i)
1298 {
1299 case 0: /* Resource Type (Default: consumer (1) */
1300
1301 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 0, 1);
1302 break;
1303
1304 case 1: /* Interrupt Type (or Mode - edge/level) */
1305
1306 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 1, 0);
1307 RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTTYPE,
1308 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.Flags), 0);
1309 break;
1310
1311 case 2: /* Interrupt Level (or Polarity - Active high/low) */
1312
1313 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 2, 0);
1314 RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTLEVEL,
1315 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.Flags), 2);
1316 break;
1317
1318 case 3: /* Share Type - Default: exclusive (0) */
1319
1320 RsSetFlagBits (&Descriptor->Exx.Flags, InitializerOp, 3, 0);
1321 RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTSHARE,
1322 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.Flags), 3);
1323 break;
1324
1325 case 4: /* ResSourceIndex [Optional Field - BYTE] */
1326
1327 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1328 {
1329 HasResSourceIndex = TRUE;
1330 ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
1331 }
1332 break;
1333
1334 case 5: /* ResSource [Optional Field - STRING] */
1335
1336 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1337 (InitializerOp->Asl.Value.String))
1338 {
1339 if (StringLength)
1340 {
1341 ResSourceString = (UINT8 *) InitializerOp->Asl.Value.String;
1342 }
1343 }
1344 break;
1345
1346 case 6: /* ResourceTag */
1347
1348 UtAttachNamepathToOwner (Op, InitializerOp);
1349 break;
1350
1351 default:
1352 /*
1353 * Interrupt Numbers come through here, repeatedly.
1354 * Store the integer and move pointer to the next one.
1355 */
1356 Rover->U32Item = (UINT32) InitializerOp->Asl.Value.Integer;
1357 Rover = ACPI_PTR_ADD (ASL_RESOURCE_DESC, &(Rover->U32Item), 4);
1358
1359 Descriptor->Exx.TableLength++;
1360 Descriptor->Exx.Length += 4;
1361
1362 if (i == 7) /* case 7: First interrupt number */
1363 {
1364 RsCreateByteField (InitializerOp, ASL_RESNAME_INTERRUPT,
1365 CurrentByteOffset + ASL_RESDESC_OFFSET (Exx.InterruptNumber[0]));
1366 }
1367 }
1368
1369 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1370 }
1371
1372 /*
1373 * Add optional ResSourceIndex if present
1374 */
1375 if (HasResSourceIndex)
1376 {
1377 Rover->U8Item = ResSourceIndex;
1378 Rover = ACPI_PTR_ADD (ASL_RESOURCE_DESC, &(Rover->U8Item), 1);
1379 Descriptor->Exx.Length += 1;
1380 }
1381
1382 /*
1383 * Add optional ResSource string if present
1384 */
1385 if (StringLength && ResSourceString)
1386 {
1387
1388 strcpy ((char *) Rover, (char *) ResSourceString);
1389 Rover = ACPI_PTR_ADD (ASL_RESOURCE_DESC, &(Rover->U8Item), StringLength);
1390 Descriptor->Exx.Length = (UINT16) (Descriptor->Exx.Length + StringLength);
1391 }
1392
1393 Rnode->BufferLength = (ASL_RESDESC_OFFSET (Exx.InterruptNumber[0]) -
1394 ASL_RESDESC_OFFSET (Exx.DescriptorType))
1395 + OptionIndex + StringLength;
1396 return (Rnode);
1397}
1398
1399
1400/*******************************************************************************
1401 *
1402 * FUNCTION: RsDoVendorLargeDescriptor
1403 *
1404 * PARAMETERS: Op - Parent resource descriptor parse node
1405 * CurrentByteOffset - Offset into the resource template AML
1406 * buffer (to track references to the desc)
1407 *
1408 * RETURN: Completed resource node
1409 *
1410 * DESCRIPTION: Construct a long "VendorLong" descriptor
1411 *
1412 ******************************************************************************/
1413
1414ASL_RESOURCE_NODE *
1415RsDoVendorLargeDescriptor (
1416 ACPI_PARSE_OBJECT *Op,
1417 UINT32 CurrentByteOffset)
1418{
1419 ASL_RESOURCE_DESC *Descriptor;
1420 ACPI_PARSE_OBJECT *InitializerOp;
1421 ASL_RESOURCE_NODE *Rnode;
1422 UINT32 i;
1423
1424
1425 /* Count the number of data bytes */
1426
1427 InitializerOp = Op->Asl.Child;
1428 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1429
1430 for (i = 0; InitializerOp; i++)
1431 {
1432 InitializerOp = InitializerOp->Asl.Next;
1433 }
1434
1435 InitializerOp = Op->Asl.Child;
1436 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1437 Rnode = RsAllocateResourceNode (sizeof (ASL_LARGE_VENDOR_DESC) + (i - 1));
1438
1439 Descriptor = Rnode->Buffer;
1440 Descriptor->Lgv.DescriptorType = ACPI_RDESC_TYPE_LARGE_VENDOR;
1441 Descriptor->Lgv.Length = (UINT16) i;
1442
1443 /*
1444 * Process all child initialization nodes
1445 */
1446 for (i = 0; InitializerOp; i++)
1447 {
1448 Descriptor->Lgv.VendorDefined[i] = (UINT8) InitializerOp->Asl.Value.Integer;
1449
1450 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1451 }
1452
1453 return (Rnode);
1454}
1455
1456
1457/*******************************************************************************
1458 *
1459 * FUNCTION: RsDoGeneralRegisterDescriptor
1460 *
1461 * PARAMETERS: Op - Parent resource descriptor parse node
1462 * CurrentByteOffset - Offset into the resource template AML
1463 * buffer (to track references to the desc)
1464 *
1465 * RETURN: Completed resource node
1466 *
1467 * DESCRIPTION: Construct a long "Register" descriptor
1468 *
1469 ******************************************************************************/
1470
1471ASL_RESOURCE_NODE *
1472RsDoGeneralRegisterDescriptor (
1473 ACPI_PARSE_OBJECT *Op,
1474 UINT32 CurrentByteOffset)
1475{
1476 ASL_RESOURCE_DESC *Descriptor;
1477 ACPI_PARSE_OBJECT *InitializerOp;
1478 ASL_RESOURCE_NODE *Rnode;
1479 UINT32 i;
1480
1481
1482 InitializerOp = Op->Asl.Child;
1483 Rnode = RsAllocateResourceNode (sizeof (ASL_GENERAL_REGISTER_DESC));
1484
1485 Descriptor = Rnode->Buffer;
1486 Descriptor->Grg.DescriptorType = ACPI_RDESC_TYPE_GENERAL_REGISTER;
1487 Descriptor->Grg.Length = 12;
1488
1489 /*
1490 * Process all child initialization nodes
1491 */
1492 for (i = 0; InitializerOp; i++)
1493 {
1494 switch (i)
1495 {
1496 case 0: /* Address space */
1497
1498 Descriptor->Grg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;
1499 RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESSSPACE,
1500 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.AddressSpaceId));
1501 break;
1502
1503 case 1: /* Register Bit Width */
1504
1505 Descriptor->Grg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;
1506 RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITWIDTH,
1507 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.BitWidth));
1508 break;
1509
1510 case 2: /* Register Bit Offset */
1511
1512 Descriptor->Grg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;
1513 RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITOFFSET,
1514 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.BitOffset));
1515 break;
1516
1517 case 3: /* Register Address */
1518
1519 Descriptor->Grg.Address = InitializerOp->Asl.Value.Integer;
1520 RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESS,
1521 CurrentByteOffset + ASL_RESDESC_OFFSET (Grg.Address));
1522 break;
1523
1524
1525 default:
1526
1527 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1528 break;
1529 }
1530
1531 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1532 }
1533 return (Rnode);
1534}
1535
1536
|