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