drivers/acpi/resources/rsmisc.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsmisc - Miscellaneous resource descriptors
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2006, R. Byron Moore
   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 <acpi/acresrc.h>
  46
  47 #define _COMPONENT          ACPI_RESOURCES
  48 ACPI_MODULE_NAME("rsmisc")
  49
  50 #define INIT_RESOURCE_TYPE(i)       i->resource_offset
  51 #define INIT_RESOURCE_LENGTH(i)     i->aml_offset
  52 #define INIT_TABLE_LENGTH(i)        i->value
  53 #define COMPARE_OPCODE(i)           i->resource_offset
  54 #define COMPARE_TARGET(i)           i->aml_offset
  55 #define COMPARE_VALUE(i)            i->value
  56 /*******************************************************************************
  57  *
  58  * FUNCTION:    acpi_rs_convert_aml_to_resource
  59  *
  60  * PARAMETERS:  Resource            - Pointer to the resource descriptor
  61  *              Aml                 - Where the AML descriptor is returned
  62  *              Info                - Pointer to appropriate conversion table
  63  *
  64  * RETURN:      Status
  65  *
  66  * DESCRIPTION: Convert an external AML resource descriptor to the corresponding
  67  *              internal resource descriptor
  68  *
  69  ******************************************************************************/
  70 acpi_status
  71 acpi_rs_convert_aml_to_resource(struct acpi_resource *resource,
  72                                 union aml_resource *aml,
  73                                 struct acpi_rsconvert_info *info)
  74 {
  75         acpi_rs_length aml_resource_length;
  76         void *source;
  77         void *destination;
  78         char *target;
  79         u8 count;
  80         u8 flags_mode = FALSE;
  81         u16 item_count = 0;
  82         u16 temp16 = 0;
  83
  84         ACPI_FUNCTION_TRACE("rs_get_resource");
  85
  86         if (((acpi_native_uint) resource) & 0x3) {
  87                 /* Each internal resource struct is expected to be 32-bit aligned */
  88
  89                 ACPI_WARNING((AE_INFO,
  90                               "Misaligned resource pointer (get): %p Type %2.2X Len %X",
  91                               resource, resource->type, resource->length));
  92         }
  93
  94         /* Extract the resource Length field (does not include header length) */
  95
  96         aml_resource_length = acpi_ut_get_resource_length(aml);
  97
  98         /*
  99          * First table entry must be ACPI_RSC_INITxxx and must contain the
 100          * table length (# of table entries)
 101          */
 102         count = INIT_TABLE_LENGTH(info);
 103
 104         while (count) {
 105                 /*
 106                  * Source is the external AML byte stream buffer,
 107                  * destination is the internal resource descriptor
 108                  */
 109                 source = ACPI_ADD_PTR(void, aml, info->aml_offset);
 110                 destination =
 111                     ACPI_ADD_PTR(void, resource, info->resource_offset);
 112
 113                 switch (info->opcode) {
 114                 case ACPI_RSC_INITGET:
 115                         /*
 116                          * Get the resource type and the initial (minimum) length
 117                          */
 118                         ACPI_MEMSET(resource, 0, INIT_RESOURCE_LENGTH(info));
 119                         resource->type = INIT_RESOURCE_TYPE(info);
 120                         resource->length = INIT_RESOURCE_LENGTH(info);
 121                         break;
 122
 123                 case ACPI_RSC_INITSET:
 124                         break;
 125
 126                 case ACPI_RSC_FLAGINIT:
 127
 128                         flags_mode = TRUE;
 129                         break;
 130
 131                 case ACPI_RSC_1BITFLAG:
 132                         /*
 133                          * Mask and shift the flag bit
 134                          */
 135                         ACPI_SET8(destination) = (u8)
 136                             ((ACPI_GET8(source) >> info->value) & 0x01);
 137                         break;
 138
 139                 case ACPI_RSC_2BITFLAG:
 140                         /*
 141                          * Mask and shift the flag bits
 142                          */
 143                         ACPI_SET8(destination) = (u8)
 144                             ((ACPI_GET8(source) >> info->value) & 0x03);
 145                         break;
 146
 147                 case ACPI_RSC_COUNT:
 148
 149                         item_count = ACPI_GET8(source);
 150                         ACPI_SET8(destination) = (u8) item_count;
 151
 152                         resource->length = resource->length +
 153                             (info->value * (item_count - 1));
 154                         break;
 155
 156                 case ACPI_RSC_COUNT16:
 157
 158                         item_count = aml_resource_length;
 159                         ACPI_SET16(destination) = item_count;
 160
 161                         resource->length = resource->length +
 162                             (info->value * (item_count - 1));
 163                         break;
 164
 165                 case ACPI_RSC_LENGTH:
 166
 167                         resource->length = resource->length + info->value;
 168                         break;
 169
 170                 case ACPI_RSC_MOVE8:
 171                 case ACPI_RSC_MOVE16:
 172                 case ACPI_RSC_MOVE32:
 173                 case ACPI_RSC_MOVE64:
 174                         /*
 175                          * Raw data move. Use the Info value field unless item_count has
 176                          * been previously initialized via a COUNT opcode
 177                          */
 178                         if (info->value) {
 179                                 item_count = info->value;
 180                         }
 181                         acpi_rs_move_data(destination, source, item_count,
 182                                           info->opcode);
 183                         break;
 184
 185                 case ACPI_RSC_SET8:
 186
 187                         ACPI_MEMSET(destination, info->aml_offset, info->value);
 188                         break;
 189
 190                 case ACPI_RSC_DATA8:
 191
 192                         target = ACPI_ADD_PTR(char, resource, info->value);
 193                         ACPI_MEMCPY(destination, source, ACPI_GET16(target));
 194                         break;
 195
 196                 case ACPI_RSC_ADDRESS:
 197                         /*
 198                          * Common handler for address descriptor flags
 199                          */
 200                         if (!acpi_rs_get_address_common(resource, aml)) {
 201                                 return_ACPI_STATUS
 202                                     (AE_AML_INVALID_RESOURCE_TYPE);
 203                         }
 204                         break;
 205
 206                 case ACPI_RSC_SOURCE:
 207                         /*
 208                          * Optional resource_source (Index and String)
 209                          */
 210                         resource->length +=
 211                             acpi_rs_get_resource_source(aml_resource_length,
 212                                                         info->value,
 213                                                         destination, aml, NULL);
 214                         break;
 215
 216                 case ACPI_RSC_SOURCEX:
 217                         /*
 218                          * Optional resource_source (Index and String). This is the more
 219                          * complicated case used by the Interrupt() macro
 220                          */
 221                         target =
 222                             ACPI_ADD_PTR(char, resource,
 223                                          info->aml_offset + (item_count * 4));
 224
 225                         resource->length +=
 226                             acpi_rs_get_resource_source(aml_resource_length,
 227                                                         (acpi_rs_length) (((item_count - 1) * sizeof(u32)) + info->value), destination, aml, target);
 228                         break;
 229
 230                 case ACPI_RSC_BITMASK:
 231                         /*
 232                          * 8-bit encoded bitmask (DMA macro)
 233                          */
 234                         item_count =
 235                             acpi_rs_decode_bitmask(ACPI_GET8(source),
 236                                                    destination);
 237                         if (item_count) {
 238                                 resource->length += (item_count - 1);
 239                         }
 240
 241                         target = ACPI_ADD_PTR(char, resource, info->value);
 242                         ACPI_SET8(target) = (u8) item_count;
 243                         break;
 244
 245                 case ACPI_RSC_BITMASK16:
 246                         /*
 247                          * 16-bit encoded bitmask (IRQ macro)
 248                          */
 249                         ACPI_MOVE_16_TO_16(&temp16, source);
 250
 251                         item_count =
 252                             acpi_rs_decode_bitmask(temp16, destination);
 253                         if (item_count) {
 254                                 resource->length += (item_count - 1);
 255                         }
 256
 257                         target = ACPI_ADD_PTR(char, resource, info->value);
 258                         ACPI_SET8(target) = (u8) item_count;
 259                         break;
 260
 261                 case ACPI_RSC_EXIT_NE:
 262                         /*
 263                          * Control - Exit conversion if not equal
 264                          */
 265                         switch (info->resource_offset) {
 266                         case ACPI_RSC_COMPARE_AML_LENGTH:
 267                                 if (aml_resource_length != info->value) {
 268                                         goto exit;
 269                                 }
 270                                 break;
 271
 272                         case ACPI_RSC_COMPARE_VALUE:
 273                                 if (ACPI_GET8(source) != info->value) {
 274                                         goto exit;
 275                                 }
 276                                 break;
 277
 278                         default:
 279
 280                                 ACPI_ERROR((AE_INFO,
 281                                             "Invalid conversion sub-opcode"));
 282                                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 283                         }
 284                         break;
 285
 286                 default:
 287
 288                         ACPI_ERROR((AE_INFO, "Invalid conversion opcode"));
 289                         return_ACPI_STATUS(AE_BAD_PARAMETER);
 290                 }
 291
 292                 count--;
 293                 info++;
 294         }
 295
 296       exit:
 297         if (!flags_mode) {
 298                 /* Round the resource struct length up to the next 32-bit boundary */
 299
 300                 resource->length = ACPI_ROUND_UP_to_32_bITS(resource->length);
 301         }
 302         return_ACPI_STATUS(AE_OK);
 303 }
 304
 305 /*******************************************************************************
 306  *
 307  * FUNCTION:    acpi_rs_convert_resource_to_aml
 308  *
 309  * PARAMETERS:  Resource            - Pointer to the resource descriptor
 310  *              Aml                 - Where the AML descriptor is returned
 311  *              Info                - Pointer to appropriate conversion table
 312  *
 313  * RETURN:      Status
 314  *
 315  * DESCRIPTION: Convert an internal resource descriptor to the corresponding
 316  *              external AML resource descriptor.
 317  *
 318  ******************************************************************************/
 319
 320 acpi_status
 321 acpi_rs_convert_resource_to_aml(struct acpi_resource *resource,
 322                                 union aml_resource *aml,
 323                                 struct acpi_rsconvert_info *info)
 324 {
 325         void *source = NULL;
 326         void *destination;
 327         acpi_rsdesc_size aml_length = 0;
 328         u8 count;
 329         u16 temp16 = 0;
 330         u16 item_count = 0;
 331
 332         ACPI_FUNCTION_TRACE("rs_convert_resource_to_aml");
 333
 334         /*
 335          * First table entry must be ACPI_RSC_INITxxx and must contain the
 336          * table length (# of table entries)
 337          */
 338         count = INIT_TABLE_LENGTH(info);
 339
 340         while (count) {
 341                 /*
 342                  * Source is the internal resource descriptor,
 343                  * destination is the external AML byte stream buffer
 344                  */
 345                 source = ACPI_ADD_PTR(void, resource, info->resource_offset);
 346                 destination = ACPI_ADD_PTR(void, aml, info->aml_offset);
 347
 348                 switch (info->opcode) {
 349                 case ACPI_RSC_INITSET:
 350
 351                         ACPI_MEMSET(aml, 0, INIT_RESOURCE_LENGTH(info));
 352                         aml_length = INIT_RESOURCE_LENGTH(info);
 353                         acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info),
 354                                                     aml_length, aml);
 355                         break;
 356
 357                 case ACPI_RSC_INITGET:
 358                         break;
 359
 360                 case ACPI_RSC_FLAGINIT:
 361                         /*
 362                          * Clear the flag byte
 363                          */
 364                         ACPI_SET8(destination) = 0;
 365                         break;
 366
 367                 case ACPI_RSC_1BITFLAG:
 368                         /*
 369                          * Mask and shift the flag bit
 370                          */
 371                         ACPI_SET8(destination) |= (u8)
 372                             ((ACPI_GET8(source) & 0x01) << info->value);
 373                         break;
 374
 375                 case ACPI_RSC_2BITFLAG:
 376                         /*
 377                          * Mask and shift the flag bits
 378                          */
 379                         ACPI_SET8(destination) |= (u8)
 380                             ((ACPI_GET8(source) & 0x03) << info->value);
 381                         break;
 382
 383                 case ACPI_RSC_COUNT:
 384
 385                         item_count = ACPI_GET8(source);
 386                         ACPI_SET8(destination) = (u8) item_count;
 387
 388                         aml_length =
 389                             (u16) (aml_length +
 390                                    (info->value * (item_count - 1)));
 391                         break;
 392
 393                 case ACPI_RSC_COUNT16:
 394
 395                         item_count = ACPI_GET16(source);
 396                         aml_length = (u16) (aml_length + item_count);
 397                         acpi_rs_set_resource_length(aml_length, aml);
 398                         break;
 399
 400                 case ACPI_RSC_LENGTH:
 401
 402                         acpi_rs_set_resource_length(info->value, aml);
 403                         break;
 404
 405                 case ACPI_RSC_MOVE8:
 406                 case ACPI_RSC_MOVE16:
 407                 case ACPI_RSC_MOVE32:
 408                 case ACPI_RSC_MOVE64:
 409
 410                         if (info->value) {
 411                                 item_count = info->value;
 412                         }
 413                         acpi_rs_move_data(destination, source, item_count,
 414                                           info->opcode);
 415                         break;
 416
 417                 case ACPI_RSC_ADDRESS:
 418
 419                         /* Set the Resource Type, General Flags, and Type-Specific Flags */
 420
 421                         acpi_rs_set_address_common(aml, resource);
 422                         break;
 423
 424                 case ACPI_RSC_SOURCEX:
 425                         /*
 426                          * Optional resource_source (Index and String)
 427                          */
 428                         aml_length =
 429                             acpi_rs_set_resource_source(aml,
 430                                                         (acpi_rs_length)
 431                                                         aml_length, source);
 432                         acpi_rs_set_resource_length(aml_length, aml);
 433                         break;
 434
 435                 case ACPI_RSC_SOURCE:
 436                         /*
 437                          * Optional resource_source (Index and String). This is the more
 438                          * complicated case used by the Interrupt() macro
 439                          */
 440                         aml_length =
 441                             acpi_rs_set_resource_source(aml, info->value,
 442                                                         source);
 443                         acpi_rs_set_resource_length(aml_length, aml);
 444                         break;
 445
 446                 case ACPI_RSC_BITMASK:
 447                         /*
 448                          * 8-bit encoded bitmask (DMA macro)
 449                          */
 450                         ACPI_SET8(destination) = (u8)
 451                             acpi_rs_encode_bitmask(source,
 452                                                    *ACPI_ADD_PTR(u8, resource,
 453                                                                  info->value));
 454                         break;
 455
 456                 case ACPI_RSC_BITMASK16:
 457                         /*
 458                          * 16-bit encoded bitmask (IRQ macro)
 459                          */
 460                         temp16 = acpi_rs_encode_bitmask(source,
 461                                                         *ACPI_ADD_PTR(u8,
 462                                                                       resource,
 463                                                                       info->
 464                                                                       value));
 465                         ACPI_MOVE_16_TO_16(destination, &temp16);
 466                         break;
 467
 468                 case ACPI_RSC_EXIT_LE:
 469                         /*
 470                          * Control - Exit conversion if less than or equal
 471                          */
 472                         if (item_count <= info->value) {
 473                                 goto exit;
 474                         }
 475                         break;
 476
 477                 case ACPI_RSC_EXIT_NE:
 478                         /*
 479                          * Control - Exit conversion if not equal
 480                          */
 481                         switch (COMPARE_OPCODE(info)) {
 482                         case ACPI_RSC_COMPARE_VALUE:
 483
 484                                 if (*ACPI_ADD_PTR(u8, resource,
 485                                                   COMPARE_TARGET(info)) !=
 486                                     COMPARE_VALUE(info)) {
 487                                         goto exit;
 488                                 }
 489                                 break;
 490
 491                         default:
 492
 493                                 ACPI_ERROR((AE_INFO,
 494                                             "Invalid conversion sub-opcode"));
 495                                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 496                         }
 497                         break;
 498
 499                 default:
 500
 501                         ACPI_ERROR((AE_INFO, "Invalid conversion opcode"));
 502                         return_ACPI_STATUS(AE_BAD_PARAMETER);
 503                 }
 504
 505                 count--;
 506                 info++;
 507         }
 508
 509       exit:
 510         return_ACPI_STATUS(AE_OK);
 511 }
 512
 513 #if 0
 514 /* Previous resource validations */
 515
 516 if (aml->ext_address64.revision_iD != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
 517         return_ACPI_STATUS(AE_SUPPORT);
 518 }
 519
 520 if (resource->data.start_dpf.performance_robustness >= 3) {
 521         return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
 522 }
 523
 524 if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) {
 525         /*
 526          * Only [active_high, edge_sensitive] or [active_low, level_sensitive]
 527          * polarity/trigger interrupts are allowed (ACPI spec, section
 528          * "IRQ Format"), so 0x00 and 0x09 are illegal.
 529          */
 530         ACPI_ERROR((AE_INFO,
 531                     "Invalid interrupt polarity/trigger in resource list, %X",
 532                     aml->irq.flags));
 533         return_ACPI_STATUS(AE_BAD_DATA);
 534 }
 535
 536 resource->data.extended_irq.interrupt_count = temp8;
 537 if (temp8 < 1) {
 538         /* Must have at least one IRQ */
 539
 540         return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
 541 }
 542
 543 if (resource->data.dma.transfer == 0x03) {
 544         ACPI_ERROR((AE_INFO, "Invalid DMA.Transfer preference (3)"));
 545         return_ACPI_STATUS(AE_BAD_DATA);
 546 }
 547 #endif