LXR linux/drivers/acpi/acpica/rsmisc.c

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