?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / acpi / acpica / rsmisc.c
blobc99cec9cefdec4ee20305ed6e5ff578b60960f58
1 /*******************************************************************************
2 *
3 * Module Name: rsmisc - Miscellaneous resource descriptors
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acresrc.h"
47
48 #define _COMPONENT ACPI_RESOURCES
49 ACPI_MODULE_NAME("rsmisc")
50 #define INIT_RESOURCE_TYPE(i) i->resource_offset
51 #define INIT_RESOURCE_LENGTH(i) i->aml_offset
52 #define INIT_TABLE_LENGTH(i) i->value
53 #define COMPARE_OPCODE(i) i->resource_offset
54 #define COMPARE_TARGET(i) i->aml_offset
55 #define COMPARE_VALUE(i) i->value
56 /*******************************************************************************
57 *
58 * FUNCTION: acpi_rs_convert_aml_to_resource
59 *
60 * PARAMETERS: resource - Pointer to the resource descriptor
61 * aml - Where the AML descriptor is returned
62 * info - Pointer to appropriate conversion table
63 *
64 * RETURN: Status
65 *
66 * DESCRIPTION: Convert an external AML resource descriptor to the corresponding
67 * internal resource descriptor
68 *
69 ******************************************************************************/
70 acpi_status
71 acpi_rs_convert_aml_to_resource(struct acpi_resource *resource,
72 union aml_resource *aml,
73 struct acpi_rsconvert_info *info)
74 {
75 acpi_rs_length aml_resource_length;
76 void *source;
77 void *destination;
78 char *target;
79 u8 count;
80 u8 flags_mode = FALSE;
81 u16 item_count = 0;
82 u16 temp16 = 0;
83
84 ACPI_FUNCTION_TRACE(rs_convert_aml_to_resource);
85
86 if (!info) {
87 return_ACPI_STATUS(AE_BAD_PARAMETER);
88 }
89
90 if (((acpi_size) resource) & 0x3) {
91
92 /* Each internal resource struct is expected to be 32-bit aligned */
93
94 ACPI_WARNING((AE_INFO,
95 "Misaligned resource pointer (get): %p Type 0x%2.2X Length %u",
96 resource, resource->type, resource->length));
97 }
98
99 /* Extract the resource Length field (does not include header length) */
100
101 aml_resource_length = acpi_ut_get_resource_length(aml);
102
103 /*
104 * First table entry must be ACPI_RSC_INITxxx and must contain the
105 * table length (# of table entries)
106 */
107 count = INIT_TABLE_LENGTH(info);
108 while (count) {
109 /*
110 * Source is the external AML byte stream buffer,
111 * destination is the internal resource descriptor
112 */
113 source = ACPI_ADD_PTR(void, aml, info->aml_offset);
114 destination =
115 ACPI_ADD_PTR(void, resource, info->resource_offset);
116
117 switch (info->opcode) {
118 case ACPI_RSC_INITGET:
119 /*
120 * Get the resource type and the initial (minimum) length
121 */
122 ACPI_MEMSET(resource, 0, INIT_RESOURCE_LENGTH(info));
123 resource->type = INIT_RESOURCE_TYPE(info);
124 resource->length = INIT_RESOURCE_LENGTH(info);
125 break;
126
127 case ACPI_RSC_INITSET:
128 break;
129
130 case ACPI_RSC_FLAGINIT:
131
132 flags_mode = TRUE;
133 break;
134
135 case ACPI_RSC_1BITFLAG:
136 /*
137 * Mask and shift the flag bit
138 */
139 ACPI_SET8(destination,
140 ((ACPI_GET8(source) >> info->value) & 0x01));
141 break;
142
143 case ACPI_RSC_2BITFLAG:
144 /*
145 * Mask and shift the flag bits
146 */
147 ACPI_SET8(destination,
148 ((ACPI_GET8(source) >> info->value) & 0x03));
149 break;
150
151 case ACPI_RSC_3BITFLAG:
152 /*
153 * Mask and shift the flag bits
154 */
155 ACPI_SET8(destination,
156 ((ACPI_GET8(source) >> info->value) & 0x07));
157 break;
158
159 case ACPI_RSC_COUNT:
160
161 item_count = ACPI_GET8(source);
162 ACPI_SET8(destination, item_count);
163
164 resource->length = resource->length +
165 (info->value * (item_count - 1));
166 break;
167
168 case ACPI_RSC_COUNT16:
169
170 item_count = aml_resource_length;
171 ACPI_SET16(destination, item_count);
172
173 resource->length = resource->length +
174 (info->value * (item_count - 1));
175 break;
176
177 case ACPI_RSC_COUNT_GPIO_PIN:
178
179 target = ACPI_ADD_PTR(void, aml, info->value);
180 item_count = ACPI_GET16(target) - ACPI_GET16(source);
181
182 resource->length = resource->length + item_count;
183 item_count = item_count / 2;
184 ACPI_SET16(destination, item_count);
185 break;
186
187 case ACPI_RSC_COUNT_GPIO_VEN:
188
189 item_count = ACPI_GET8(source);
190 ACPI_SET8(destination, item_count);
191
192 resource->length = resource->length +
193 (info->value * item_count);
194 break;
195
196 case ACPI_RSC_COUNT_GPIO_RES:
197 /*
198 * Vendor data is optional (length/offset may both be zero)
199 * Examine vendor data length field first
200 */
201 target = ACPI_ADD_PTR(void, aml, (info->value + 2));
202 if (ACPI_GET16(target)) {
203
204 /* Use vendor offset to get resource source length */
205
206 target = ACPI_ADD_PTR(void, aml, info->value);
207 item_count =
208 ACPI_GET16(target) - ACPI_GET16(source);
209 } else {
210 /* No vendor data to worry about */
211
212 item_count = aml->large_header.resource_length +
213 sizeof(struct aml_resource_large_header) -
214 ACPI_GET16(source);
215 }
216
217 resource->length = resource->length + item_count;
218 ACPI_SET16(destination, item_count);
219 break;
220
221 case ACPI_RSC_COUNT_SERIAL_VEN:
222
223 item_count = ACPI_GET16(source) - info->value;
224
225 resource->length = resource->length + item_count;
226 ACPI_SET16(destination, item_count);
227 break;
228
229 case ACPI_RSC_COUNT_SERIAL_RES:
230
231 item_count = (aml_resource_length +
232 sizeof(struct aml_resource_large_header))
233 - ACPI_GET16(source) - info->value;
234
235 resource->length = resource->length + item_count;
236 ACPI_SET16(destination, item_count);
237 break;
238
239 case ACPI_RSC_LENGTH:
240
241 resource->length = resource->length + info->value;
242 break;
243
244 case ACPI_RSC_MOVE8:
245 case ACPI_RSC_MOVE16:
246 case ACPI_RSC_MOVE32:
247 case ACPI_RSC_MOVE64:
248 /*
249 * Raw data move. Use the Info value field unless item_count has
250 * been previously initialized via a COUNT opcode
251 */
252 if (info->value) {
253 item_count = info->value;
254 }
255 acpi_rs_move_data(destination, source, item_count,
256 info->opcode);
257 break;
258
259 case ACPI_RSC_MOVE_GPIO_PIN:
260
261 /* Generate and set the PIN data pointer */
262
263 target = (char *)ACPI_ADD_PTR(void, resource,
264 (resource->length -
265 item_count * 2));
266 *(u16 **)destination = ACPI_CAST_PTR(u16, target);
267
268 /* Copy the PIN data */
269
270 source = ACPI_ADD_PTR(void, aml, ACPI_GET16(source));
271 acpi_rs_move_data(target, source, item_count,
272 info->opcode);
273 break;
274
275 case ACPI_RSC_MOVE_GPIO_RES:
276
277 /* Generate and set the resource_source string pointer */
278
279 target = (char *)ACPI_ADD_PTR(void, resource,
280 (resource->length -
281 item_count));
282 *(u8 **)destination = ACPI_CAST_PTR(u8, target);
283
284 /* Copy the resource_source string */
285
286 source = ACPI_ADD_PTR(void, aml, ACPI_GET16(source));
287 acpi_rs_move_data(target, source, item_count,
288 info->opcode);
289 break;
290
291 case ACPI_RSC_MOVE_SERIAL_VEN:
292
293 /* Generate and set the Vendor Data pointer */
294
295 target = (char *)ACPI_ADD_PTR(void, resource,
296 (resource->length -
297 item_count));
298 *(u8 **)destination = ACPI_CAST_PTR(u8, target);
299
300 /* Copy the Vendor Data */
301
302 source = ACPI_ADD_PTR(void, aml, info->value);
303 acpi_rs_move_data(target, source, item_count,
304 info->opcode);
305 break;
306
307 case ACPI_RSC_MOVE_SERIAL_RES:
308
309 /* Generate and set the resource_source string pointer */
310
311 target = (char *)ACPI_ADD_PTR(void, resource,
312 (resource->length -
313 item_count));
314 *(u8 **)destination = ACPI_CAST_PTR(u8, target);
315
316 /* Copy the resource_source string */
317
318 source =
319 ACPI_ADD_PTR(void, aml,
320 (ACPI_GET16(source) + info->value));
321 acpi_rs_move_data(target, source, item_count,
322 info->opcode);
323 break;
324
325 case ACPI_RSC_SET8:
326
327 ACPI_MEMSET(destination, info->aml_offset, info->value);
328 break;
329
330 case ACPI_RSC_DATA8:
331
332 target = ACPI_ADD_PTR(char, resource, info->value);
333 ACPI_MEMCPY(destination, source, ACPI_GET16(target));
334 break;
335
336 case ACPI_RSC_ADDRESS:
337 /*
338 * Common handler for address descriptor flags
339 */
340 if (!acpi_rs_get_address_common(resource, aml)) {
341 return_ACPI_STATUS
342 (AE_AML_INVALID_RESOURCE_TYPE);
343 }
344 break;
345
346 case ACPI_RSC_SOURCE:
347 /*
348 * Optional resource_source (Index and String)
349 */
350 resource->length +=
351 acpi_rs_get_resource_source(aml_resource_length,
352 info->value,
353 destination, aml, NULL);
354 break;
355
356 case ACPI_RSC_SOURCEX:
357 /*
358 * Optional resource_source (Index and String). This is the more
359 * complicated case used by the Interrupt() macro
360 */
361 target = ACPI_ADD_PTR(char, resource,
362 info->aml_offset +
363 (item_count * 4));
364
365 resource->length +=
366 acpi_rs_get_resource_source(aml_resource_length,
367 (acpi_rs_length)
368 (((item_count -
369 1) * sizeof(u32)) +
370 info->value),
371 destination, aml,
372 target);
373 break;
374
375 case ACPI_RSC_BITMASK:
376 /*
377 * 8-bit encoded bitmask (DMA macro)
378 */
379 item_count =
380 acpi_rs_decode_bitmask(ACPI_GET8(source),
381 destination);
382 if (item_count) {
383 resource->length += (item_count - 1);
384 }
385
386 target = ACPI_ADD_PTR(char, resource, info->value);
387 ACPI_SET8(target, item_count);
388 break;
389
390 case ACPI_RSC_BITMASK16:
391 /*
392 * 16-bit encoded bitmask (IRQ macro)
393 */
394 ACPI_MOVE_16_TO_16(&temp16, source);
395
396 item_count =
397 acpi_rs_decode_bitmask(temp16, destination);
398 if (item_count) {
399 resource->length += (item_count - 1);
400 }
401
402 target = ACPI_ADD_PTR(char, resource, info->value);
403 ACPI_SET8(target, item_count);
404 break;
405
406 case ACPI_RSC_EXIT_NE:
407 /*
408 * control - Exit conversion if not equal
409 */
410 switch (info->resource_offset) {
411 case ACPI_RSC_COMPARE_AML_LENGTH:
412
413 if (aml_resource_length != info->value) {
414 goto exit;
415 }
416 break;
417
418 case ACPI_RSC_COMPARE_VALUE:
419
420 if (ACPI_GET8(source) != info->value) {
421 goto exit;
422 }
423 break;
424
425 default:
426
427 ACPI_ERROR((AE_INFO,
428 "Invalid conversion sub-opcode"));
429 return_ACPI_STATUS(AE_BAD_PARAMETER);
430 }
431 break;
432
433 default:
434
435 ACPI_ERROR((AE_INFO, "Invalid conversion opcode"));
436 return_ACPI_STATUS(AE_BAD_PARAMETER);
437 }
438
439 count--;
440 info++;
441 }
442
443 exit:
444 if (!flags_mode) {
445
446 /* Round the resource struct length up to the next boundary (32 or 64) */
447
448 resource->length =
449 (u32) ACPI_ROUND_UP_TO_NATIVE_WORD(resource->length);
450 }
451 return_ACPI_STATUS(AE_OK);
452 }
453
454 /*******************************************************************************
455 *
456 * FUNCTION: acpi_rs_convert_resource_to_aml
457 *
458 * PARAMETERS: resource - Pointer to the resource descriptor
459 * aml - Where the AML descriptor is returned
460 * info - Pointer to appropriate conversion table
461 *
462 * RETURN: Status
463 *
464 * DESCRIPTION: Convert an internal resource descriptor to the corresponding
465 * external AML resource descriptor.
466 *
467 ******************************************************************************/
468
469 acpi_status
470 acpi_rs_convert_resource_to_aml(struct acpi_resource *resource,
471 union aml_resource *aml,
472 struct acpi_rsconvert_info *info)
473 {
474 void *source = NULL;
475 void *destination;
476 char *target;
477 acpi_rsdesc_size aml_length = 0;
478 u8 count;
479 u16 temp16 = 0;
480 u16 item_count = 0;
481
482 ACPI_FUNCTION_TRACE(rs_convert_resource_to_aml);
483
484 if (!info) {
485 return_ACPI_STATUS(AE_BAD_PARAMETER);
486 }
487
488 /*
489 * First table entry must be ACPI_RSC_INITxxx and must contain the
490 * table length (# of table entries)
491 */
492 count = INIT_TABLE_LENGTH(info);
493
494 while (count) {
495 /*
496 * Source is the internal resource descriptor,
497 * destination is the external AML byte stream buffer
498 */
499 source = ACPI_ADD_PTR(void, resource, info->resource_offset);
500 destination = ACPI_ADD_PTR(void, aml, info->aml_offset);
501
502 switch (info->opcode) {
503 case ACPI_RSC_INITSET:
504
505 ACPI_MEMSET(aml, 0, INIT_RESOURCE_LENGTH(info));
506 aml_length = INIT_RESOURCE_LENGTH(info);
507 acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info),
508 aml_length, aml);
509 break;
510
511 case ACPI_RSC_INITGET:
512 break;
513
514 case ACPI_RSC_FLAGINIT:
515 /*
516 * Clear the flag byte
517 */
518 ACPI_SET8(destination, 0);
519 break;
520
521 case ACPI_RSC_1BITFLAG:
522 /*
523 * Mask and shift the flag bit
524 */
525 ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
526 ((ACPI_GET8(source) & 0x01) << info->
527 value));
528 break;
529
530 case ACPI_RSC_2BITFLAG:
531 /*
532 * Mask and shift the flag bits
533 */
534 ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
535 ((ACPI_GET8(source) & 0x03) << info->
536 value));
537 break;
538
539 case ACPI_RSC_3BITFLAG:
540 /*
541 * Mask and shift the flag bits
542 */
543 ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
544 ((ACPI_GET8(source) & 0x07) << info->
545 value));
546 break;
547
548 case ACPI_RSC_COUNT:
549
550 item_count = ACPI_GET8(source);
551 ACPI_SET8(destination, item_count);
552
553 aml_length =
554 (u16) (aml_length +
555 (info->value * (item_count - 1)));
556 break;
557
558 case ACPI_RSC_COUNT16:
559
560 item_count = ACPI_GET16(source);
561 aml_length = (u16) (aml_length + item_count);
562 acpi_rs_set_resource_length(aml_length, aml);
563 break;
564
565 case ACPI_RSC_COUNT_GPIO_PIN:
566
567 item_count = ACPI_GET16(source);
568 ACPI_SET16(destination, aml_length);
569
570 aml_length = (u16)(aml_length + item_count * 2);
571 target = ACPI_ADD_PTR(void, aml, info->value);
572 ACPI_SET16(target, aml_length);
573 acpi_rs_set_resource_length(aml_length, aml);
574 break;
575
576 case ACPI_RSC_COUNT_GPIO_VEN:
577
578 item_count = ACPI_GET16(source);
579 ACPI_SET16(destination, item_count);
580
581 aml_length =
582 (u16)(aml_length + (info->value * item_count));
583 acpi_rs_set_resource_length(aml_length, aml);
584 break;
585
586 case ACPI_RSC_COUNT_GPIO_RES:
587
588 /* Set resource source string length */
589
590 item_count = ACPI_GET16(source);
591 ACPI_SET16(destination, aml_length);
592
593 /* Compute offset for the Vendor Data */
594
595 aml_length = (u16)(aml_length + item_count);
596 target = ACPI_ADD_PTR(void, aml, info->value);
597
598 /* Set vendor offset only if there is vendor data */
599
600 if (resource->data.gpio.vendor_length) {
601 ACPI_SET16(target, aml_length);
602 }
603
604 acpi_rs_set_resource_length(aml_length, aml);
605 break;
606
607 case ACPI_RSC_COUNT_SERIAL_VEN:
608
609 item_count = ACPI_GET16(source);
610 ACPI_SET16(destination, item_count + info->value);
611 aml_length = (u16)(aml_length + item_count);
612 acpi_rs_set_resource_length(aml_length, aml);
613 break;
614
615 case ACPI_RSC_COUNT_SERIAL_RES:
616
617 item_count = ACPI_GET16(source);
618 aml_length = (u16)(aml_length + item_count);
619 acpi_rs_set_resource_length(aml_length, aml);
620 break;
621
622 case ACPI_RSC_LENGTH:
623
624 acpi_rs_set_resource_length(info->value, aml);
625 break;
626
627 case ACPI_RSC_MOVE8:
628 case ACPI_RSC_MOVE16:
629 case ACPI_RSC_MOVE32:
630 case ACPI_RSC_MOVE64:
631
632 if (info->value) {
633 item_count = info->value;
634 }
635 acpi_rs_move_data(destination, source, item_count,
636 info->opcode);
637 break;
638
639 case ACPI_RSC_MOVE_GPIO_PIN:
640
641 destination = (char *)ACPI_ADD_PTR(void, aml,
642 ACPI_GET16
643 (destination));
644 source = *(u16 **)source;
645 acpi_rs_move_data(destination, source, item_count,
646 info->opcode);
647 break;
648
649 case ACPI_RSC_MOVE_GPIO_RES:
650
651 /* Used for both resource_source string and vendor_data */
652
653 destination = (char *)ACPI_ADD_PTR(void, aml,
654 ACPI_GET16
655 (destination));
656 source = *(u8 **)source;
657 acpi_rs_move_data(destination, source, item_count,
658 info->opcode);
659 break;
660
661 case ACPI_RSC_MOVE_SERIAL_VEN:
662
663 destination = (char *)ACPI_ADD_PTR(void, aml,
664 (aml_length -
665 item_count));
666 source = *(u8 **)source;
667 acpi_rs_move_data(destination, source, item_count,
668 info->opcode);
669 break;
670
671 case ACPI_RSC_MOVE_SERIAL_RES:
672
673 destination = (char *)ACPI_ADD_PTR(void, aml,
674 (aml_length -
675 item_count));
676 source = *(u8 **)source;
677 acpi_rs_move_data(destination, source, item_count,
678 info->opcode);
679 break;
680
681 case ACPI_RSC_ADDRESS:
682
683 /* Set the Resource Type, General Flags, and Type-Specific Flags */
684
685 acpi_rs_set_address_common(aml, resource);
686 break;
687
688 case ACPI_RSC_SOURCEX:
689 /*
690 * Optional resource_source (Index and String)
691 */
692 aml_length =
693 acpi_rs_set_resource_source(aml,
694 (acpi_rs_length)
695 aml_length, source);
696 acpi_rs_set_resource_length(aml_length, aml);
697 break;
698
699 case ACPI_RSC_SOURCE:
700 /*
701 * Optional resource_source (Index and String). This is the more
702 * complicated case used by the Interrupt() macro
703 */
704 aml_length =
705 acpi_rs_set_resource_source(aml, info->value,
706 source);
707 acpi_rs_set_resource_length(aml_length, aml);
708 break;
709
710 case ACPI_RSC_BITMASK:
711 /*
712 * 8-bit encoded bitmask (DMA macro)
713 */
714 ACPI_SET8(destination,
715 acpi_rs_encode_bitmask(source,
716 *ACPI_ADD_PTR(u8,
717 resource,
718 info->
719 value)));
720 break;
721
722 case ACPI_RSC_BITMASK16:
723 /*
724 * 16-bit encoded bitmask (IRQ macro)
725 */
726 temp16 = acpi_rs_encode_bitmask(source,
727 *ACPI_ADD_PTR(u8,
728 resource,
729 info->
730 value));
731 ACPI_MOVE_16_TO_16(destination, &temp16);
732 break;
733
734 case ACPI_RSC_EXIT_LE:
735 /*
736 * control - Exit conversion if less than or equal
737 */
738 if (item_count <= info->value) {
739 goto exit;
740 }
741 break;
742
743 case ACPI_RSC_EXIT_NE:
744 /*
745 * control - Exit conversion if not equal
746 */
747 switch (COMPARE_OPCODE(info)) {
748 case ACPI_RSC_COMPARE_VALUE:
749
750 if (*ACPI_ADD_PTR(u8, resource,
751 COMPARE_TARGET(info)) !=
752 COMPARE_VALUE(info)) {
753 goto exit;
754 }
755 break;
756
757 default:
758
759 ACPI_ERROR((AE_INFO,
760 "Invalid conversion sub-opcode"));
761 return_ACPI_STATUS(AE_BAD_PARAMETER);
762 }
763 break;
764
765 case ACPI_RSC_EXIT_EQ:
766 /*
767 * control - Exit conversion if equal
768 */
769 if (*ACPI_ADD_PTR(u8, resource,
770 COMPARE_TARGET(info)) ==
771 COMPARE_VALUE(info)) {
772 goto exit;
773 }
774 break;
775
776 default:
777
778 ACPI_ERROR((AE_INFO, "Invalid conversion opcode"));
779 return_ACPI_STATUS(AE_BAD_PARAMETER);
780 }
781
782 count--;
783 info++;
784 }
785
786 exit:
787 return_ACPI_STATUS(AE_OK);
788 }
789
790 #if 0
791 /* Previous resource validations */
792
793 if (aml->ext_address64.revision_ID != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
794 return_ACPI_STATUS(AE_SUPPORT);
795 }
796
797 if (resource->data.start_dpf.performance_robustness >= 3) {
798 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
799 }
800
801 if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) {
802 /*
803 * Only [active_high, edge_sensitive] or [active_low, level_sensitive]
804 * polarity/trigger interrupts are allowed (ACPI spec, section
805 * "IRQ Format"), so 0x00 and 0x09 are illegal.
806 */
807 ACPI_ERROR((AE_INFO,
808 "Invalid interrupt polarity/trigger in resource list, 0x%X",
809 aml->irq.flags));
810 return_ACPI_STATUS(AE_BAD_DATA);
811 }
812
813 resource->data.extended_irq.interrupt_count = temp8;
814 if (temp8 < 1) {
815
816 /* Must have at least one IRQ */
817
818 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
819 }
820
821 if (resource->data.dma.transfer == 0x03) {
822 ACPI_ERROR((AE_INFO, "Invalid DMA.Transfer preference (3)"));
823 return_ACPI_STATUS(AE_BAD_DATA);
824 }
825 #endif
Linux with added FPC-III support