drivers/acpi/resources/rsmisc.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsmisc - Miscellaneous resource descriptors
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2005, 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         /* Validate the Resource pointer, must be 32-bit aligned */
 332
 333         if (((acpi_native_uint) resource) & 0x3) {
 334                 acpi_os_printf
 335                     ("**** SET: Misaligned resource pointer: %p Type %2.2X Len %X\n",
 336                      resource, resource->type, resource->length);
 337         }
 338
 339         /*
 340          * First table entry must be ACPI_RSC_INITxxx and must contain the
 341          * table length (# of table entries)
 342          */
 343         count = INIT_TABLE_LENGTH(info);
 344
 345         while (count) {
 346                 /*
 347                  * Source is the internal resource descriptor,
 348                  * destination is the external AML byte stream buffer
 349                  */
 350                 source = ACPI_ADD_PTR(void, resource, info->resource_offset);
 351                 destination = ACPI_ADD_PTR(void, aml, info->aml_offset);
 352
 353                 switch (info->opcode) {
 354                 case ACPI_RSC_INITSET:
 355
 356                         ACPI_MEMSET(aml, 0, INIT_RESOURCE_LENGTH(info));
 357                         aml_length = INIT_RESOURCE_LENGTH(info);
 358                         acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info),
 359                                                     aml_length, aml);
 360                         break;
 361
 362                 case ACPI_RSC_INITGET:
 363                         break;
 364
 365                 case ACPI_RSC_FLAGINIT:
 366                         /*
 367                          * Clear the flag byte
 368                          */
 369                         ACPI_SET8(destination) = 0;
 370                         break;
 371
 372                 case ACPI_RSC_1BITFLAG:
 373                         /*
 374                          * Mask and shift the flag bit
 375                          */
 376                         ACPI_SET8(destination) |= (u8)
 377                             ((ACPI_GET8(source) & 0x01) << info->value);
 378                         break;
 379
 380                 case ACPI_RSC_2BITFLAG:
 381                         /*
 382                          * Mask and shift the flag bits
 383                          */
 384                         ACPI_SET8(destination) |= (u8)
 385                             ((ACPI_GET8(source) & 0x03) << info->value);
 386                         break;
 387
 388                 case ACPI_RSC_COUNT:
 389
 390                         item_count = ACPI_GET8(source);
 391                         ACPI_SET8(destination) = (u8) item_count;
 392
 393                         aml_length =
 394                             (u16) (aml_length +
 395                                    (info->value * (item_count - 1)));
 396                         break;
 397
 398                 case ACPI_RSC_COUNT16:
 399
 400                         item_count = ACPI_GET16(source);
 401                         aml_length = (u16) (aml_length + item_count);
 402                         acpi_rs_set_resource_length(aml_length, aml);
 403                         break;
 404
 405                 case ACPI_RSC_LENGTH:
 406
 407                         acpi_rs_set_resource_length(info->value, aml);
 408                         break;
 409
 410                 case ACPI_RSC_MOVE8:
 411                 case ACPI_RSC_MOVE16:
 412                 case ACPI_RSC_MOVE32:
 413                 case ACPI_RSC_MOVE64:
 414
 415                         if (info->value) {
 416                                 item_count = info->value;
 417                         }
 418                         acpi_rs_move_data(destination, source, item_count,
 419                                           info->opcode);
 420                         break;
 421
 422                 case ACPI_RSC_ADDRESS:
 423
 424                         /* Set the Resource Type, General Flags, and Type-Specific Flags */
 425
 426                         acpi_rs_set_address_common(aml, resource);
 427                         break;
 428
 429                 case ACPI_RSC_SOURCEX:
 430                         /*
 431                          * Optional resource_source (Index and String)
 432                          */
 433                         aml_length =
 434                             acpi_rs_set_resource_source(aml,
 435                                                         (acpi_rs_length)
 436                                                         aml_length, source);
 437                         acpi_rs_set_resource_length(aml_length, aml);
 438                         break;
 439
 440                 case ACPI_RSC_SOURCE:
 441                         /*
 442                          * Optional resource_source (Index and String). This is the more
 443                          * complicated case used by the Interrupt() macro
 444                          */
 445                         aml_length =
 446                             acpi_rs_set_resource_source(aml, info->value,
 447                                                         source);
 448                         acpi_rs_set_resource_length(aml_length, aml);
 449                         break;
 450
 451                 case ACPI_RSC_BITMASK:
 452                         /*
 453                          * 8-bit encoded bitmask (DMA macro)
 454                          */
 455                         ACPI_SET8(destination) = (u8)
 456                             acpi_rs_encode_bitmask(source,
 457                                                    *ACPI_ADD_PTR(u8, resource,
 458                                                                  info->value));
 459                         break;
 460
 461                 case ACPI_RSC_BITMASK16:
 462                         /*
 463                          * 16-bit encoded bitmask (IRQ macro)
 464                          */
 465                         temp16 = acpi_rs_encode_bitmask(source,
 466                                                         *ACPI_ADD_PTR(u8,
 467                                                                       resource,
 468                                                                       info->
 469                                                                       value));
 470                         ACPI_MOVE_16_TO_16(destination, &temp16);
 471                         break;
 472
 473                 case ACPI_RSC_EXIT_LE:
 474                         /*
 475                          * Control - Exit conversion if less than or equal
 476                          */
 477                         if (item_count <= info->value) {
 478                                 goto exit;
 479                         }
 480                         break;
 481
 482                 case ACPI_RSC_EXIT_NE:
 483                         /*
 484                          * Control - Exit conversion if not equal
 485                          */
 486                         switch (COMPARE_OPCODE(info)) {
 487                         case ACPI_RSC_COMPARE_VALUE:
 488
 489                                 if (*ACPI_ADD_PTR(u8, resource,
 490                                                   COMPARE_TARGET(info)) !=
 491                                     COMPARE_VALUE(info)) {
 492                                         goto exit;
 493                                 }
 494                                 break;
 495
 496                         default:
 497                                 acpi_os_printf
 498                                     ("*** Invalid conversion sub-opcode\n");
 499                                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 500                         }
 501                         break;
 502
 503                 default:
 504
 505                         acpi_os_printf("*** Invalid conversion opcode\n");
 506                         return_ACPI_STATUS(AE_BAD_PARAMETER);
 507                 }
 508
 509                 count--;
 510                 info++;
 511         }
 512
 513       exit:
 514         return_ACPI_STATUS(AE_OK);
 515 }
 516
 517 #if 0
 518 /* Previous resource validations */
 519
 520 if (aml->ext_address64.revision_iD != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
 521         return_ACPI_STATUS(AE_SUPPORT);
 522 }
 523
 524 if (resource->data.start_dpf.performance_robustness >= 3) {
 525         return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
 526 }
 527
 528 if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) {
 529         /*
 530          * Only [active_high, edge_sensitive] or [active_low, level_sensitive]
 531          * polarity/trigger interrupts are allowed (ACPI spec, section
 532          * "IRQ Format"), so 0x00 and 0x09 are illegal.
 533          */
 534         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 535                           "Invalid interrupt polarity/trigger in resource list, %X\n",
 536                           aml->irq.flags));
 537         return_ACPI_STATUS(AE_BAD_DATA);
 538 }
 539
 540 resource->data.extended_irq.interrupt_count = temp8;
 541 if (temp8 < 1) {
 542         /* Must have at least one IRQ */
 543
 544         return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
 545 }
 546
 547 if (resource->data.dma.transfer == 0x03) {
 548         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 549                           "Invalid DMA.Transfer preference (3)\n"));
 550         return_ACPI_STATUS(AE_BAD_DATA);
 551 }
 552 #endif