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 - 2015, 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.address.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.address.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.address.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,
 198          ACPI_RS_OFFSET(data.ext_address64.address.granularity),
 199          AML_OFFSET(ext_address64.granularity),
 200          6}
 201 };
 202
 203 /*******************************************************************************
 204  *
 205  * acpi_rs_convert_general_flags - Flags common to all address descriptors
 206  *
 207  ******************************************************************************/
 208
 209 static struct acpi_rsconvert_info acpi_rs_convert_general_flags[6] = {
 210         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.flags),
 211          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_general_flags)},
 212
 213         /* Resource Type (Memory, Io, bus_number, etc.) */
 214
 215         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.address.resource_type),
 216          AML_OFFSET(address.resource_type),
 217          1},
 218
 219         /* General flags - Consume, Decode, min_fixed, max_fixed */
 220
 221         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.producer_consumer),
 222          AML_OFFSET(address.flags),
 223          0},
 224
 225         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.decode),
 226          AML_OFFSET(address.flags),
 227          1},
 228
 229         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.min_address_fixed),
 230          AML_OFFSET(address.flags),
 231          2},
 232
 233         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.max_address_fixed),
 234          AML_OFFSET(address.flags),
 235          3}
 236 };
 237
 238 /*******************************************************************************
 239  *
 240  * acpi_rs_convert_mem_flags - Flags common to Memory address descriptors
 241  *
 242  ******************************************************************************/
 243
 244 static struct acpi_rsconvert_info acpi_rs_convert_mem_flags[5] = {
 245         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
 246          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_mem_flags)},
 247
 248         /* Memory-specific flags */
 249
 250         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.write_protect),
 251          AML_OFFSET(address.specific_flags),
 252          0},
 253
 254         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.caching),
 255          AML_OFFSET(address.specific_flags),
 256          1},
 257
 258         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.range_type),
 259          AML_OFFSET(address.specific_flags),
 260          3},
 261
 262         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.translation),
 263          AML_OFFSET(address.specific_flags),
 264          5}
 265 };
 266
 267 /*******************************************************************************
 268  *
 269  * acpi_rs_convert_io_flags - Flags common to I/O address descriptors
 270  *
 271  ******************************************************************************/
 272
 273 static struct acpi_rsconvert_info acpi_rs_convert_io_flags[4] = {
 274         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
 275          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io_flags)},
 276
 277         /* I/O-specific flags */
 278
 279         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.io.range_type),
 280          AML_OFFSET(address.specific_flags),
 281          0},
 282
 283         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.io.translation),
 284          AML_OFFSET(address.specific_flags),
 285          4},
 286
 287         {ACPI_RSC_1BITFLAG,
 288          ACPI_RS_OFFSET(data.address.info.io.translation_type),
 289          AML_OFFSET(address.specific_flags),
 290          5}
 291 };
 292
 293 /*******************************************************************************
 294  *
 295  * FUNCTION:    acpi_rs_get_address_common
 296  *
 297  * PARAMETERS:  resource            - Pointer to the internal resource struct
 298  *              aml                 - Pointer to the AML resource descriptor
 299  *
 300  * RETURN:      TRUE if the resource_type field is OK, FALSE otherwise
 301  *
 302  * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
 303  *              to an internal resource descriptor
 304  *
 305  ******************************************************************************/
 306
 307 u8
 308 acpi_rs_get_address_common(struct acpi_resource *resource,
 309                            union aml_resource *aml)
 310 {
 311         ACPI_FUNCTION_ENTRY();
 312
 313         /* Validate the Resource Type */
 314
 315         if ((aml->address.resource_type > 2)
 316             && (aml->address.resource_type < 0xC0)) {
 317                 return (FALSE);
 318         }
 319
 320         /* Get the Resource Type and General Flags */
 321
 322         (void)acpi_rs_convert_aml_to_resource(resource, aml,
 323                                               acpi_rs_convert_general_flags);
 324
 325         /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
 326
 327         if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
 328                 (void)acpi_rs_convert_aml_to_resource(resource, aml,
 329                                                       acpi_rs_convert_mem_flags);
 330         } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
 331                 (void)acpi_rs_convert_aml_to_resource(resource, aml,
 332                                                       acpi_rs_convert_io_flags);
 333         } else {
 334                 /* Generic resource type, just grab the type_specific byte */
 335
 336                 resource->data.address.info.type_specific =
 337                     aml->address.specific_flags;
 338         }
 339
 340         return (TRUE);
 341 }
 342
 343 /*******************************************************************************
 344  *
 345  * FUNCTION:    acpi_rs_set_address_common
 346  *
 347  * PARAMETERS:  aml                 - Pointer to the AML resource descriptor
 348  *              resource            - Pointer to the internal resource struct
 349  *
 350  * RETURN:      None
 351  *
 352  * DESCRIPTION: Convert common flag fields from a resource descriptor to an
 353  *              AML descriptor
 354  *
 355  ******************************************************************************/
 356
 357 void
 358 acpi_rs_set_address_common(union aml_resource *aml,
 359                            struct acpi_resource *resource)
 360 {
 361         ACPI_FUNCTION_ENTRY();
 362
 363         /* Set the Resource Type and General Flags */
 364
 365         (void)acpi_rs_convert_resource_to_aml(resource, aml,
 366                                               acpi_rs_convert_general_flags);
 367
 368         /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
 369
 370         if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
 371                 (void)acpi_rs_convert_resource_to_aml(resource, aml,
 372                                                       acpi_rs_convert_mem_flags);
 373         } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
 374                 (void)acpi_rs_convert_resource_to_aml(resource, aml,
 375                                                       acpi_rs_convert_io_flags);
 376         } else {
 377                 /* Generic resource type, just copy the type_specific byte */
 378
 379                 aml->address.specific_flags =
 380                     resource->data.address.info.type_specific;
 381         }
 382 }