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

   1/*******************************************************************************
   2 *
   3 * Module Name: rsmisc - Miscellaneous resource descriptors
   4 *
   5 ******************************************************************************/
   6
   7/*
   8 * Copyright (C) 2000 - 2016, 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
  49ACPI_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 ******************************************************************************/
  70acpi_status
  71acpi_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                        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 =
 193                            resource->length + (info->value * item_count);
 194                        break;
 195
 196                case ACPI_RSC_COUNT_GPIO_RES:
 197                        /*
 198                         * Vendor data is optional (length/offset may both be zero)
 199                         * Examine vendor data length field first
 200                         */
 201                        target = ACPI_ADD_PTR(void, aml, (info->value + 2));
 202                        if (ACPI_GET16(target)) {
 203
 204                                /* Use vendor offset to get resource source length */
 205
 206                                target = ACPI_ADD_PTR(void, aml, info->value);
 207                                item_count =
 208                                    ACPI_GET16(target) - ACPI_GET16(source);
 209                        } else {
 210                                /* No vendor data to worry about */
 211
 212                                item_count = aml->large_header.resource_length +
 213                                    sizeof(struct aml_resource_large_header) -
 214                                    ACPI_GET16(source);
 215                        }
 216
 217                        resource->length = resource->length + item_count;
 218                        ACPI_SET16(destination, item_count);
 219                        break;
 220
 221                case ACPI_RSC_COUNT_SERIAL_VEN:
 222
 223                        item_count = ACPI_GET16(source) - info->value;
 224
 225                        resource->length = resource->length + item_count;
 226                        ACPI_SET16(destination, item_count);
 227                        break;
 228
 229                case ACPI_RSC_COUNT_SERIAL_RES:
 230
 231                        item_count = (aml_resource_length +
 232                                      sizeof(struct aml_resource_large_header))
 233                            - ACPI_GET16(source) - info->value;
 234
 235                        resource->length = resource->length + item_count;
 236                        ACPI_SET16(destination, item_count);
 237                        break;
 238
 239                case ACPI_RSC_LENGTH:
 240
 241                        resource->length = resource->length + info->value;
 242                        break;
 243
 244                case ACPI_RSC_MOVE8:
 245                case ACPI_RSC_MOVE16:
 246                case ACPI_RSC_MOVE32:
 247                case ACPI_RSC_MOVE64:
 248                        /*
 249                         * Raw data move. Use the Info value field unless item_count has
 250                         * been previously initialized via a COUNT opcode
 251                         */
 252                        if (info->value) {
 253                                item_count = info->value;
 254                        }
 255                        acpi_rs_move_data(destination, source, item_count,
 256                                          info->opcode);
 257                        break;
 258
 259                case ACPI_RSC_MOVE_GPIO_PIN:
 260
 261                        /* Generate and set the PIN data pointer */
 262
 263                        target = (char *)ACPI_ADD_PTR(void, resource,
 264                                                      (resource->length -
 265                                                       item_count * 2));
 266                        *(u16 **)destination = ACPI_CAST_PTR(u16, target);
 267
 268                        /* Copy the PIN data */
 269
 270                        source = ACPI_ADD_PTR(void, aml, ACPI_GET16(source));
 271                        acpi_rs_move_data(target, source, item_count,
 272                                          info->opcode);
 273                        break;
 274
 275                case ACPI_RSC_MOVE_GPIO_RES:
 276
 277                        /* Generate and set the resource_source string pointer */
 278
 279                        target = (char *)ACPI_ADD_PTR(void, resource,
 280                                                      (resource->length -
 281                                                       item_count));
 282                        *(u8 **)destination = ACPI_CAST_PTR(u8, target);
 283
 284                        /* Copy the resource_source string */
 285
 286                        source = ACPI_ADD_PTR(void, aml, ACPI_GET16(source));
 287                        acpi_rs_move_data(target, source, item_count,
 288                                          info->opcode);
 289                        break;
 290
 291                case ACPI_RSC_MOVE_SERIAL_VEN:
 292
 293                        /* Generate and set the Vendor Data pointer */
 294
 295                        target = (char *)ACPI_ADD_PTR(void, resource,
 296                                                      (resource->length -
 297                                                       item_count));
 298                        *(u8 **)destination = ACPI_CAST_PTR(u8, target);
 299
 300                        /* Copy the Vendor Data */
 301
 302                        source = ACPI_ADD_PTR(void, aml, info->value);
 303                        acpi_rs_move_data(target, source, item_count,
 304                                          info->opcode);
 305                        break;
 306
 307                case ACPI_RSC_MOVE_SERIAL_RES:
 308
 309                        /* Generate and set the resource_source string pointer */
 310
 311                        target = (char *)ACPI_ADD_PTR(void, resource,
 312                                                      (resource->length -
 313                                                       item_count));
 314                        *(u8 **)destination = ACPI_CAST_PTR(u8, target);
 315
 316                        /* Copy the resource_source string */
 317
 318                        source =
 319                            ACPI_ADD_PTR(void, aml,
 320                                         (ACPI_GET16(source) + info->value));
 321                        acpi_rs_move_data(target, source, item_count,
 322                                          info->opcode);
 323                        break;
 324
 325                case ACPI_RSC_SET8:
 326
 327                        memset(destination, info->aml_offset, info->value);
 328                        break;
 329
 330                case ACPI_RSC_DATA8:
 331
 332                        target = ACPI_ADD_PTR(char, resource, info->value);
 333                        memcpy(destination, source, ACPI_GET16(target));
 334                        break;
 335
 336                case ACPI_RSC_ADDRESS:
 337                        /*
 338                         * Common handler for address descriptor flags
 339                         */
 340                        if (!acpi_rs_get_address_common(resource, aml)) {
 341                                return_ACPI_STATUS
 342                                    (AE_AML_INVALID_RESOURCE_TYPE);
 343                        }
 344                        break;
 345
 346                case ACPI_RSC_SOURCE:
 347                        /*
 348                         * Optional resource_source (Index and String)
 349                         */
 350                        resource->length +=
 351                            acpi_rs_get_resource_source(aml_resource_length,
 352                                                        info->value,
 353                                                        destination, aml, NULL);
 354                        break;
 355
 356                case ACPI_RSC_SOURCEX:
 357                        /*
 358                         * Optional resource_source (Index and String). This is the more
 359                         * complicated case used by the Interrupt() macro
 360                         */
 361                        target = ACPI_ADD_PTR(char, resource,
 362                                              info->aml_offset +
 363                                              (item_count * 4));
 364
 365                        resource->length +=
 366                            acpi_rs_get_resource_source(aml_resource_length,
 367                                                        (acpi_rs_length)
 368                                                        (((item_count -
 369                                                           1) * sizeof(u32)) +
 370                                                         info->value),
 371                                                        destination, aml,
 372                                                        target);
 373                        break;
 374
 375                case ACPI_RSC_BITMASK:
 376                        /*
 377                         * 8-bit encoded bitmask (DMA macro)
 378                         */
 379                        item_count =
 380                            acpi_rs_decode_bitmask(ACPI_GET8(source),
 381                                                   destination);
 382                        if (item_count) {
 383                                resource->length += (item_count - 1);
 384                        }
 385
 386                        target = ACPI_ADD_PTR(char, resource, info->value);
 387                        ACPI_SET8(target, item_count);
 388                        break;
 389
 390                case ACPI_RSC_BITMASK16:
 391                        /*
 392                         * 16-bit encoded bitmask (IRQ macro)
 393                         */
 394                        ACPI_MOVE_16_TO_16(&temp16, source);
 395
 396                        item_count =
 397                            acpi_rs_decode_bitmask(temp16, destination);
 398                        if (item_count) {
 399                                resource->length += (item_count - 1);
 400                        }
 401
 402                        target = ACPI_ADD_PTR(char, resource, info->value);
 403                        ACPI_SET8(target, item_count);
 404                        break;
 405
 406                case ACPI_RSC_EXIT_NE:
 407                        /*
 408                         * control - Exit conversion if not equal
 409                         */
 410                        switch (info->resource_offset) {
 411                        case ACPI_RSC_COMPARE_AML_LENGTH:
 412
 413                                if (aml_resource_length != info->value) {
 414                                        goto exit;
 415                                }
 416                                break;
 417
 418                        case ACPI_RSC_COMPARE_VALUE:
 419
 420                                if (ACPI_GET8(source) != info->value) {
 421                                        goto exit;
 422                                }
 423                                break;
 424
 425                        default:
 426
 427                                ACPI_ERROR((AE_INFO,
 428                                            "Invalid conversion sub-opcode"));
 429                                return_ACPI_STATUS(AE_BAD_PARAMETER);
 430                        }
 431                        break;
 432
 433                default:
 434
 435                        ACPI_ERROR((AE_INFO, "Invalid conversion opcode"));
 436                        return_ACPI_STATUS(AE_BAD_PARAMETER);
 437                }
 438
 439                count--;
 440                info++;
 441        }
 442
 443exit:
 444        if (!flags_mode) {
 445
 446                /* Round the resource struct length up to the next boundary (32 or 64) */
 447
 448                resource->length = (u32)
 449                    ACPI_ROUND_UP_TO_NATIVE_WORD(resource->length);
 450        }
 451        return_ACPI_STATUS(AE_OK);
 452}
 453
 454/*******************************************************************************
 455 *
 456 * FUNCTION:    acpi_rs_convert_resource_to_aml
 457 *
 458 * PARAMETERS:  resource            - Pointer to the resource descriptor
 459 *              aml                 - Where the AML descriptor is returned
 460 *              info                - Pointer to appropriate conversion table
 461 *
 462 * RETURN:      Status
 463 *
 464 * DESCRIPTION: Convert an internal resource descriptor to the corresponding
 465 *              external AML resource descriptor.
 466 *
 467 ******************************************************************************/
 468
 469acpi_status
 470acpi_rs_convert_resource_to_aml(struct acpi_resource *resource,
 471                                union aml_resource *aml,
 472                                struct acpi_rsconvert_info *info)
 473{
 474        void *source = NULL;
 475        void *destination;
 476        char *target;
 477        acpi_rsdesc_size aml_length = 0;
 478        u8 count;
 479        u16 temp16 = 0;
 480        u16 item_count = 0;
 481
 482        ACPI_FUNCTION_TRACE(rs_convert_resource_to_aml);
 483
 484        if (!info) {
 485                return_ACPI_STATUS(AE_BAD_PARAMETER);
 486        }
 487
 488        /*
 489         * First table entry must be ACPI_RSC_INITxxx and must contain the
 490         * table length (# of table entries)
 491         */
 492        count = INIT_TABLE_LENGTH(info);
 493
 494        while (count) {
 495                /*
 496                 * Source is the internal resource descriptor,
 497                 * destination is the external AML byte stream buffer
 498                 */
 499                source = ACPI_ADD_PTR(void, resource, info->resource_offset);
 500                destination = ACPI_ADD_PTR(void, aml, info->aml_offset);
 501
 502                switch (info->opcode) {
 503                case ACPI_RSC_INITSET:
 504
 505                        memset(aml, 0, INIT_RESOURCE_LENGTH(info));
 506                        aml_length = INIT_RESOURCE_LENGTH(info);
 507                        acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info),
 508                                                    aml_length, aml);
 509                        break;
 510
 511                case ACPI_RSC_INITGET:
 512                        break;
 513
 514                case ACPI_RSC_FLAGINIT:
 515                        /*
 516                         * Clear the flag byte
 517                         */
 518                        ACPI_SET8(destination, 0);
 519                        break;
 520
 521                case ACPI_RSC_1BITFLAG:
 522                        /*
 523                         * Mask and shift the flag bit
 524                         */
 525                        ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
 526                                     ((ACPI_GET8(source) & 0x01) << info->
 527                                      value));
 528                        break;
 529
 530                case ACPI_RSC_2BITFLAG:
 531                        /*
 532                         * Mask and shift the flag bits
 533                         */
 534                        ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
 535                                     ((ACPI_GET8(source) & 0x03) << info->
 536                                      value));
 537                        break;
 538
 539                case ACPI_RSC_3BITFLAG:
 540                        /*
 541                         * Mask and shift the flag bits
 542                         */
 543                        ACPI_SET_BIT(*ACPI_CAST8(destination), (u8)
 544                                     ((ACPI_GET8(source) & 0x07) << info->
 545                                      value));
 546                        break;
 547
 548                case ACPI_RSC_COUNT:
 549
 550                        item_count = ACPI_GET8(source);
 551                        ACPI_SET8(destination, item_count);
 552
 553                        aml_length = (u16)
 554                            (aml_length + (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 =
 726                            acpi_rs_encode_bitmask(source,
 727                                                   *ACPI_ADD_PTR(u8, resource,
 728                                                                 info->value));
 729                        ACPI_MOVE_16_TO_16(destination, &temp16);
 730                        break;
 731
 732                case ACPI_RSC_EXIT_LE:
 733                        /*
 734                         * control - Exit conversion if less than or equal
 735                         */
 736                        if (item_count <= info->value) {
 737                                goto exit;
 738                        }
 739                        break;
 740
 741                case ACPI_RSC_EXIT_NE:
 742                        /*
 743                         * control - Exit conversion if not equal
 744                         */
 745                        switch (COMPARE_OPCODE(info)) {
 746                        case ACPI_RSC_COMPARE_VALUE:
 747
 748                                if (*ACPI_ADD_PTR(u8, resource,
 749                                                  COMPARE_TARGET(info)) !=
 750                                    COMPARE_VALUE(info)) {
 751                                        goto exit;
 752                                }
 753                                break;
 754
 755                        default:
 756
 757                                ACPI_ERROR((AE_INFO,
 758                                            "Invalid conversion sub-opcode"));
 759                                return_ACPI_STATUS(AE_BAD_PARAMETER);
 760                        }
 761                        break;
 762
 763                case ACPI_RSC_EXIT_EQ:
 764                        /*
 765                         * control - Exit conversion if equal
 766                         */
 767                        if (*ACPI_ADD_PTR(u8, resource,
 768                                          COMPARE_TARGET(info)) ==
 769                            COMPARE_VALUE(info)) {
 770                                goto exit;
 771                        }
 772                        break;
 773
 774                default:
 775
 776                        ACPI_ERROR((AE_INFO, "Invalid conversion opcode"));
 777                        return_ACPI_STATUS(AE_BAD_PARAMETER);
 778                }
 779
 780                count--;
 781                info++;
 782        }
 783
 784exit:
 785        return_ACPI_STATUS(AE_OK);
 786}
 787
 788#if 0
 789/* Previous resource validations */
 790
 791if (aml->ext_address64.revision_ID != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
 792        return_ACPI_STATUS(AE_SUPPORT);
 793}
 794
 795if (resource->data.start_dpf.performance_robustness >= 3) {
 796        return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
 797}
 798
 799if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) {
 800        /*
 801         * Only [active_high, edge_sensitive] or [active_low, level_sensitive]
 802         * polarity/trigger interrupts are allowed (ACPI spec, section
 803         * "IRQ Format"), so 0x00 and 0x09 are illegal.
 804         */
 805        ACPI_ERROR((AE_INFO,
 806                    "Invalid interrupt polarity/trigger in resource list, 0x%X",
 807                    aml->irq.flags));
 808        return_ACPI_STATUS(AE_BAD_DATA);
 809}
 810
 811resource->data.extended_irq.interrupt_count = temp8;
 812if (temp8 < 1) {
 813
 814        /* Must have at least one IRQ */
 815
 816        return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
 817}
 818
 819if (resource->data.dma.transfer == 0x03) {
 820        ACPI_ERROR((AE_INFO, "Invalid DMA.Transfer preference (3)"));
 821        return_ACPI_STATUS(AE_BAD_DATA);
 822}
 823#endif
 824