drivers/acpi/resources/rsio.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsio - IO and DMA 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("rsio")
  49
  50 /*******************************************************************************
  51  *
  52  * FUNCTION:    acpi_rs_io_resource
  53  *
  54  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
  55  *                                        stream
  56  *              bytes_consumed          - Pointer to where the number of bytes
  57  *                                        consumed the byte_stream_buffer is
  58  *                                        returned
  59  *              output_buffer           - Pointer to the return data buffer
  60  *              structure_size          - Pointer to where the number of bytes
  61  *                                        in the return data struct is returned
  62  *
  63  * RETURN:      Status
  64  *
  65  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
  66  *              structure pointed to by the output_buffer. Return the
  67  *              number of bytes consumed from the byte stream.
  68  *
  69  ******************************************************************************/
  70 acpi_status
  71 acpi_rs_io_resource(u8 * byte_stream_buffer,
  72                     acpi_size * bytes_consumed,
  73                     u8 ** output_buffer, acpi_size * structure_size)
  74 {
  75         u8 *buffer = byte_stream_buffer;
  76         struct acpi_resource *output_struct = (void *)*output_buffer;
  77         u16 temp16 = 0;
  78         u8 temp8 = 0;
  79         acpi_size struct_size = ACPI_SIZEOF_RESOURCE(struct acpi_resource_io);
  80
  81         ACPI_FUNCTION_TRACE("rs_io_resource");
  82
  83         /* The number of bytes consumed are Constant */
  84
  85         *bytes_consumed = 8;
  86
  87         output_struct->id = ACPI_RSTYPE_IO;
  88
  89         /* Check Decode */
  90
  91         buffer += 1;
  92         temp8 = *buffer;
  93
  94         output_struct->data.io.io_decode = temp8 & 0x01;
  95
  96         /* Check min_base Address */
  97
  98         buffer += 1;
  99         ACPI_MOVE_16_TO_16(&temp16, buffer);
 100
 101         output_struct->data.io.min_base_address = temp16;
 102
 103         /* Check max_base Address */
 104
 105         buffer += 2;
 106         ACPI_MOVE_16_TO_16(&temp16, buffer);
 107
 108         output_struct->data.io.max_base_address = temp16;
 109
 110         /* Check Base alignment */
 111
 112         buffer += 2;
 113         temp8 = *buffer;
 114
 115         output_struct->data.io.alignment = temp8;
 116
 117         /* Check range_length */
 118
 119         buffer += 1;
 120         temp8 = *buffer;
 121
 122         output_struct->data.io.range_length = temp8;
 123
 124         /* Set the Length parameter */
 125
 126         output_struct->length = (u32) struct_size;
 127
 128         /* Return the final size of the structure */
 129
 130         *structure_size = struct_size;
 131         return_ACPI_STATUS(AE_OK);
 132 }
 133
 134 /*******************************************************************************
 135  *
 136  * FUNCTION:    acpi_rs_fixed_io_resource
 137  *
 138  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
 139  *                                        stream
 140  *              bytes_consumed          - Pointer to where the number of bytes
 141  *                                        consumed the byte_stream_buffer is
 142  *                                        returned
 143  *              output_buffer           - Pointer to the return data buffer
 144  *              structure_size          - Pointer to where the number of bytes
 145  *                                        in the return data struct is returned
 146  *
 147  * RETURN:      Status
 148  *
 149  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
 150  *              structure pointed to by the output_buffer. Return the
 151  *              number of bytes consumed from the byte stream.
 152  *
 153  ******************************************************************************/
 154
 155 acpi_status
 156 acpi_rs_fixed_io_resource(u8 * byte_stream_buffer,
 157                           acpi_size * bytes_consumed,
 158                           u8 ** output_buffer, acpi_size * structure_size)
 159 {
 160         u8 *buffer = byte_stream_buffer;
 161         struct acpi_resource *output_struct = (void *)*output_buffer;
 162         u16 temp16 = 0;
 163         u8 temp8 = 0;
 164         acpi_size struct_size =
 165             ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io);
 166
 167         ACPI_FUNCTION_TRACE("rs_fixed_io_resource");
 168
 169         /* The number of bytes consumed are Constant */
 170
 171         *bytes_consumed = 4;
 172
 173         output_struct->id = ACPI_RSTYPE_FIXED_IO;
 174
 175         /* Check Range Base Address */
 176
 177         buffer += 1;
 178         ACPI_MOVE_16_TO_16(&temp16, buffer);
 179
 180         output_struct->data.fixed_io.base_address = temp16;
 181
 182         /* Check range_length */
 183
 184         buffer += 2;
 185         temp8 = *buffer;
 186
 187         output_struct->data.fixed_io.range_length = temp8;
 188
 189         /* Set the Length parameter */
 190
 191         output_struct->length = (u32) struct_size;
 192
 193         /* Return the final size of the structure */
 194
 195         *structure_size = struct_size;
 196         return_ACPI_STATUS(AE_OK);
 197 }
 198
 199 /*******************************************************************************
 200  *
 201  * FUNCTION:    acpi_rs_io_stream
 202  *
 203  * PARAMETERS:  linked_list             - Pointer to the resource linked list
 204  *              output_buffer           - Pointer to the user's return buffer
 205  *              bytes_consumed          - Pointer to where the number of bytes
 206  *                                        used in the output_buffer is returned
 207  *
 208  * RETURN:      Status
 209  *
 210  * DESCRIPTION: Take the linked list resource structure and fills in the
 211  *              the appropriate bytes in a byte stream
 212  *
 213  ******************************************************************************/
 214
 215 acpi_status
 216 acpi_rs_io_stream(struct acpi_resource *linked_list,
 217                   u8 ** output_buffer, acpi_size * bytes_consumed)
 218 {
 219         u8 *buffer = *output_buffer;
 220         u16 temp16 = 0;
 221         u8 temp8 = 0;
 222
 223         ACPI_FUNCTION_TRACE("rs_io_stream");
 224
 225         /* The descriptor field is static */
 226
 227         *buffer = 0x47;
 228         buffer += 1;
 229
 230         /* Io Information Byte */
 231
 232         temp8 = (u8) (linked_list->data.io.io_decode & 0x01);
 233
 234         *buffer = temp8;
 235         buffer += 1;
 236
 237         /* Set the Range minimum base address */
 238
 239         temp16 = (u16) linked_list->data.io.min_base_address;
 240
 241         ACPI_MOVE_16_TO_16(buffer, &temp16);
 242         buffer += 2;
 243
 244         /* Set the Range maximum base address */
 245
 246         temp16 = (u16) linked_list->data.io.max_base_address;
 247
 248         ACPI_MOVE_16_TO_16(buffer, &temp16);
 249         buffer += 2;
 250
 251         /* Set the base alignment */
 252
 253         temp8 = (u8) linked_list->data.io.alignment;
 254
 255         *buffer = temp8;
 256         buffer += 1;
 257
 258         /* Set the range length */
 259
 260         temp8 = (u8) linked_list->data.io.range_length;
 261
 262         *buffer = temp8;
 263         buffer += 1;
 264
 265         /* Return the number of bytes consumed in this operation */
 266
 267         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
 268         return_ACPI_STATUS(AE_OK);
 269 }
 270
 271 /*******************************************************************************
 272  *
 273  * FUNCTION:    acpi_rs_fixed_io_stream
 274  *
 275  * PARAMETERS:  linked_list             - Pointer to the resource linked list
 276  *              output_buffer           - Pointer to the user's return buffer
 277  *              bytes_consumed          - Pointer to where the number of bytes
 278  *                                        used in the output_buffer is returned
 279  *
 280  * RETURN:      Status
 281  *
 282  * DESCRIPTION: Take the linked list resource structure and fills in the
 283  *              the appropriate bytes in a byte stream
 284  *
 285  ******************************************************************************/
 286
 287 acpi_status
 288 acpi_rs_fixed_io_stream(struct acpi_resource *linked_list,
 289                         u8 ** output_buffer, acpi_size * bytes_consumed)
 290 {
 291         u8 *buffer = *output_buffer;
 292         u16 temp16 = 0;
 293         u8 temp8 = 0;
 294
 295         ACPI_FUNCTION_TRACE("rs_fixed_io_stream");
 296
 297         /* The descriptor field is static */
 298
 299         *buffer = 0x4B;
 300
 301         buffer += 1;
 302
 303         /* Set the Range base address */
 304
 305         temp16 = (u16) linked_list->data.fixed_io.base_address;
 306
 307         ACPI_MOVE_16_TO_16(buffer, &temp16);
 308         buffer += 2;
 309
 310         /* Set the range length */
 311
 312         temp8 = (u8) linked_list->data.fixed_io.range_length;
 313
 314         *buffer = temp8;
 315         buffer += 1;
 316
 317         /* Return the number of bytes consumed in this operation */
 318
 319         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
 320         return_ACPI_STATUS(AE_OK);
 321 }
 322
 323 /*******************************************************************************
 324  *
 325  * FUNCTION:    acpi_rs_dma_resource
 326  *
 327  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
 328  *                                        stream
 329  *              bytes_consumed          - Pointer to where the number of bytes
 330  *                                        consumed the byte_stream_buffer is
 331  *                                        returned
 332  *              output_buffer           - Pointer to the return data buffer
 333  *              structure_size          - Pointer to where the number of bytes
 334  *                                        in the return data struct is returned
 335  *
 336  * RETURN:      Status
 337  *
 338  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
 339  *              structure pointed to by the output_buffer. Return the
 340  *              number of bytes consumed from the byte stream.
 341  *
 342  ******************************************************************************/
 343
 344 acpi_status
 345 acpi_rs_dma_resource(u8 * byte_stream_buffer,
 346                      acpi_size * bytes_consumed,
 347                      u8 ** output_buffer, acpi_size * structure_size)
 348 {
 349         u8 *buffer = byte_stream_buffer;
 350         struct acpi_resource *output_struct = (void *)*output_buffer;
 351         u8 temp8 = 0;
 352         u8 index;
 353         u8 i;
 354         acpi_size struct_size = ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma);
 355
 356         ACPI_FUNCTION_TRACE("rs_dma_resource");
 357
 358         /* The number of bytes consumed are Constant */
 359
 360         *bytes_consumed = 3;
 361         output_struct->id = ACPI_RSTYPE_DMA;
 362
 363         /* Point to the 8-bits of Byte 1 */
 364
 365         buffer += 1;
 366         temp8 = *buffer;
 367
 368         /* Decode the DMA channel bits */
 369
 370         for (i = 0, index = 0; index < 8; index++) {
 371                 if ((temp8 >> index) & 0x01) {
 372                         output_struct->data.dma.channels[i] = index;
 373                         i++;
 374                 }
 375         }
 376
 377         /* Zero DMA channels is valid */
 378
 379         output_struct->data.dma.number_of_channels = i;
 380         if (i > 0) {
 381                 /* Calculate the structure size based upon the number of interrupts */
 382
 383                 struct_size += ((acpi_size) i - 1) * 4;
 384         }
 385
 386         /* Point to Byte 2 */
 387
 388         buffer += 1;
 389         temp8 = *buffer;
 390
 391         /* Check for transfer preference (Bits[1:0]) */
 392
 393         output_struct->data.dma.transfer = temp8 & 0x03;
 394
 395         if (0x03 == output_struct->data.dma.transfer) {
 396                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 397                                   "Invalid DMA.Transfer preference (3)\n"));
 398                 return_ACPI_STATUS(AE_BAD_DATA);
 399         }
 400
 401         /* Get bus master preference (Bit[2]) */
 402
 403         output_struct->data.dma.bus_master = (temp8 >> 2) & 0x01;
 404
 405         /* Get channel speed support (Bits[6:5]) */
 406
 407         output_struct->data.dma.type = (temp8 >> 5) & 0x03;
 408
 409         /* Set the Length parameter */
 410
 411         output_struct->length = (u32) struct_size;
 412
 413         /* Return the final size of the structure */
 414
 415         *structure_size = struct_size;
 416         return_ACPI_STATUS(AE_OK);
 417 }
 418
 419 /*******************************************************************************
 420  *
 421  * FUNCTION:    acpi_rs_dma_stream
 422  *
 423  * PARAMETERS:  linked_list             - Pointer to the resource linked list
 424  *              output_buffer           - Pointer to the user's return buffer
 425  *              bytes_consumed          - Pointer to where the number of bytes
 426  *                                        used in the output_buffer is returned
 427  *
 428  * RETURN:      Status
 429  *
 430  * DESCRIPTION: Take the linked list resource structure and fills in the
 431  *              the appropriate bytes in a byte stream
 432  *
 433  ******************************************************************************/
 434
 435 acpi_status
 436 acpi_rs_dma_stream(struct acpi_resource *linked_list,
 437                    u8 ** output_buffer, acpi_size * bytes_consumed)
 438 {
 439         u8 *buffer = *output_buffer;
 440         u16 temp16 = 0;
 441         u8 temp8 = 0;
 442         u8 index;
 443
 444         ACPI_FUNCTION_TRACE("rs_dma_stream");
 445
 446         /* The descriptor field is static */
 447
 448         *buffer = 0x2A;
 449         buffer += 1;
 450         temp8 = 0;
 451
 452         /* Loop through all of the Channels and set the mask bits */
 453
 454         for (index = 0;
 455              index < linked_list->data.dma.number_of_channels; index++) {
 456                 temp16 = (u16) linked_list->data.dma.channels[index];
 457                 temp8 |= 0x1 << temp16;
 458         }
 459
 460         *buffer = temp8;
 461         buffer += 1;
 462
 463         /* Set the DMA Info */
 464
 465         temp8 = (u8) ((linked_list->data.dma.type & 0x03) << 5);
 466         temp8 |= ((linked_list->data.dma.bus_master & 0x01) << 2);
 467         temp8 |= (linked_list->data.dma.transfer & 0x03);
 468
 469         *buffer = temp8;
 470         buffer += 1;
 471
 472         /* Return the number of bytes consumed in this operation */
 473
 474         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
 475         return_ACPI_STATUS(AE_OK);
 476 }