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