SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 = ((u8 *) aml) + info->aml_offset;
 108                 destination = ((u8 *) resource) + info->resource_offset;
 109
 110                 switch (info->opcode) {
 111                 case ACPI_RSC_INITGET:
 112                         /*
 113                          * Get the resource type and the initial (minimum) length
 114                          */
 115                         ACPI_MEMSET(resource, 0, INIT_RESOURCE_LENGTH(info));
 116                         resource->type = INIT_RESOURCE_TYPE(info);
 117                         resource->length = INIT_RESOURCE_LENGTH(info);
 118                         break;
 119
 120                 case ACPI_RSC_INITSET:
 121                         break;
 122
 123                 case ACPI_RSC_FLAGINIT:
 124
 125                         flags_mode = TRUE;
 126                         break;
 127
 128                 case ACPI_RSC_1BITFLAG:
 129                         /*
 130                          * Mask and shift the flag bit
 131                          */
 132                         *((u8 *) destination) = (u8)
 133                             ((*((u8 *) source) >> info->value) & 0x01);
 134                         break;
 135
 136                 case ACPI_RSC_2BITFLAG:
 137                         /*
 138                          * Mask and shift the flag bits
 139                          */
 140                         *((u8 *) destination) = (u8)
 141                             ((*((u8 *) source) >> info->value) & 0x03);
 142                         break;
 143
 144                 case ACPI_RSC_COUNT:
 145
 146                         item_count = *((u8 *) source);
 147                         *((u8 *) destination) = (u8) item_count;
 148
 149                         resource->length = resource->length +
 150                             (info->value * (item_count - 1));
 151                         break;
 152
 153                 case ACPI_RSC_COUNT16:
 154
 155                         item_count = aml_resource_length;
 156                         *((u16 *) destination) = item_count;
 157
 158                         resource->length = resource->length +
 159                             (info->value * (item_count - 1));
 160                         break;
 161
 162                 case ACPI_RSC_LENGTH:
 163
 164                         resource->length = resource->length + info->value;
 165                         break;
 166
 167                 case ACPI_RSC_MOVE8:
 168                 case ACPI_RSC_MOVE16:
 169                 case ACPI_RSC_MOVE32:
 170                 case ACPI_RSC_MOVE64:
 171                         /*
 172                          * Raw data move. Use the Info value field unless item_count has
 173                          * been previously initialized via a COUNT opcode
 174                          */
 175                         if (info->value) {
 176                                 item_count = info->value;
 177                         }
 178                         acpi_rs_move_data(destination, source, item_count,
 179                                           info->opcode);
 180                         break;
 181
 182                 case ACPI_RSC_SET8:
 183
 184                         ACPI_MEMSET(destination, info->aml_offset, info->value);
 185                         break;
 186
 187                 case ACPI_RSC_DATA8:
 188
 189                         target = ((char *)resource) + info->value;
 190                         ACPI_MEMCPY(destination, source,
 191                                     *(ACPI_CAST_PTR(u16, 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                             ((char *)resource) + info->aml_offset +
 221                             (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(*((u8 *) source),
 234                                                    destination);
 235                         if (item_count) {
 236                                 resource->length +=
 237                                     resource->length + (item_count - 1);
 238                         }
 239
 240                         target = ((char *)resource) + info->value;
 241                         *((u8 *) target) = (u8) item_count;
 242                         break;
 243
 244                 case ACPI_RSC_BITMASK16:
 245                         /*
 246                          * 16-bit encoded bitmask (IRQ macro)
 247                          */
 248                         ACPI_MOVE_16_TO_16(&temp16, source);
 249
 250                         item_count =
 251                             acpi_rs_decode_bitmask(temp16, destination);
 252                         if (item_count) {
 253                                 resource->length =
 254                                     resource->length + (item_count - 1);
 255                         }
 256
 257                         target = ((char *)resource) + info->value;
 258                         *((u8 *) 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 (*((u8 *) source) != info->value) {
 274                                         goto exit;
 275                                 }
 276                                 break;
 277
 278                         default:
 279                                 acpi_os_printf
 280                                     ("*** Invalid conversion sub-opcode\n");
 281                                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 282                         }
 283                         break;
 284
 285                 default:
 286
 287                         acpi_os_printf("*** Invalid conversion opcode\n");
 288                         return_ACPI_STATUS(AE_BAD_PARAMETER);
 289                 }
 290
 291                 count--;
 292                 info++;
 293         }
 294
 295       exit:
 296         if (!flags_mode) {
 297                 /* Round the resource struct length up to the next 32-bit boundary */
 298
 299                 resource->length = ACPI_ROUND_UP_to_32_bITS(resource->length);
 300         }
 301         return_ACPI_STATUS(AE_OK);
 302 }
 303
 304 /*******************************************************************************
 305  *
 306  * FUNCTION:    acpi_rs_convert_resource_to_aml
 307  *
 308  * PARAMETERS:  Resource            - Pointer to the resource descriptor
 309  *              Aml                 - Where the AML descriptor is returned
 310  *              Info                - Pointer to appropriate conversion table
 311  *
 312  * RETURN:      Status
 313  *
 314  * DESCRIPTION: Convert an internal resource descriptor to the corresponding
 315  *              external AML resource descriptor.
 316  *
 317  ******************************************************************************/
 318
 319 acpi_status
 320 acpi_rs_convert_resource_to_aml(struct acpi_resource *resource,
 321                                 union aml_resource *aml,
 322                                 struct acpi_rsconvert_info *info)
 323 {
 324         void *source = NULL;
 325         void *destination;
 326         acpi_rsdesc_size aml_length = 0;
 327         u8 count;
 328         u16 temp16 = 0;
 329         u16 item_count = 0;
 330
 331         ACPI_FUNCTION_TRACE("rs_convert_resource_to_aml");
 332
 333         /* Validate the Resource pointer, must be 32-bit aligned */
 334
 335         if (((acpi_native_uint) resource) & 0x3) {
 336                 acpi_os_printf
 337                     ("**** SET: Misaligned resource pointer: %p Type %2.2X Len %X\n",
 338                      resource, resource->type, resource->length);
 339         }
 340
 341         /*
 342          * First table entry must be ACPI_RSC_INITxxx and must contain the
 343          * table length (# of table entries)
 344          */
 345         count = INIT_TABLE_LENGTH(info);
 346
 347         while (count) {
 348                 /*
 349                  * Source is the internal resource descriptor,
 350                  * destination is the external AML byte stream buffer
 351                  */
 352                 source = ((u8 *) resource) + info->resource_offset;
 353                 destination = ((u8 *) aml) + info->aml_offset;
 354
 355                 switch (info->opcode) {
 356                 case ACPI_RSC_INITSET:
 357
 358                         ACPI_MEMSET(aml, 0, INIT_RESOURCE_LENGTH(info));
 359                         aml_length = INIT_RESOURCE_LENGTH(info);
 360                         acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info),
 361                                                     aml_length, aml);
 362                         break;
 363
 364                 case ACPI_RSC_INITGET:
 365                         break;
 366
 367                 case ACPI_RSC_FLAGINIT:
 368                         /*
 369                          * Clear the flag byte
 370                          */
 371                         *((u8 *) destination) = 0;
 372                         break;
 373
 374                 case ACPI_RSC_1BITFLAG:
 375                         /*
 376                          * Mask and shift the flag bit
 377                          */
 378                         *((u8 *) destination) |= (u8)
 379                             ((*((u8 *) source) & 0x01) << info->value);
 380                         break;
 381
 382                 case ACPI_RSC_2BITFLAG:
 383                         /*
 384                          * Mask and shift the flag bits
 385                          */
 386                         *((u8 *) destination) |= (u8)
 387                             ((*((u8 *) source) & 0x03) << info->value);
 388                         break;
 389
 390                 case ACPI_RSC_COUNT:
 391
 392                         item_count = *((u8 *) source);
 393                         *((u8 *) destination) = (u8) item_count;
 394
 395                         aml_length = (u16) (aml_length +
 396                                             (info->value * (item_count - 1)));
 397                         break;
 398
 399                 case ACPI_RSC_COUNT16:
 400
 401                         item_count = *((u16 *) source);
 402                         aml_length = (u16) (aml_length + item_count);
 403                         acpi_rs_set_resource_length(aml_length, aml);
 404                         break;
 405
 406                 case ACPI_RSC_LENGTH:
 407
 408                         acpi_rs_set_resource_length(info->value, aml);
 409                         break;
 410
 411                 case ACPI_RSC_MOVE8:
 412                 case ACPI_RSC_MOVE16:
 413                 case ACPI_RSC_MOVE32:
 414                 case ACPI_RSC_MOVE64:
 415
 416                         if (info->value) {
 417                                 item_count = info->value;
 418                         }
 419                         acpi_rs_move_data(destination, source, item_count,
 420                                           info->opcode);
 421                         break;
 422
 423                 case ACPI_RSC_ADDRESS:
 424
 425                         /* Set the Resource Type, General Flags, and Type-Specific Flags */
 426
 427                         acpi_rs_set_address_common(aml, resource);
 428                         break;
 429
 430                 case ACPI_RSC_SOURCEX:
 431                         /*
 432                          * Optional resource_source (Index and String)
 433                          */
 434                         aml_length =
 435                             acpi_rs_set_resource_source(aml,
 436                                                         (acpi_rs_length)
 437                                                         aml_length, source);
 438                         acpi_rs_set_resource_length(aml_length, aml);
 439                         break;
 440
 441                 case ACPI_RSC_SOURCE:
 442                         /*
 443                          * Optional resource_source (Index and String). This is the more
 444                          * complicated case used by the Interrupt() macro
 445                          */
 446                         aml_length =
 447                             acpi_rs_set_resource_source(aml, info->value,
 448                                                         source);
 449                         acpi_rs_set_resource_length(aml_length, aml);
 450                         break;
 451
 452                 case ACPI_RSC_BITMASK:
 453                         /*
 454                          * 8-bit encoded bitmask (DMA macro)
 455                          */
 456                         *((u8 *) destination) = (u8)
 457                             acpi_rs_encode_bitmask(source,
 458                                                    *(((u8 *) resource) +
 459                                                      info->value));
 460                         break;
 461
 462                 case ACPI_RSC_BITMASK16:
 463                         /*
 464                          * 16-bit encoded bitmask (IRQ macro)
 465                          */
 466                         temp16 =
 467                             acpi_rs_encode_bitmask(source,
 468                                                    *(((u8 *) resource) +
 469                                                      info->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                                 if (*
 489                                     ((u8 *) (((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