drivers/acpi/acpica/rsmisc.c

   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                         /*
 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, 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, 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_SET_BIT(*ACPI_CAST8(destination), (u8)
 525                                      ((ACPI_GET8(source) & 0x01) << info->
 526                                       value));
 527                         break;
 528
 529                 case ACPI_RSC_2BITFLAG:
 530                         /*
 531                          * Mask and shift the flag bits
 532                          */
 533                         ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
 534                                      ((ACPI_GET8(source) & 0x03) << info->
 535                                       value));
 536                         break;
 537
 538                 case ACPI_RSC_3BITFLAG:
 539                         /*
 540                          * Mask and shift the flag bits
 541                          */
 542                         ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
 543                                      ((ACPI_GET8(source) & 0x07) << info->
 544                                       value));
 545                         break;
 546
 547                 case ACPI_RSC_COUNT:
 548
 549                         item_count = ACPI_GET8(source);
 550                         ACPI_SET8(destination, item_count);
 551
 552                         aml_length =
 553                             (u16) (aml_length +
 554                                    (info->value * (item_count - 1)));
 555                         break;
 556
 557                 case ACPI_RSC_COUNT16:
 558
 559                         item_count = ACPI_GET16(source);
 560                         aml_length = (u16) (aml_length + item_count);
 561                         acpi_rs_set_resource_length(aml_length, aml);
 562                         break;
 563
 564                 case ACPI_RSC_COUNT_GPIO_PIN:
 565
 566                         item_count = ACPI_GET16(source);
 567                         ACPI_SET16(destination, aml_length);
 568
 569                         aml_length = (u16)(aml_length + item_count * 2);
 570                         target = ACPI_ADD_PTR(void, aml, info->value);
 571                         ACPI_SET16(target, aml_length);
 572                         acpi_rs_set_resource_length(aml_length, aml);
 573                         break;
 574
 575                 case ACPI_RSC_COUNT_GPIO_VEN:
 576
 577                         item_count = ACPI_GET16(source);
 578                         ACPI_SET16(destination, item_count);
 579
 580                         aml_length =
 581                             (u16)(aml_length + (info->value * item_count));
 582                         acpi_rs_set_resource_length(aml_length, aml);
 583                         break;
 584
 585                 case ACPI_RSC_COUNT_GPIO_RES:
 586
 587                         /* Set resource source string length */
 588
 589                         item_count = ACPI_GET16(source);
 590                         ACPI_SET16(destination, aml_length);
 591
 592                         /* Compute offset for the Vendor Data */
 593
 594                         aml_length = (u16)(aml_length + item_count);
 595                         target = ACPI_ADD_PTR(void, aml, info->value);
 596
 597                         /* Set vendor offset only if there is vendor data */
 598
 599                         if (resource->data.gpio.vendor_length) {
 600                                 ACPI_SET16(target, aml_length);
 601                         }
 602
 603                         acpi_rs_set_resource_length(aml_length, aml);
 604                         break;
 605
 606                 case ACPI_RSC_COUNT_SERIAL_VEN:
 607
 608                         item_count = ACPI_GET16(source);
 609                         ACPI_SET16(destination, item_count + info->value);
 610                         aml_length = (u16)(aml_length + item_count);
 611                         acpi_rs_set_resource_length(aml_length, aml);
 612                         break;
 613
 614                 case ACPI_RSC_COUNT_SERIAL_RES:
 615
 616                         item_count = ACPI_GET16(source);
 617                         aml_length = (u16)(aml_length + item_count);
 618                         acpi_rs_set_resource_length(aml_length, aml);
 619                         break;
 620
 621                 case ACPI_RSC_LENGTH:
 622
 623                         acpi_rs_set_resource_length(info->value, aml);
 624                         break;
 625
 626                 case ACPI_RSC_MOVE8:
 627                 case ACPI_RSC_MOVE16:
 628                 case ACPI_RSC_MOVE32:
 629                 case ACPI_RSC_MOVE64:
 630
 631                         if (info->value) {
 632                                 item_count = info->value;
 633                         }
 634                         acpi_rs_move_data(destination, source, item_count,
 635                                           info->opcode);
 636                         break;
 637
 638                 case ACPI_RSC_MOVE_GPIO_PIN:
 639
 640                         destination = (char *)ACPI_ADD_PTR(void, aml,
 641                                                            ACPI_GET16
 642                                                            (destination));
 643                         source = *(u16 **)source;
 644                         acpi_rs_move_data(destination, source, item_count,
 645                                           info->opcode);
 646                         break;
 647
 648                 case ACPI_RSC_MOVE_GPIO_RES:
 649
 650                         /* Used for both resource_source string and vendor_data */
 651
 652                         destination = (char *)ACPI_ADD_PTR(void, aml,
 653                                                            ACPI_GET16
 654                                                            (destination));
 655                         source = *(u8 **)source;
 656                         acpi_rs_move_data(destination, source, item_count,
 657                                           info->opcode);
 658                         break;
 659
 660                 case ACPI_RSC_MOVE_SERIAL_VEN:
 661
 662                         destination = (char *)ACPI_ADD_PTR(void, aml,
 663                                                            (aml_length -
 664                                                             item_count));
 665                         source = *(u8 **)source;
 666                         acpi_rs_move_data(destination, source, item_count,
 667                                           info->opcode);
 668                         break;
 669
 670                 case ACPI_RSC_MOVE_SERIAL_RES:
 671
 672                         destination = (char *)ACPI_ADD_PTR(void, aml,
 673                                                            (aml_length -
 674                                                             item_count));
 675                         source = *(u8 **)source;
 676                         acpi_rs_move_data(destination, source, item_count,
 677                                           info->opcode);
 678                         break;
 679
 680                 case ACPI_RSC_ADDRESS:
 681
 682                         /* Set the Resource Type, General Flags, and Type-Specific Flags */
 683
 684                         acpi_rs_set_address_common(aml, resource);
 685                         break;
 686
 687                 case ACPI_RSC_SOURCEX:
 688                         /*
 689                          * Optional resource_source (Index and String)
 690                          */
 691                         aml_length =
 692                             acpi_rs_set_resource_source(aml,
 693                                                         (acpi_rs_length)
 694                                                         aml_length, source);
 695                         acpi_rs_set_resource_length(aml_length, aml);
 696                         break;
 697
 698                 case ACPI_RSC_SOURCE:
 699                         /*
 700                          * Optional resource_source (Index and String). This is the more
 701                          * complicated case used by the Interrupt() macro
 702                          */
 703                         aml_length =
 704                             acpi_rs_set_resource_source(aml, info->value,
 705                                                         source);
 706                         acpi_rs_set_resource_length(aml_length, aml);
 707                         break;
 708
 709                 case ACPI_RSC_BITMASK:
 710                         /*
 711                          * 8-bit encoded bitmask (DMA macro)
 712                          */
 713                         ACPI_SET8(destination,
 714                                   acpi_rs_encode_bitmask(source,
 715                                                          *ACPI_ADD_PTR(u8,
 716                                                                        resource,
 717                                                                        info->
 718                                                                        value)));
 719                         break;
 720
 721                 case ACPI_RSC_BITMASK16:
 722                         /*
 723                          * 16-bit encoded bitmask (IRQ macro)
 724                          */
 725                         temp16 = acpi_rs_encode_bitmask(source,
 726                                                         *ACPI_ADD_PTR(u8,
 727                                                                       resource,
 728                                                                       info->
 729                                                                       value));
 730                         ACPI_MOVE_16_TO_16(destination, &temp16);
 731                         break;
 732
 733                 case ACPI_RSC_EXIT_LE:
 734                         /*
 735                          * control - Exit conversion if less than or equal
 736                          */
 737                         if (item_count <= info->value) {
 738                                 goto exit;
 739                         }
 740                         break;
 741
 742                 case ACPI_RSC_EXIT_NE:
 743                         /*
 744                          * control - Exit conversion if not equal
 745                          */
 746                         switch (COMPARE_OPCODE(info)) {
 747                         case ACPI_RSC_COMPARE_VALUE:
 748
 749                                 if (*ACPI_ADD_PTR(u8, resource,
 750                                                   COMPARE_TARGET(info)) !=
 751                                     COMPARE_VALUE(info)) {
 752                                         goto exit;
 753                                 }
 754                                 break;
 755
 756                         default:
 757
 758                                 ACPI_ERROR((AE_INFO,
 759                                             "Invalid conversion sub-opcode"));
 760                                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 761                         }
 762                         break;
 763
 764                 case ACPI_RSC_EXIT_EQ:
 765                         /*
 766                          * control - Exit conversion if equal
 767                          */
 768                         if (*ACPI_ADD_PTR(u8, resource,
 769                                           COMPARE_TARGET(info)) ==
 770                             COMPARE_VALUE(info)) {
 771                                 goto exit;
 772                         }
 773                         break;
 774
 775                 default:
 776
 777                         ACPI_ERROR((AE_INFO, "Invalid conversion opcode"));
 778                         return_ACPI_STATUS(AE_BAD_PARAMETER);
 779                 }
 780
 781                 count--;
 782                 info++;
 783         }
 784
 785       exit:
 786         return_ACPI_STATUS(AE_OK);
 787 }
 788
 789 #if 0
 790 /* Previous resource validations */
 791
 792 if (aml->ext_address64.revision_ID != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
 793         return_ACPI_STATUS(AE_SUPPORT);
 794 }
 795
 796 if (resource->data.start_dpf.performance_robustness >= 3) {
 797         return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
 798 }
 799
 800 if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) {
 801         /*
 802          * Only [active_high, edge_sensitive] or [active_low, level_sensitive]
 803          * polarity/trigger interrupts are allowed (ACPI spec, section
 804          * "IRQ Format"), so 0x00 and 0x09 are illegal.
 805          */
 806         ACPI_ERROR((AE_INFO,
 807                     "Invalid interrupt polarity/trigger in resource list, 0x%X",
 808                     aml->irq.flags));
 809         return_ACPI_STATUS(AE_BAD_DATA);
 810 }
 811
 812 resource->data.extended_irq.interrupt_count = temp8;
 813 if (temp8 < 1) {
 814
 815         /* Must have at least one IRQ */
 816
 817         return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
 818 }
 819
 820 if (resource->data.dma.transfer == 0x03) {
 821         ACPI_ERROR((AE_INFO, "Invalid DMA.Transfer preference (3)"));
 822         return_ACPI_STATUS(AE_BAD_DATA);
 823 }
 824 #endif