drivers/acpi/acpica/rsaddr.c

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