drivers/acpi/resources/rsmemory.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsmem24 - Memory 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("rsmemory")
  49
  50 /*******************************************************************************
  51  *
  52  * FUNCTION:    acpi_rs_memory24_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_memory24_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 =
  80             ACPI_SIZEOF_RESOURCE(struct acpi_resource_mem24);
  81
  82         ACPI_FUNCTION_TRACE("rs_memory24_resource");
  83
  84         /* Point past the Descriptor to get the number of bytes consumed */
  85
  86         buffer += 1;
  87         ACPI_MOVE_16_TO_16(&temp16, buffer);
  88
  89         buffer += 2;
  90         *bytes_consumed = (acpi_size) temp16 + 3;
  91         output_struct->type = ACPI_RSTYPE_MEM24;
  92
  93         /* Check Byte 3 the Read/Write bit */
  94
  95         temp8 = *buffer;
  96         buffer += 1;
  97         output_struct->data.memory24.read_write_attribute = temp8 & 0x01;
  98
  99         /* Get min_base_address (Bytes 4-5) */
 100
 101         ACPI_MOVE_16_TO_16(&temp16, buffer);
 102         buffer += 2;
 103         output_struct->data.memory24.min_base_address = temp16;
 104
 105         /* Get max_base_address (Bytes 6-7) */
 106
 107         ACPI_MOVE_16_TO_16(&temp16, buffer);
 108         buffer += 2;
 109         output_struct->data.memory24.max_base_address = temp16;
 110
 111         /* Get Alignment (Bytes 8-9) */
 112
 113         ACPI_MOVE_16_TO_16(&temp16, buffer);
 114         buffer += 2;
 115         output_struct->data.memory24.alignment = temp16;
 116
 117         /* Get range_length (Bytes 10-11) */
 118
 119         ACPI_MOVE_16_TO_16(&temp16, buffer);
 120         output_struct->data.memory24.range_length = temp16;
 121
 122         /* Set the Length parameter */
 123
 124         output_struct->length = (u32) struct_size;
 125
 126         /* Return the final size of the structure */
 127
 128         *structure_size = struct_size;
 129         return_ACPI_STATUS(AE_OK);
 130 }
 131
 132 /*******************************************************************************
 133  *
 134  * FUNCTION:    acpi_rs_memory24_stream
 135  *
 136  * PARAMETERS:  Resource                - Pointer to the resource linked list
 137  *              output_buffer           - Pointer to the user's return buffer
 138  *              bytes_consumed          - Pointer to where the number of bytes
 139  *                                        used in the output_buffer is returned
 140  *
 141  * RETURN:      Status
 142  *
 143  * DESCRIPTION: Take the linked list resource structure and fills in the
 144  *              the appropriate bytes in a byte stream
 145  *
 146  ******************************************************************************/
 147
 148 acpi_status
 149 acpi_rs_memory24_stream(struct acpi_resource *resource,
 150                         u8 ** output_buffer, acpi_size * bytes_consumed)
 151 {
 152         u8 *buffer = *output_buffer;
 153         u16 temp16 = 0;
 154         u8 temp8 = 0;
 155
 156         ACPI_FUNCTION_TRACE("rs_memory24_stream");
 157
 158         /* The Descriptor Type field is static */
 159
 160         *buffer = ACPI_RDESC_TYPE_MEMORY_24;
 161         buffer += 1;
 162
 163         /* The length field is static */
 164
 165         temp16 = 0x09;
 166         ACPI_MOVE_16_TO_16(buffer, &temp16);
 167         buffer += 2;
 168
 169         /* Set the Information Byte */
 170
 171         temp8 = (u8) (resource->data.memory24.read_write_attribute & 0x01);
 172         *buffer = temp8;
 173         buffer += 1;
 174
 175         /* Set the Range minimum base address */
 176
 177         ACPI_MOVE_32_TO_16(buffer, &resource->data.memory24.min_base_address);
 178         buffer += 2;
 179
 180         /* Set the Range maximum base address */
 181
 182         ACPI_MOVE_32_TO_16(buffer, &resource->data.memory24.max_base_address);
 183         buffer += 2;
 184
 185         /* Set the base alignment */
 186
 187         ACPI_MOVE_32_TO_16(buffer, &resource->data.memory24.alignment);
 188         buffer += 2;
 189
 190         /* Set the range length */
 191
 192         ACPI_MOVE_32_TO_16(buffer, &resource->data.memory24.range_length);
 193         buffer += 2;
 194
 195         /* Return the number of bytes consumed in this operation */
 196
 197         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
 198         return_ACPI_STATUS(AE_OK);
 199 }
 200
 201 /*******************************************************************************
 202  *
 203  * FUNCTION:    acpi_rs_memory32_range_resource
 204  *
 205  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
 206  *                                        stream
 207  *              bytes_consumed          - Pointer to where the number of bytes
 208  *                                        consumed the byte_stream_buffer is
 209  *                                        returned
 210  *              output_buffer           - Pointer to the return data buffer
 211  *              structure_size          - Pointer to where the number of bytes
 212  *                                        in the return data struct is returned
 213  *
 214  * RETURN:      Status
 215  *
 216  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
 217  *              structure pointed to by the output_buffer. Return the
 218  *              number of bytes consumed from the byte stream.
 219  *
 220  ******************************************************************************/
 221
 222 acpi_status
 223 acpi_rs_memory32_range_resource(u8 * byte_stream_buffer,
 224                                 acpi_size * bytes_consumed,
 225                                 u8 ** output_buffer, acpi_size * structure_size)
 226 {
 227         u8 *buffer = byte_stream_buffer;
 228         struct acpi_resource *output_struct = (void *)*output_buffer;
 229         u16 temp16 = 0;
 230         u8 temp8 = 0;
 231         acpi_size struct_size =
 232             ACPI_SIZEOF_RESOURCE(struct acpi_resource_mem32);
 233
 234         ACPI_FUNCTION_TRACE("rs_memory32_range_resource");
 235
 236         /* Point past the Descriptor to get the number of bytes consumed */
 237
 238         buffer += 1;
 239         ACPI_MOVE_16_TO_16(&temp16, buffer);
 240
 241         buffer += 2;
 242         *bytes_consumed = (acpi_size) temp16 + 3;
 243         output_struct->type = ACPI_RSTYPE_MEM32;
 244
 245         /*
 246          *  Point to the place in the output buffer where the data portion will
 247          *  begin.
 248          *  1. Set the RESOURCE_DATA * Data to point to its own address, then
 249          *  2. Set the pointer to the next address.
 250          *
 251          *  NOTE: output_struct->Data is cast to u8, otherwise, this addition adds
 252          *  4 * sizeof(RESOURCE_DATA) instead of 4 * sizeof(u8)
 253          */
 254
 255         /* Check Byte 3 the Read/Write bit */
 256
 257         temp8 = *buffer;
 258         buffer += 1;
 259
 260         output_struct->data.memory32.read_write_attribute = temp8 & 0x01;
 261
 262         /* Get min_base_address (Bytes 4-7) */
 263
 264         ACPI_MOVE_32_TO_32(&output_struct->data.memory32.min_base_address,
 265                            buffer);
 266         buffer += 4;
 267
 268         /* Get max_base_address (Bytes 8-11) */
 269
 270         ACPI_MOVE_32_TO_32(&output_struct->data.memory32.max_base_address,
 271                            buffer);
 272         buffer += 4;
 273
 274         /* Get Alignment (Bytes 12-15) */
 275
 276         ACPI_MOVE_32_TO_32(&output_struct->data.memory32.alignment, buffer);
 277         buffer += 4;
 278
 279         /* Get range_length (Bytes 16-19) */
 280
 281         ACPI_MOVE_32_TO_32(&output_struct->data.memory32.range_length, buffer);
 282
 283         /* Set the Length parameter */
 284
 285         output_struct->length = (u32) struct_size;
 286
 287         /* Return the final size of the structure */
 288
 289         *structure_size = struct_size;
 290         return_ACPI_STATUS(AE_OK);
 291 }
 292
 293 /*******************************************************************************
 294  *
 295  * FUNCTION:    acpi_rs_fixed_memory32_resource
 296  *
 297  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
 298  *                                        stream
 299  *              bytes_consumed          - Pointer to where the number of bytes
 300  *                                        consumed the byte_stream_buffer is
 301  *                                        returned
 302  *              output_buffer           - Pointer to the return data buffer
 303  *              structure_size          - Pointer to where the number of bytes
 304  *                                        in the return data struct is returned
 305  *
 306  * RETURN:      Status
 307  *
 308  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
 309  *              structure pointed to by the output_buffer. Return the
 310  *              number of bytes consumed from the byte stream.
 311  *
 312  ******************************************************************************/
 313
 314 acpi_status
 315 acpi_rs_fixed_memory32_resource(u8 * byte_stream_buffer,
 316                                 acpi_size * bytes_consumed,
 317                                 u8 ** output_buffer, acpi_size * structure_size)
 318 {
 319         u8 *buffer = byte_stream_buffer;
 320         struct acpi_resource *output_struct = (void *)*output_buffer;
 321         u16 temp16 = 0;
 322         u8 temp8 = 0;
 323         acpi_size struct_size =
 324             ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_mem32);
 325
 326         ACPI_FUNCTION_TRACE("rs_fixed_memory32_resource");
 327
 328         /* Point past the Descriptor to get the number of bytes consumed */
 329
 330         buffer += 1;
 331         ACPI_MOVE_16_TO_16(&temp16, buffer);
 332
 333         buffer += 2;
 334         *bytes_consumed = (acpi_size) temp16 + 3;
 335         output_struct->type = ACPI_RSTYPE_FIXED_MEM32;
 336
 337         /* Check Byte 3 the Read/Write bit */
 338
 339         temp8 = *buffer;
 340         buffer += 1;
 341         output_struct->data.fixed_memory32.read_write_attribute = temp8 & 0x01;
 342
 343         /* Get range_base_address (Bytes 4-7) */
 344
 345         ACPI_MOVE_32_TO_32(&output_struct->data.fixed_memory32.
 346                            range_base_address, buffer);
 347         buffer += 4;
 348
 349         /* Get range_length (Bytes 8-11) */
 350
 351         ACPI_MOVE_32_TO_32(&output_struct->data.fixed_memory32.range_length,
 352                            buffer);
 353
 354         /* Set the Length parameter */
 355
 356         output_struct->length = (u32) struct_size;
 357
 358         /* Return the final size of the structure */
 359
 360         *structure_size = struct_size;
 361         return_ACPI_STATUS(AE_OK);
 362 }
 363
 364 /*******************************************************************************
 365  *
 366  * FUNCTION:    acpi_rs_memory32_range_stream
 367  *
 368  * PARAMETERS:  Resource                - Pointer to the resource linked list
 369  *              output_buffer           - Pointer to the user's return buffer
 370  *              bytes_consumed          - Pointer to where the number of bytes
 371  *                                        used in the output_buffer is returned
 372  *
 373  * RETURN:      Status
 374  *
 375  * DESCRIPTION: Take the linked list resource structure and fills in the
 376  *              the appropriate bytes in a byte stream
 377  *
 378  ******************************************************************************/
 379
 380 acpi_status
 381 acpi_rs_memory32_range_stream(struct acpi_resource *resource,
 382                               u8 ** output_buffer, acpi_size * bytes_consumed)
 383 {
 384         u8 *buffer = *output_buffer;
 385         u16 temp16 = 0;
 386         u8 temp8 = 0;
 387
 388         ACPI_FUNCTION_TRACE("rs_memory32_range_stream");
 389
 390         /* The Descriptor Type field is static */
 391
 392         *buffer = ACPI_RDESC_TYPE_MEMORY_32;
 393         buffer += 1;
 394
 395         /* The length field is static */
 396
 397         temp16 = 0x11;
 398
 399         ACPI_MOVE_16_TO_16(buffer, &temp16);
 400         buffer += 2;
 401
 402         /* Set the Information Byte */
 403
 404         temp8 = (u8) (resource->data.memory32.read_write_attribute & 0x01);
 405         *buffer = temp8;
 406         buffer += 1;
 407
 408         /* Set the Range minimum base address */
 409
 410         ACPI_MOVE_32_TO_32(buffer, &resource->data.memory32.min_base_address);
 411         buffer += 4;
 412
 413         /* Set the Range maximum base address */
 414
 415         ACPI_MOVE_32_TO_32(buffer, &resource->data.memory32.max_base_address);
 416         buffer += 4;
 417
 418         /* Set the base alignment */
 419
 420         ACPI_MOVE_32_TO_32(buffer, &resource->data.memory32.alignment);
 421         buffer += 4;
 422
 423         /* Set the range length */
 424
 425         ACPI_MOVE_32_TO_32(buffer, &resource->data.memory32.range_length);
 426         buffer += 4;
 427
 428         /* Return the number of bytes consumed in this operation */
 429
 430         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
 431         return_ACPI_STATUS(AE_OK);
 432 }
 433
 434 /*******************************************************************************
 435  *
 436  * FUNCTION:    acpi_rs_fixed_memory32_stream
 437  *
 438  * PARAMETERS:  Resource                - Pointer to the resource linked list
 439  *              output_buffer           - Pointer to the user's return buffer
 440  *              bytes_consumed          - Pointer to where the number of bytes
 441  *                                        used in the output_buffer is returned
 442  *
 443  * RETURN:      Status
 444  *
 445  * DESCRIPTION: Take the linked list resource structure and fills in the
 446  *              the appropriate bytes in a byte stream
 447  *
 448  ******************************************************************************/
 449
 450 acpi_status
 451 acpi_rs_fixed_memory32_stream(struct acpi_resource *resource,
 452                               u8 ** output_buffer, acpi_size * bytes_consumed)
 453 {
 454         u8 *buffer = *output_buffer;
 455         u16 temp16 = 0;
 456         u8 temp8 = 0;
 457
 458         ACPI_FUNCTION_TRACE("rs_fixed_memory32_stream");
 459
 460         /* The Descriptor Type field is static */
 461
 462         *buffer = ACPI_RDESC_TYPE_FIXED_MEMORY_32;
 463         buffer += 1;
 464
 465         /* The length field is static */
 466
 467         temp16 = 0x09;
 468
 469         ACPI_MOVE_16_TO_16(buffer, &temp16);
 470         buffer += 2;
 471
 472         /* Set the Information Byte */
 473
 474         temp8 =
 475             (u8) (resource->data.fixed_memory32.read_write_attribute & 0x01);
 476         *buffer = temp8;
 477         buffer += 1;
 478
 479         /* Set the Range base address */
 480
 481         ACPI_MOVE_32_TO_32(buffer,
 482                            &resource->data.fixed_memory32.range_base_address);
 483         buffer += 4;
 484
 485         /* Set the range length */
 486
 487         ACPI_MOVE_32_TO_32(buffer, &resource->data.fixed_memory32.range_length);
 488         buffer += 4;
 489
 490         /* Return the number of bytes consumed in this operation */
 491
 492         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
 493         return_ACPI_STATUS(AE_OK);
 494 }