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