git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/resources/rsirq.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsirq - IRQ 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
  45 #include <acpi/acpi.h>
  46 #include <acpi/acresrc.h>
  47
  48 #define _COMPONENT          ACPI_RESOURCES
  49          ACPI_MODULE_NAME    ("rsirq")
  50
  51
  52 /*******************************************************************************
  53  *
  54  * FUNCTION:    acpi_rs_irq_resource
  55  *
  56  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
  57  *                                        stream
  58  *              bytes_consumed          - Pointer to where the number of bytes
  59  *                                        consumed the byte_stream_buffer is
  60  *                                        returned
  61  *              output_buffer           - Pointer to the return data buffer
  62  *              structure_size          - Pointer to where the number of bytes
  63  *                                        in the return data struct is returned
  64  *
  65  * RETURN:      Status
  66  *
  67  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
  68  *              structure pointed to by the output_buffer. Return the
  69  *              number of bytes consumed from the byte stream.
  70  *
  71  ******************************************************************************/
  72
  73 acpi_status
  74 acpi_rs_irq_resource (
  75         u8                              *byte_stream_buffer,
  76         acpi_size                       *bytes_consumed,
  77         u8                              **output_buffer,
  78         acpi_size                       *structure_size)
  79 {
  80         u8                              *buffer = byte_stream_buffer;
  81         struct acpi_resource            *output_struct = (void *) *output_buffer;
  82         u16                             temp16 = 0;
  83         u8                              temp8 = 0;
  84         u8                              index;
  85         u8                              i;
  86         acpi_size                       struct_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_irq);
  87
  88
  89         ACPI_FUNCTION_TRACE ("rs_irq_resource");
  90
  91
  92         /*
  93          * The number of bytes consumed are contained in the descriptor
  94          *  (Bits:0-1)
  95          */
  96         temp8 = *buffer;
  97         *bytes_consumed = (temp8 & 0x03) + 1;
  98         output_struct->id = ACPI_RSTYPE_IRQ;
  99
 100         /*
 101          * Point to the 16-bits of Bytes 1 and 2
 102          */
 103         buffer += 1;
 104         ACPI_MOVE_16_TO_16 (&temp16, buffer);
 105
 106         output_struct->data.irq.number_of_interrupts = 0;
 107
 108         /* Decode the IRQ bits */
 109
 110         for (i = 0, index = 0; index < 16; index++) {
 111                 if ((temp16 >> index) & 0x01) {
 112                         output_struct->data.irq.interrupts[i] = index;
 113                         i++;
 114                 }
 115         }
 116
 117         /* Zero interrupts is valid */
 118
 119         output_struct->data.irq.number_of_interrupts = i;
 120         if (i > 0) {
 121                 /*
 122                  * Calculate the structure size based upon the number of interrupts
 123                  */
 124                 struct_size += ((acpi_size) i - 1) * 4;
 125         }
 126
 127         /*
 128          * Point to Byte 3 if it is used
 129          */
 130         if (4 == *bytes_consumed) {
 131                 buffer += 2;
 132                 temp8 = *buffer;
 133
 134                 /*
 135                  * Check for HE, LL interrupts
 136                  */
 137                 switch (temp8 & 0x09) {
 138                 case 0x01: /* HE */
 139                         output_struct->data.irq.edge_level = ACPI_EDGE_SENSITIVE;
 140                         output_struct->data.irq.active_high_low = ACPI_ACTIVE_HIGH;
 141                         break;
 142
 143                 case 0x08: /* LL */
 144                         output_struct->data.irq.edge_level = ACPI_LEVEL_SENSITIVE;
 145                         output_struct->data.irq.active_high_low = ACPI_ACTIVE_LOW;
 146                         break;
 147
 148                 default:
 149                         /*
 150                          * Only _LL and _HE polarity/trigger interrupts
 151                          * are allowed (ACPI spec, section "IRQ Format")
 152                          * so 0x00 and 0x09 are illegal.
 153                          */
 154                         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 155                                 "Invalid interrupt polarity/trigger in resource list, %X\n", temp8));
 156                         return_ACPI_STATUS (AE_BAD_DATA);
 157                 }
 158
 159                 /*
 160                  * Check for sharable
 161                  */
 162                 output_struct->data.irq.shared_exclusive = (temp8 >> 3) & 0x01;
 163         }
 164         else {
 165                 /*
 166                  * Assume Edge Sensitive, Active High, Non-Sharable
 167                  * per ACPI Specification
 168                  */
 169                 output_struct->data.irq.edge_level = ACPI_EDGE_SENSITIVE;
 170                 output_struct->data.irq.active_high_low = ACPI_ACTIVE_HIGH;
 171                 output_struct->data.irq.shared_exclusive = ACPI_EXCLUSIVE;
 172         }
 173
 174         /*
 175          * Set the Length parameter
 176          */
 177         output_struct->length = (u32) struct_size;
 178
 179         /*
 180          * Return the final size of the structure
 181          */
 182         *structure_size = struct_size;
 183         return_ACPI_STATUS (AE_OK);
 184 }
 185
 186
 187 /*******************************************************************************
 188  *
 189  * FUNCTION:    acpi_rs_irq_stream
 190  *
 191  * PARAMETERS:  linked_list             - Pointer to the resource linked list
 192  *              output_buffer           - Pointer to the user's return buffer
 193  *              bytes_consumed          - Pointer to where the number of bytes
 194  *                                        used in the output_buffer is returned
 195  *
 196  * RETURN:      Status
 197  *
 198  * DESCRIPTION: Take the linked list resource structure and fills in the
 199  *              the appropriate bytes in a byte stream
 200  *
 201  ******************************************************************************/
 202
 203 acpi_status
 204 acpi_rs_irq_stream (
 205         struct acpi_resource            *linked_list,
 206         u8                              **output_buffer,
 207         acpi_size                       *bytes_consumed)
 208 {
 209         u8                              *buffer = *output_buffer;
 210         u16                             temp16 = 0;
 211         u8                              temp8 = 0;
 212         u8                              index;
 213         u8                              IRqinfo_byte_needed;
 214
 215
 216         ACPI_FUNCTION_TRACE ("rs_irq_stream");
 217
 218
 219         /*
 220          * The descriptor field is set based upon whether a third byte is
 221          * needed to contain the IRQ Information.
 222          */
 223         if (ACPI_EDGE_SENSITIVE == linked_list->data.irq.edge_level &&
 224                 ACPI_ACTIVE_HIGH == linked_list->data.irq.active_high_low &&
 225                 ACPI_EXCLUSIVE == linked_list->data.irq.shared_exclusive) {
 226                 *buffer = 0x22;
 227                 IRqinfo_byte_needed = FALSE;
 228         }
 229         else {
 230                 *buffer = 0x23;
 231                 IRqinfo_byte_needed = TRUE;
 232         }
 233
 234         buffer += 1;
 235         temp16 = 0;
 236
 237         /*
 238          * Loop through all of the interrupts and set the mask bits
 239          */
 240         for(index = 0;
 241                 index < linked_list->data.irq.number_of_interrupts;
 242                 index++) {
 243                 temp8 = (u8) linked_list->data.irq.interrupts[index];
 244                 temp16 |= 0x1 << temp8;
 245         }
 246
 247         ACPI_MOVE_16_TO_16 (buffer, &temp16);
 248         buffer += 2;
 249
 250         /*
 251          * Set the IRQ Info byte if needed.
 252          */
 253         if (IRqinfo_byte_needed) {
 254                 temp8 = 0;
 255                 temp8 = (u8) ((linked_list->data.irq.shared_exclusive &
 256                                  0x01) << 4);
 257
 258                 if (ACPI_LEVEL_SENSITIVE == linked_list->data.irq.edge_level &&
 259                         ACPI_ACTIVE_LOW == linked_list->data.irq.active_high_low) {
 260                         temp8 |= 0x08;
 261                 }
 262                 else {
 263                         temp8 |= 0x01;
 264                 }
 265
 266                 *buffer = temp8;
 267                 buffer += 1;
 268         }
 269
 270         /*
 271          * Return the number of bytes consumed in this operation
 272          */
 273         *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer);
 274         return_ACPI_STATUS (AE_OK);
 275 }
 276
 277
 278 /*******************************************************************************
 279  *
 280  * FUNCTION:    acpi_rs_extended_irq_resource
 281  *
 282  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
 283  *                                        stream
 284  *              bytes_consumed          - Pointer to where the number of bytes
 285  *                                        consumed the byte_stream_buffer is
 286  *                                        returned
 287  *              output_buffer           - Pointer to the return data buffer
 288  *              structure_size          - Pointer to where the number of bytes
 289  *                                        in the return data struct is returned
 290  *
 291  * RETURN:      Status
 292  *
 293  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
 294  *              structure pointed to by the output_buffer. Return the
 295  *              number of bytes consumed from the byte stream.
 296  *
 297  ******************************************************************************/
 298
 299 acpi_status
 300 acpi_rs_extended_irq_resource (
 301         u8                              *byte_stream_buffer,
 302         acpi_size                       *bytes_consumed,
 303         u8                              **output_buffer,
 304         acpi_size                       *structure_size)
 305 {
 306         u8                              *buffer = byte_stream_buffer;
 307         struct acpi_resource            *output_struct = (void *) *output_buffer;
 308         u16                             temp16 = 0;
 309         u8                              temp8 = 0;
 310         u8                              *temp_ptr;
 311         u8                              index;
 312         acpi_size                       struct_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_ext_irq);
 313
 314
 315         ACPI_FUNCTION_TRACE ("rs_extended_irq_resource");
 316
 317
 318         /*
 319          * Point past the Descriptor to get the number of bytes consumed
 320          */
 321         buffer += 1;
 322         ACPI_MOVE_16_TO_16 (&temp16, buffer);
 323
 324         /* Validate minimum descriptor length */
 325
 326         if (temp16 < 6) {
 327                 return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
 328         }
 329
 330         *bytes_consumed = temp16 + 3;
 331         output_struct->id = ACPI_RSTYPE_EXT_IRQ;
 332
 333         /*
 334          * Point to the Byte3
 335          */
 336         buffer += 2;
 337         temp8 = *buffer;
 338
 339         output_struct->data.extended_irq.producer_consumer = temp8 & 0x01;
 340
 341         /*
 342          * Check for Interrupt Mode
 343          *
 344          * The definition of an Extended IRQ changed between ACPI spec v1.0b
 345          * and ACPI spec 2.0 (section 6.4.3.6 in both).
 346          *
 347          * - Edge/Level are defined opposite in the table vs the headers
 348          */
 349         output_struct->data.extended_irq.edge_level =
 350                            (temp8 & 0x2) ? ACPI_EDGE_SENSITIVE : ACPI_LEVEL_SENSITIVE;
 351
 352         /*
 353          * Check Interrupt Polarity
 354          */
 355         output_struct->data.extended_irq.active_high_low = (temp8 >> 2) & 0x1;
 356
 357         /*
 358          * Check for sharable
 359          */
 360         output_struct->data.extended_irq.shared_exclusive = (temp8 >> 3) & 0x01;
 361
 362         /*
 363          * Point to Byte4 (IRQ Table length)
 364          */
 365         buffer += 1;
 366         temp8 = *buffer;
 367
 368         /* Must have at least one IRQ */
 369
 370         if (temp8 < 1) {
 371                 return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
 372         }
 373
 374         output_struct->data.extended_irq.number_of_interrupts = temp8;
 375
 376         /*
 377          * Add any additional structure size to properly calculate
 378          * the next pointer at the end of this function
 379          */
 380         struct_size += (temp8 - 1) * 4;
 381
 382         /*
 383          * Point to Byte5 (First IRQ Number)
 384          */
 385         buffer += 1;
 386
 387         /*
 388          * Cycle through every IRQ in the table
 389          */
 390         for (index = 0; index < temp8; index++) {
 391                 ACPI_MOVE_32_TO_32 (
 392                         &output_struct->data.extended_irq.interrupts[index], buffer);
 393
 394                 /* Point to the next IRQ */
 395
 396                 buffer += 4;
 397         }
 398
 399         /*
 400          * This will leave us pointing to the Resource Source Index
 401          * If it is present, then save it off and calculate the
 402          * pointer to where the null terminated string goes:
 403          * Each Interrupt takes 32-bits + the 5 bytes of the
 404          * stream that are default.
 405          *
 406          * Note: Some resource descriptors will have an additional null, so
 407          * we add 1 to the length.
 408          */
 409         if (*bytes_consumed >
 410                 ((acpi_size) output_struct->data.extended_irq.number_of_interrupts * 4) + (5 + 1)) {
 411                 /* Dereference the Index */
 412
 413                 temp8 = *buffer;
 414                 output_struct->data.extended_irq.resource_source.index = (u32) temp8;
 415
 416                 /* Point to the String */
 417
 418                 buffer += 1;
 419
 420                 /*
 421                  * Point the String pointer to the end of this structure.
 422                  */
 423                 output_struct->data.extended_irq.resource_source.string_ptr =
 424                                 (char *)((char *) output_struct + struct_size);
 425
 426                 temp_ptr = (u8 *) output_struct->data.extended_irq.resource_source.string_ptr;
 427
 428                 /* Copy the string into the buffer */
 429
 430                 index = 0;
 431                 while (0x00 != *buffer) {
 432                         *temp_ptr = *buffer;
 433
 434                         temp_ptr += 1;
 435                         buffer += 1;
 436                         index += 1;
 437                 }
 438
 439                 /*
 440                  * Add the terminating null
 441                  */
 442                 *temp_ptr = 0x00;
 443                 output_struct->data.extended_irq.resource_source.string_length = index + 1;
 444
 445                 /*
 446                  * In order for the struct_size to fall on a 32-bit boundary,
 447                  * calculate the length of the string and expand the
 448                  * struct_size to the next 32-bit boundary.
 449                  */
 450                 temp8 = (u8) (index + 1);
 451                 struct_size += ACPI_ROUND_UP_to_32_bITS (temp8);
 452         }
 453         else {
 454                 output_struct->data.extended_irq.resource_source.index = 0x00;
 455                 output_struct->data.extended_irq.resource_source.string_length = 0;
 456                 output_struct->data.extended_irq.resource_source.string_ptr = NULL;
 457         }
 458
 459         /*
 460          * Set the Length parameter
 461          */
 462         output_struct->length = (u32) struct_size;
 463
 464         /*
 465          * Return the final size of the structure
 466          */
 467         *structure_size = struct_size;
 468         return_ACPI_STATUS (AE_OK);
 469 }
 470
 471
 472 /*******************************************************************************
 473  *
 474  * FUNCTION:    acpi_rs_extended_irq_stream
 475  *
 476  * PARAMETERS:  linked_list             - Pointer to the resource linked list
 477  *              output_buffer           - Pointer to the user's return buffer
 478  *              bytes_consumed          - Pointer to where the number of bytes
 479  *                                        used in the output_buffer is returned
 480  *
 481  * RETURN:      Status
 482  *
 483  * DESCRIPTION: Take the linked list resource structure and fills in the
 484  *              the appropriate bytes in a byte stream
 485  *
 486  ******************************************************************************/
 487
 488 acpi_status
 489 acpi_rs_extended_irq_stream (
 490         struct acpi_resource            *linked_list,
 491         u8                              **output_buffer,
 492         acpi_size                       *bytes_consumed)
 493 {
 494         u8                              *buffer = *output_buffer;
 495         u16                             *length_field;
 496         u8                              temp8 = 0;
 497         u8                              index;
 498         char                            *temp_pointer = NULL;
 499
 500
 501         ACPI_FUNCTION_TRACE ("rs_extended_irq_stream");
 502
 503
 504         /*
 505          * The descriptor field is static
 506          */
 507         *buffer = 0x89;
 508         buffer += 1;
 509
 510         /*
 511          * Set a pointer to the Length field - to be filled in later
 512          */
 513         length_field = ACPI_CAST_PTR (u16, buffer);
 514         buffer += 2;
 515
 516         /*
 517          * Set the Interrupt vector flags
 518          */
 519         temp8 = (u8)(linked_list->data.extended_irq.producer_consumer & 0x01);
 520         temp8 |= ((linked_list->data.extended_irq.shared_exclusive & 0x01) << 3);
 521
 522         /*
 523          * Set the Interrupt Mode
 524          *
 525          * The definition of an Extended IRQ changed between ACPI spec v1.0b
 526          * and ACPI spec 2.0 (section 6.4.3.6 in both).  This code does not
 527          * implement the more restrictive definition of 1.0b
 528          *
 529          * - Edge/Level are defined opposite in the table vs the headers
 530          */
 531         if (ACPI_EDGE_SENSITIVE == linked_list->data.extended_irq.edge_level) {
 532                 temp8 |= 0x2;
 533         }
 534
 535         /*
 536          * Set the Interrupt Polarity
 537          */
 538         temp8 |= ((linked_list->data.extended_irq.active_high_low & 0x1) << 2);
 539
 540         *buffer = temp8;
 541         buffer += 1;
 542
 543         /*
 544          * Set the Interrupt table length
 545          */
 546         temp8 = (u8) linked_list->data.extended_irq.number_of_interrupts;
 547
 548         *buffer = temp8;
 549         buffer += 1;
 550
 551         for (index = 0; index < linked_list->data.extended_irq.number_of_interrupts;
 552                  index++) {
 553                 ACPI_MOVE_32_TO_32 (buffer,
 554                                   &linked_list->data.extended_irq.interrupts[index]);
 555                 buffer += 4;
 556         }
 557
 558         /*
 559          * Resource Source Index and Resource Source are optional
 560          */
 561         if (0 != linked_list->data.extended_irq.resource_source.string_length) {
 562                 *buffer = (u8) linked_list->data.extended_irq.resource_source.index;
 563                 buffer += 1;
 564
 565                 temp_pointer = (char *) buffer;
 566
 567                 /*
 568                  * Copy the string
 569                  */
 570                 ACPI_STRCPY (temp_pointer,
 571                         linked_list->data.extended_irq.resource_source.string_ptr);
 572
 573                 /*
 574                  * Buffer needs to be set to the length of the sting + one for the
 575                  * terminating null
 576                  */
 577                 buffer += (acpi_size)(ACPI_STRLEN (linked_list->data.extended_irq.resource_source.string_ptr) + 1);
 578         }
 579
 580         /*
 581          * Return the number of bytes consumed in this operation
 582          */
 583         *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer);
 584
 585         /*
 586          * Set the length field to the number of bytes consumed
 587          * minus the header size (3 bytes)
 588          */
 589         *length_field = (u16) (*bytes_consumed - 3);
 590         return_ACPI_STATUS (AE_OK);
 591 }
 592