drivers/acpi/acpica/rsaddr.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsaddr - Address resource descriptors (16/32/64)
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2012, Intel Corp.
   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 "accommon.h"
  46 #include "acresrc.h"
  47
  48 #define _COMPONENT          ACPI_RESOURCES
  49 ACPI_MODULE_NAME("rsaddr")
  50
  51 /*******************************************************************************
  52  *
  53  * acpi_rs_convert_address16 - All WORD (16-bit) address resources
  54  *
  55  ******************************************************************************/
  56 struct acpi_rsconvert_info acpi_rs_convert_address16[5] = {
  57         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS16,
  58          ACPI_RS_SIZE(struct acpi_resource_address16),
  59          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address16)},
  60
  61         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS16,
  62          sizeof(struct aml_resource_address16),
  63          0},
  64
  65         /* Resource Type, General Flags, and Type-Specific Flags */
  66
  67         {ACPI_RSC_ADDRESS, 0, 0, 0},
  68
  69         /*
  70          * These fields are contiguous in both the source and destination:
  71          * Address Granularity
  72          * Address Range Minimum
  73          * Address Range Maximum
  74          * Address Translation Offset
  75          * Address Length
  76          */
  77         {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.address16.granularity),
  78          AML_OFFSET(address16.granularity),
  79          5},
  80
  81         /* Optional resource_source (Index and String) */
  82
  83         {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address16.resource_source),
  84          0,
  85          sizeof(struct aml_resource_address16)}
  86 };
  87
  88 /*******************************************************************************
  89  *
  90  * acpi_rs_convert_address32 - All DWORD (32-bit) address resources
  91  *
  92  ******************************************************************************/
  93
  94 struct acpi_rsconvert_info acpi_rs_convert_address32[5] = {
  95         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS32,
  96          ACPI_RS_SIZE(struct acpi_resource_address32),
  97          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address32)},
  98
  99         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS32,
 100          sizeof(struct aml_resource_address32),
 101          0},
 102
 103         /* Resource Type, General Flags, and Type-Specific Flags */
 104
 105         {ACPI_RSC_ADDRESS, 0, 0, 0},
 106
 107         /*
 108          * These fields are contiguous in both the source and destination:
 109          * Address Granularity
 110          * Address Range Minimum
 111          * Address Range Maximum
 112          * Address Translation Offset
 113          * Address Length
 114          */
 115         {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.address32.granularity),
 116          AML_OFFSET(address32.granularity),
 117          5},
 118
 119         /* Optional resource_source (Index and String) */
 120
 121         {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address32.resource_source),
 122          0,
 123          sizeof(struct aml_resource_address32)}
 124 };
 125
 126 /*******************************************************************************
 127  *
 128  * acpi_rs_convert_address64 - All QWORD (64-bit) address resources
 129  *
 130  ******************************************************************************/
 131
 132 struct acpi_rsconvert_info acpi_rs_convert_address64[5] = {
 133         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS64,
 134          ACPI_RS_SIZE(struct acpi_resource_address64),
 135          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address64)},
 136
 137         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS64,
 138          sizeof(struct aml_resource_address64),
 139          0},
 140
 141         /* Resource Type, General Flags, and Type-Specific Flags */
 142
 143         {ACPI_RSC_ADDRESS, 0, 0, 0},
 144
 145         /*
 146          * These fields are contiguous in both the source and destination:
 147          * Address Granularity
 148          * Address Range Minimum
 149          * Address Range Maximum
 150          * Address Translation Offset
 151          * Address Length
 152          */
 153         {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.address64.granularity),
 154          AML_OFFSET(address64.granularity),
 155          5},
 156
 157         /* Optional resource_source (Index and String) */
 158
 159         {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address64.resource_source),
 160          0,
 161          sizeof(struct aml_resource_address64)}
 162 };
 163
 164 /*******************************************************************************
 165  *
 166  * acpi_rs_convert_ext_address64 - All Extended (64-bit) address resources
 167  *
 168  ******************************************************************************/
 169
 170 struct acpi_rsconvert_info acpi_rs_convert_ext_address64[5] = {
 171         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
 172          ACPI_RS_SIZE(struct acpi_resource_extended_address64),
 173          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_address64)},
 174
 175         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
 176          sizeof(struct aml_resource_extended_address64),
 177          0},
 178
 179         /* Resource Type, General Flags, and Type-Specific Flags */
 180
 181         {ACPI_RSC_ADDRESS, 0, 0, 0},
 182
 183         /* Revision ID */
 184
 185         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.ext_address64.revision_iD),
 186          AML_OFFSET(ext_address64.revision_iD),
 187          1},
 188         /*
 189          * These fields are contiguous in both the source and destination:
 190          * Address Granularity
 191          * Address Range Minimum
 192          * Address Range Maximum
 193          * Address Translation Offset
 194          * Address Length
 195          * Type-Specific Attribute
 196          */
 197         {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.ext_address64.granularity),
 198          AML_OFFSET(ext_address64.granularity),
 199          6}
 200 };
 201
 202 /*******************************************************************************
 203  *
 204  * acpi_rs_convert_general_flags - Flags common to all address descriptors
 205  *
 206  ******************************************************************************/
 207
 208 static struct acpi_rsconvert_info acpi_rs_convert_general_flags[6] = {
 209         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.flags),
 210          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_general_flags)},
 211
 212         /* Resource Type (Memory, Io, bus_number, etc.) */
 213
 214         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.address.resource_type),
 215          AML_OFFSET(address.resource_type),
 216          1},
 217
 218         /* General Flags - Consume, Decode, min_fixed, max_fixed */
 219
 220         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.producer_consumer),
 221          AML_OFFSET(address.flags),
 222          0},
 223
 224         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.decode),
 225          AML_OFFSET(address.flags),
 226          1},
 227
 228         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.min_address_fixed),
 229          AML_OFFSET(address.flags),
 230          2},
 231
 232         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.max_address_fixed),
 233          AML_OFFSET(address.flags),
 234          3}
 235 };
 236
 237 /*******************************************************************************
 238  *
 239  * acpi_rs_convert_mem_flags - Flags common to Memory address descriptors
 240  *
 241  ******************************************************************************/
 242
 243 static struct acpi_rsconvert_info acpi_rs_convert_mem_flags[5] = {
 244         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
 245          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_mem_flags)},
 246
 247         /* Memory-specific flags */
 248
 249         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.write_protect),
 250          AML_OFFSET(address.specific_flags),
 251          0},
 252
 253         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.caching),
 254          AML_OFFSET(address.specific_flags),
 255          1},
 256
 257         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.range_type),
 258          AML_OFFSET(address.specific_flags),
 259          3},
 260
 261         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.translation),
 262          AML_OFFSET(address.specific_flags),
 263          5}
 264 };
 265
 266 /*******************************************************************************
 267  *
 268  * acpi_rs_convert_io_flags - Flags common to I/O address descriptors
 269  *
 270  ******************************************************************************/
 271
 272 static struct acpi_rsconvert_info acpi_rs_convert_io_flags[4] = {
 273         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
 274          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io_flags)},
 275
 276         /* I/O-specific flags */
 277
 278         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.io.range_type),
 279          AML_OFFSET(address.specific_flags),
 280          0},
 281
 282         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.io.translation),
 283          AML_OFFSET(address.specific_flags),
 284          4},
 285
 286         {ACPI_RSC_1BITFLAG,
 287          ACPI_RS_OFFSET(data.address.info.io.translation_type),
 288          AML_OFFSET(address.specific_flags),
 289          5}
 290 };
 291
 292 /*******************************************************************************
 293  *
 294  * FUNCTION:    acpi_rs_get_address_common
 295  *
 296  * PARAMETERS:  Resource            - Pointer to the internal resource struct
 297  *              Aml                 - Pointer to the AML resource descriptor
 298  *
 299  * RETURN:      TRUE if the resource_type field is OK, FALSE otherwise
 300  *
 301  * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
 302  *              to an internal resource descriptor
 303  *
 304  ******************************************************************************/
 305
 306 u8
 307 acpi_rs_get_address_common(struct acpi_resource *resource,
 308                            union aml_resource *aml)
 309 {
 310         ACPI_FUNCTION_ENTRY();
 311
 312         /* Validate the Resource Type */
 313
 314         if ((aml->address.resource_type > 2)
 315             && (aml->address.resource_type < 0xC0)) {
 316                 return (FALSE);
 317         }
 318
 319         /* Get the Resource Type and General Flags */
 320
 321         (void)acpi_rs_convert_aml_to_resource(resource, aml,
 322                                               acpi_rs_convert_general_flags);
 323
 324         /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
 325
 326         if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
 327                 (void)acpi_rs_convert_aml_to_resource(resource, aml,
 328                                                       acpi_rs_convert_mem_flags);
 329         } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
 330                 (void)acpi_rs_convert_aml_to_resource(resource, aml,
 331                                                       acpi_rs_convert_io_flags);
 332         } else {
 333                 /* Generic resource type, just grab the type_specific byte */
 334
 335                 resource->data.address.info.type_specific =
 336                     aml->address.specific_flags;
 337         }
 338
 339         return (TRUE);
 340 }
 341
 342 /*******************************************************************************
 343  *
 344  * FUNCTION:    acpi_rs_set_address_common
 345  *
 346  * PARAMETERS:  Aml                 - Pointer to the AML resource descriptor
 347  *              Resource            - Pointer to the internal resource struct
 348  *
 349  * RETURN:      None
 350  *
 351  * DESCRIPTION: Convert common flag fields from a resource descriptor to an
 352  *              AML descriptor
 353  *
 354  ******************************************************************************/
 355
 356 void
 357 acpi_rs_set_address_common(union aml_resource *aml,
 358                            struct acpi_resource *resource)
 359 {
 360         ACPI_FUNCTION_ENTRY();
 361
 362         /* Set the Resource Type and General Flags */
 363
 364         (void)acpi_rs_convert_resource_to_aml(resource, aml,
 365                                               acpi_rs_convert_general_flags);
 366
 367         /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
 368
 369         if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
 370                 (void)acpi_rs_convert_resource_to_aml(resource, aml,
 371                                                       acpi_rs_convert_mem_flags);
 372         } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
 373                 (void)acpi_rs_convert_resource_to_aml(resource, aml,
 374                                                       acpi_rs_convert_io_flags);
 375         } else {
 376                 /* Generic resource type, just copy the type_specific byte */
 377
 378                 aml->address.specific_flags =
 379                     resource->data.address.info.type_specific;
 380         }
 381 }