1 /*******************************************************************************
2 *
3 * Module Name: rsmisc - Miscellaneous resource descriptors
4 *
5 ******************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include "acpi.h"
153 #include "accommon.h"
154 #include "acresrc.h"
155
156 #define _COMPONENT ACPI_RESOURCES
157 ACPI_MODULE_NAME ("rsmisc")
158
159
160 #define INIT_RESOURCE_TYPE(i) i->ResourceOffset
161 #define INIT_RESOURCE_LENGTH(i) i->AmlOffset
162 #define INIT_TABLE_LENGTH(i) i->Value
163
164 #define COMPARE_OPCODE(i) i->ResourceOffset
165 #define COMPARE_TARGET(i) i->AmlOffset
166 #define COMPARE_VALUE(i) i->Value
167
168
169 /*******************************************************************************
170 *
171 * FUNCTION: AcpiRsConvertAmlToResource
172 *
173 * PARAMETERS: Resource - Pointer to the resource descriptor
174 * Aml - Where the AML descriptor is returned
175 * Info - Pointer to appropriate conversion table
176 *
177 * RETURN: Status
178 *
179 * DESCRIPTION: Convert an external AML resource descriptor to the corresponding
180 * internal resource descriptor
181 *
182 ******************************************************************************/
183
184 ACPI_STATUS
AcpiRsConvertAmlToResource(ACPI_RESOURCE * Resource,AML_RESOURCE * Aml,ACPI_RSCONVERT_INFO * Info)185 AcpiRsConvertAmlToResource (
186 ACPI_RESOURCE *Resource,
187 AML_RESOURCE *Aml,
188 ACPI_RSCONVERT_INFO *Info)
189 {
190 ACPI_RS_LENGTH AmlResourceLength;
191 void *Source;
192 void *Destination;
193 char *Target;
194 UINT8 Count;
195 UINT8 FlagsMode = FALSE;
196 UINT16 ItemCount = 0;
197 UINT16 Temp16 = 0;
198
199
200 ACPI_FUNCTION_TRACE (RsConvertAmlToResource);
201
202
203 if (!Info)
204 {
205 return_ACPI_STATUS (AE_BAD_PARAMETER);
206 }
207
208 if (((ACPI_SIZE) Resource) & 0x3)
209 {
210 /* Each internal resource struct is expected to be 32-bit aligned */
211
212 ACPI_WARNING ((AE_INFO,
213 "Misaligned resource pointer (get): %p Type 0x%2.2X Length %u",
214 Resource, Resource->Type, Resource->Length));
215 }
216
217 /* Extract the resource Length field (does not include header length) */
218
219 AmlResourceLength = AcpiUtGetResourceLength (Aml);
220
221 /*
222 * First table entry must be ACPI_RSC_INITxxx and must contain the
223 * table length (# of table entries)
224 */
225 Count = INIT_TABLE_LENGTH (Info);
226 while (Count)
227 {
228 /*
229 * Source is the external AML byte stream buffer,
230 * destination is the internal resource descriptor
231 */
232 Source = ACPI_ADD_PTR (void, Aml, Info->AmlOffset);
233 Destination = ACPI_ADD_PTR (void, Resource, Info->ResourceOffset);
234
235 switch (Info->Opcode)
236 {
237 case ACPI_RSC_INITGET:
238 /*
239 * Get the resource type and the initial (minimum) length
240 */
241 memset (Resource, 0, INIT_RESOURCE_LENGTH (Info));
242 Resource->Type = INIT_RESOURCE_TYPE (Info);
243 Resource->Length = INIT_RESOURCE_LENGTH (Info);
244 break;
245
246 case ACPI_RSC_INITSET:
247 break;
248
249 case ACPI_RSC_FLAGINIT:
250
251 FlagsMode = TRUE;
252 break;
253
254 case ACPI_RSC_1BITFLAG:
255 /*
256 * Mask and shift the flag bit
257 */
258 ACPI_SET8 (Destination,
259 ((ACPI_GET8 (Source) >> Info->Value) & 0x01));
260 break;
261
262 case ACPI_RSC_2BITFLAG:
263 /*
264 * Mask and shift the flag bits
265 */
266 ACPI_SET8 (Destination,
267 ((ACPI_GET8 (Source) >> Info->Value) & 0x03));
268 break;
269
270 case ACPI_RSC_3BITFLAG:
271 /*
272 * Mask and shift the flag bits
273 */
274 ACPI_SET8 (Destination,
275 ((ACPI_GET8 (Source) >> Info->Value) & 0x07));
276 break;
277
278 case ACPI_RSC_COUNT:
279
280 ItemCount = ACPI_GET8 (Source);
281 ACPI_SET8 (Destination, ItemCount);
282
283 Resource->Length = Resource->Length +
284 (Info->Value * (ItemCount - 1));
285 break;
286
287 case ACPI_RSC_COUNT16:
288
289 ItemCount = AmlResourceLength;
290 ACPI_SET16 (Destination, ItemCount);
291
292 Resource->Length = Resource->Length +
293 (Info->Value * (ItemCount - 1));
294 break;
295
296 case ACPI_RSC_COUNT_GPIO_PIN:
297
298 Target = ACPI_ADD_PTR (void, Aml, Info->Value);
299 ItemCount = ACPI_GET16 (Target) - ACPI_GET16 (Source);
300
301 Resource->Length = Resource->Length + ItemCount;
302 ItemCount = ItemCount / 2;
303 ACPI_SET16 (Destination, ItemCount);
304 break;
305
306 case ACPI_RSC_COUNT_GPIO_VEN:
307
308 ItemCount = ACPI_GET8 (Source);
309 ACPI_SET8 (Destination, ItemCount);
310
311 Resource->Length = Resource->Length + (Info->Value * ItemCount);
312 break;
313
314 case ACPI_RSC_COUNT_GPIO_RES:
315 /*
316 * Vendor data is optional (length/offset may both be zero)
317 * Examine vendor data length field first
318 */
319 Target = ACPI_ADD_PTR (void, Aml, (Info->Value + 2));
320 if (ACPI_GET16 (Target))
321 {
322 /* Use vendor offset to get resource source length */
323
324 Target = ACPI_ADD_PTR (void, Aml, Info->Value);
325 ItemCount = ACPI_GET16 (Target) - ACPI_GET16 (Source);
326 }
327 else
328 {
329 /* No vendor data to worry about */
330
331 ItemCount = Aml->LargeHeader.ResourceLength +
332 sizeof (AML_RESOURCE_LARGE_HEADER) -
333 ACPI_GET16 (Source);
334 }
335
336 Resource->Length = Resource->Length + ItemCount;
337 ACPI_SET16 (Destination, ItemCount);
338 break;
339
340 case ACPI_RSC_COUNT_SERIAL_VEN:
341
342 ItemCount = ACPI_GET16 (Source) - Info->Value;
343
344 Resource->Length = Resource->Length + ItemCount;
345 ACPI_SET16 (Destination, ItemCount);
346 break;
347
348 case ACPI_RSC_COUNT_SERIAL_RES:
349
350 ItemCount = (AmlResourceLength +
351 sizeof (AML_RESOURCE_LARGE_HEADER)) -
352 ACPI_GET16 (Source) - Info->Value;
353
354 Resource->Length = Resource->Length + ItemCount;
355 ACPI_SET16 (Destination, ItemCount);
356 break;
357
358 case ACPI_RSC_LENGTH:
359
360 Resource->Length = Resource->Length + Info->Value;
361 break;
362
363 case ACPI_RSC_MOVE8:
364 case ACPI_RSC_MOVE16:
365 case ACPI_RSC_MOVE32:
366 case ACPI_RSC_MOVE64:
367 /*
368 * Raw data move. Use the Info value field unless ItemCount has
369 * been previously initialized via a COUNT opcode
370 */
371 if (Info->Value)
372 {
373 ItemCount = Info->Value;
374 }
375 AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
376 break;
377
378 case ACPI_RSC_MOVE_GPIO_PIN:
379
380 /* Generate and set the PIN data pointer */
381
382 Target = (char *) ACPI_ADD_PTR (void, Resource,
383 (Resource->Length - ItemCount * 2));
384 *(UINT16 **) Destination = ACPI_CAST_PTR (UINT16, Target);
385
386 /* Copy the PIN data */
387
388 Source = ACPI_ADD_PTR (void, Aml, ACPI_GET16 (Source));
389 AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
390 break;
391
392 case ACPI_RSC_MOVE_GPIO_RES:
393
394 /* Generate and set the ResourceSource string pointer */
395
396 Target = (char *) ACPI_ADD_PTR (void, Resource,
397 (Resource->Length - ItemCount));
398 *(UINT8 **) Destination = ACPI_CAST_PTR (UINT8, Target);
399
400 /* Copy the ResourceSource string */
401
402 Source = ACPI_ADD_PTR (void, Aml, ACPI_GET16 (Source));
403 AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
404 break;
405
406 case ACPI_RSC_MOVE_SERIAL_VEN:
407
408 /* Generate and set the Vendor Data pointer */
409
410 Target = (char *) ACPI_ADD_PTR (void, Resource,
411 (Resource->Length - ItemCount));
412 *(UINT8 **) Destination = ACPI_CAST_PTR (UINT8, Target);
413
414 /* Copy the Vendor Data */
415
416 Source = ACPI_ADD_PTR (void, Aml, Info->Value);
417 AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
418 break;
419
420 case ACPI_RSC_MOVE_SERIAL_RES:
421
422 /* Generate and set the ResourceSource string pointer */
423
424 Target = (char *) ACPI_ADD_PTR (void, Resource,
425 (Resource->Length - ItemCount));
426 *(UINT8 **) Destination = ACPI_CAST_PTR (UINT8, Target);
427
428 /* Copy the ResourceSource string */
429
430 Source = ACPI_ADD_PTR (
431 void, Aml, (ACPI_GET16 (Source) + Info->Value));
432 AcpiRsMoveData (Target, Source, ItemCount, Info->Opcode);
433 break;
434
435 case ACPI_RSC_SET8:
436
437 memset (Destination, Info->AmlOffset, Info->Value);
438 break;
439
440 case ACPI_RSC_DATA8:
441
442 Target = ACPI_ADD_PTR (char, Resource, Info->Value);
443 memcpy (Destination, Source, ACPI_GET16 (Target));
444 break;
445
446 case ACPI_RSC_ADDRESS:
447 /*
448 * Common handler for address descriptor flags
449 */
450 if (!AcpiRsGetAddressCommon (Resource, Aml))
451 {
452 return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
453 }
454 break;
455
456 case ACPI_RSC_SOURCE:
457 /*
458 * Optional ResourceSource (Index and String)
459 */
460 Resource->Length +=
461 AcpiRsGetResourceSource (AmlResourceLength, Info->Value,
462 Destination, Aml, NULL);
463 break;
464
465 case ACPI_RSC_SOURCEX:
466 /*
467 * Optional ResourceSource (Index and String). This is the more
468 * complicated case used by the Interrupt() macro
469 */
470 Target = ACPI_ADD_PTR (char, Resource,
471 Info->AmlOffset + (ItemCount * 4));
472
473 Resource->Length +=
474 AcpiRsGetResourceSource (AmlResourceLength, (ACPI_RS_LENGTH)
475 (((ItemCount - 1) * sizeof (UINT32)) + Info->Value),
476 Destination, Aml, Target);
477 break;
478
479 case ACPI_RSC_BITMASK:
480 /*
481 * 8-bit encoded bitmask (DMA macro)
482 */
483 ItemCount = AcpiRsDecodeBitmask (ACPI_GET8 (Source), Destination);
484 if (ItemCount)
485 {
486 Resource->Length += (ItemCount - 1);
487 }
488
489 Target = ACPI_ADD_PTR (char, Resource, Info->Value);
490 ACPI_SET8 (Target, ItemCount);
491 break;
492
493 case ACPI_RSC_BITMASK16:
494 /*
495 * 16-bit encoded bitmask (IRQ macro)
496 */
497 ACPI_MOVE_16_TO_16 (&Temp16, Source);
498
499 ItemCount = AcpiRsDecodeBitmask (Temp16, Destination);
500 if (ItemCount)
501 {
502 Resource->Length += (ItemCount - 1);
503 }
504
505 Target = ACPI_ADD_PTR (char, Resource, Info->Value);
506 ACPI_SET8 (Target, ItemCount);
507 break;
508
509 case ACPI_RSC_EXIT_NE:
510 /*
511 * Control - Exit conversion if not equal
512 */
513 switch (Info->ResourceOffset)
514 {
515 case ACPI_RSC_COMPARE_AML_LENGTH:
516
517 if (AmlResourceLength != Info->Value)
518 {
519 goto Exit;
520 }
521 break;
522
523 case ACPI_RSC_COMPARE_VALUE:
524
525 if (ACPI_GET8 (Source) != Info->Value)
526 {
527 goto Exit;
528 }
529 break;
530
531 default:
532
533 ACPI_ERROR ((AE_INFO, "Invalid conversion sub-opcode"));
534 return_ACPI_STATUS (AE_BAD_PARAMETER);
535 }
536 break;
537
538 default:
539
540 ACPI_ERROR ((AE_INFO, "Invalid conversion opcode"));
541 return_ACPI_STATUS (AE_BAD_PARAMETER);
542 }
543
544 Count--;
545 Info++;
546 }
547
548 Exit:
549 if (!FlagsMode)
550 {
551 /* Round the resource struct length up to the next boundary (32 or 64) */
552
553 Resource->Length = (UINT32)
554 ACPI_ROUND_UP_TO_NATIVE_WORD (Resource->Length);
555 }
556 return_ACPI_STATUS (AE_OK);
557 }
558
559
560 /*******************************************************************************
561 *
562 * FUNCTION: AcpiRsConvertResourceToAml
563 *
564 * PARAMETERS: Resource - Pointer to the resource descriptor
565 * Aml - Where the AML descriptor is returned
566 * Info - Pointer to appropriate conversion table
567 *
568 * RETURN: Status
569 *
570 * DESCRIPTION: Convert an internal resource descriptor to the corresponding
571 * external AML resource descriptor.
572 *
573 ******************************************************************************/
574
575 ACPI_STATUS
AcpiRsConvertResourceToAml(ACPI_RESOURCE * Resource,AML_RESOURCE * Aml,ACPI_RSCONVERT_INFO * Info)576 AcpiRsConvertResourceToAml (
577 ACPI_RESOURCE *Resource,
578 AML_RESOURCE *Aml,
579 ACPI_RSCONVERT_INFO *Info)
580 {
581 void *Source = NULL;
582 void *Destination;
583 char *Target;
584 ACPI_RSDESC_SIZE AmlLength = 0;
585 UINT8 Count;
586 UINT16 Temp16 = 0;
587 UINT16 ItemCount = 0;
588
589
590 ACPI_FUNCTION_TRACE (RsConvertResourceToAml);
591
592
593 if (!Info)
594 {
595 return_ACPI_STATUS (AE_BAD_PARAMETER);
596 }
597
598 /*
599 * First table entry must be ACPI_RSC_INITxxx and must contain the
600 * table length (# of table entries)
601 */
602 Count = INIT_TABLE_LENGTH (Info);
603
604 while (Count)
605 {
606 /*
607 * Source is the internal resource descriptor,
608 * destination is the external AML byte stream buffer
609 */
610 Source = ACPI_ADD_PTR (void, Resource, Info->ResourceOffset);
611 Destination = ACPI_ADD_PTR (void, Aml, Info->AmlOffset);
612
613 switch (Info->Opcode)
614 {
615 case ACPI_RSC_INITSET:
616
617 memset (Aml, 0, INIT_RESOURCE_LENGTH (Info));
618 AmlLength = INIT_RESOURCE_LENGTH (Info);
619 AcpiRsSetResourceHeader (
620 INIT_RESOURCE_TYPE (Info), AmlLength, Aml);
621 break;
622
623 case ACPI_RSC_INITGET:
624 break;
625
626 case ACPI_RSC_FLAGINIT:
627 /*
628 * Clear the flag byte
629 */
630 ACPI_SET8 (Destination, 0);
631 break;
632
633 case ACPI_RSC_1BITFLAG:
634 /*
635 * Mask and shift the flag bit
636 */
637 ACPI_SET_BIT (*ACPI_CAST8 (Destination), (UINT8)
638 ((ACPI_GET8 (Source) & 0x01) << Info->Value));
639 break;
640
641 case ACPI_RSC_2BITFLAG:
642 /*
643 * Mask and shift the flag bits
644 */
645 ACPI_SET_BIT (*ACPI_CAST8 (Destination), (UINT8)
646 ((ACPI_GET8 (Source) & 0x03) << Info->Value));
647 break;
648
649 case ACPI_RSC_3BITFLAG:
650 /*
651 * Mask and shift the flag bits
652 */
653 ACPI_SET_BIT (*ACPI_CAST8 (Destination), (UINT8)
654 ((ACPI_GET8 (Source) & 0x07) << Info->Value));
655 break;
656
657 case ACPI_RSC_COUNT:
658
659 ItemCount = ACPI_GET8 (Source);
660 ACPI_SET8 (Destination, ItemCount);
661
662 AmlLength = (UINT16)
663 (AmlLength + (Info->Value * (ItemCount - 1)));
664 break;
665
666 case ACPI_RSC_COUNT16:
667
668 ItemCount = ACPI_GET16 (Source);
669 AmlLength = (UINT16) (AmlLength + ItemCount);
670 AcpiRsSetResourceLength (AmlLength, Aml);
671 break;
672
673 case ACPI_RSC_COUNT_GPIO_PIN:
674
675 ItemCount = ACPI_GET16 (Source);
676 ACPI_SET16 (Destination, AmlLength);
677
678 AmlLength = (UINT16) (AmlLength + ItemCount * 2);
679 Target = ACPI_ADD_PTR (void, Aml, Info->Value);
680 ACPI_SET16 (Target, AmlLength);
681 AcpiRsSetResourceLength (AmlLength, Aml);
682 break;
683
684 case ACPI_RSC_COUNT_GPIO_VEN:
685
686 ItemCount = ACPI_GET16 (Source);
687 ACPI_SET16 (Destination, ItemCount);
688
689 AmlLength = (UINT16) (
690 AmlLength + (Info->Value * ItemCount));
691 AcpiRsSetResourceLength (AmlLength, Aml);
692 break;
693
694 case ACPI_RSC_COUNT_GPIO_RES:
695
696 /* Set resource source string length */
697
698 ItemCount = ACPI_GET16 (Source);
699 ACPI_SET16 (Destination, AmlLength);
700
701 /* Compute offset for the Vendor Data */
702
703 AmlLength = (UINT16) (AmlLength + ItemCount);
704 Target = ACPI_ADD_PTR (void, Aml, Info->Value);
705
706 /* Set vendor offset only if there is vendor data */
707
708 ACPI_SET16 (Target, AmlLength);
709
710 AcpiRsSetResourceLength (AmlLength, Aml);
711 break;
712
713 case ACPI_RSC_COUNT_SERIAL_VEN:
714
715 ItemCount = ACPI_GET16 (Source);
716 ACPI_SET16 (Destination, ItemCount + Info->Value);
717 AmlLength = (UINT16) (AmlLength + ItemCount);
718 AcpiRsSetResourceLength (AmlLength, Aml);
719 break;
720
721 case ACPI_RSC_COUNT_SERIAL_RES:
722
723 ItemCount = ACPI_GET16 (Source);
724 AmlLength = (UINT16) (AmlLength + ItemCount);
725 AcpiRsSetResourceLength (AmlLength, Aml);
726 break;
727
728 case ACPI_RSC_LENGTH:
729
730 AcpiRsSetResourceLength (Info->Value, Aml);
731 break;
732
733 case ACPI_RSC_MOVE8:
734 case ACPI_RSC_MOVE16:
735 case ACPI_RSC_MOVE32:
736 case ACPI_RSC_MOVE64:
737
738 if (Info->Value)
739 {
740 ItemCount = Info->Value;
741 }
742 AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
743 break;
744
745 case ACPI_RSC_MOVE_GPIO_PIN:
746
747 Destination = (char *) ACPI_ADD_PTR (void, Aml,
748 ACPI_GET16 (Destination));
749 Source = * (UINT16 **) Source;
750 AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
751 break;
752
753 case ACPI_RSC_MOVE_GPIO_RES:
754
755 /* Used for both ResourceSource string and VendorData */
756
757 Destination = (char *) ACPI_ADD_PTR (void, Aml,
758 ACPI_GET16 (Destination));
759 Source = * (UINT8 **) Source;
760 AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
761 break;
762
763 case ACPI_RSC_MOVE_SERIAL_VEN:
764
765 Destination = (char *) ACPI_ADD_PTR (void, Aml,
766 (AmlLength - ItemCount));
767 Source = * (UINT8 **) Source;
768 AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
769 break;
770
771 case ACPI_RSC_MOVE_SERIAL_RES:
772
773 Destination = (char *) ACPI_ADD_PTR (void, Aml,
774 (AmlLength - ItemCount));
775 Source = * (UINT8 **) Source;
776 AcpiRsMoveData (Destination, Source, ItemCount, Info->Opcode);
777 break;
778
779 case ACPI_RSC_ADDRESS:
780
781 /* Set the Resource Type, General Flags, and Type-Specific Flags */
782
783 AcpiRsSetAddressCommon (Aml, Resource);
784 break;
785
786 case ACPI_RSC_SOURCEX:
787 /*
788 * Optional ResourceSource (Index and String)
789 */
790 AmlLength = AcpiRsSetResourceSource (
791 Aml, (ACPI_RS_LENGTH) AmlLength, Source);
792 AcpiRsSetResourceLength (AmlLength, Aml);
793 break;
794
795 case ACPI_RSC_SOURCE:
796 /*
797 * Optional ResourceSource (Index and String). This is the more
798 * complicated case used by the Interrupt() macro
799 */
800 AmlLength = AcpiRsSetResourceSource (Aml, Info->Value, Source);
801 AcpiRsSetResourceLength (AmlLength, Aml);
802 break;
803
804 case ACPI_RSC_BITMASK:
805 /*
806 * 8-bit encoded bitmask (DMA macro)
807 */
808 ACPI_SET8 (Destination,
809 AcpiRsEncodeBitmask (Source,
810 *ACPI_ADD_PTR (UINT8, Resource, Info->Value)));
811 break;
812
813 case ACPI_RSC_BITMASK16:
814 /*
815 * 16-bit encoded bitmask (IRQ macro)
816 */
817 Temp16 = AcpiRsEncodeBitmask (
818 Source, *ACPI_ADD_PTR (UINT8, Resource, Info->Value));
819 ACPI_MOVE_16_TO_16 (Destination, &Temp16);
820 break;
821
822 case ACPI_RSC_EXIT_LE:
823 /*
824 * Control - Exit conversion if less than or equal
825 */
826 if (ItemCount <= Info->Value)
827 {
828 goto Exit;
829 }
830 break;
831
832 case ACPI_RSC_EXIT_NE:
833 /*
834 * Control - Exit conversion if not equal
835 */
836 switch (COMPARE_OPCODE (Info))
837 {
838 case ACPI_RSC_COMPARE_VALUE:
839
840 if (*ACPI_ADD_PTR (UINT8, Resource,
841 COMPARE_TARGET (Info)) != COMPARE_VALUE (Info))
842 {
843 goto Exit;
844 }
845 break;
846
847 default:
848
849 ACPI_ERROR ((AE_INFO, "Invalid conversion sub-opcode"));
850 return_ACPI_STATUS (AE_BAD_PARAMETER);
851 }
852 break;
853
854 case ACPI_RSC_EXIT_EQ:
855 /*
856 * Control - Exit conversion if equal
857 */
858 if (*ACPI_ADD_PTR (UINT8, Resource,
859 COMPARE_TARGET (Info)) == COMPARE_VALUE (Info))
860 {
861 goto Exit;
862 }
863 break;
864
865 default:
866
867 ACPI_ERROR ((AE_INFO, "Invalid conversion opcode"));
868 return_ACPI_STATUS (AE_BAD_PARAMETER);
869 }
870
871 Count--;
872 Info++;
873 }
874
875 Exit:
876 return_ACPI_STATUS (AE_OK);
877 }
878
879
880 #if 0
881 /* Previous resource validations */
882
883 if (Aml->ExtAddress64.RevisionID !=
884 AML_RESOURCE_EXTENDED_ADDRESS_REVISION)
885 {
886 return_ACPI_STATUS (AE_SUPPORT);
887 }
888
889 if (Resource->Data.StartDpf.PerformanceRobustness >= 3)
890 {
891 return_ACPI_STATUS (AE_AML_BAD_RESOURCE_VALUE);
892 }
893
894 if (((Aml->Irq.Flags & 0x09) == 0x00) ||
895 ((Aml->Irq.Flags & 0x09) == 0x09))
896 {
897 /*
898 * Only [ActiveHigh, EdgeSensitive] or [ActiveLow, LevelSensitive]
899 * polarity/trigger interrupts are allowed (ACPI spec, section
900 * "IRQ Format"), so 0x00 and 0x09 are illegal.
901 */
902 ACPI_ERROR ((AE_INFO,
903 "Invalid interrupt polarity/trigger in resource list, 0x%X",
904 Aml->Irq.Flags));
905 return_ACPI_STATUS (AE_BAD_DATA);
906 }
907
908 Resource->Data.ExtendedIrq.InterruptCount = Temp8;
909 if (Temp8 < 1)
910 {
911 /* Must have at least one IRQ */
912
913 return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
914 }
915
916 if (Resource->Data.Dma.Transfer == 0x03)
917 {
918 ACPI_ERROR ((AE_INFO,
919 "Invalid DMA.Transfer preference (3)"));
920 return_ACPI_STATUS (AE_BAD_DATA);
921 }
922 #endif
923