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