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