Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
0002 /*******************************************************************************
0003  *
0004  * Module Name: rsaddr - Address resource descriptors (16/32/64)
0005  *
0006  ******************************************************************************/
0007 
0008 #include <acpi/acpi.h>
0009 #include "accommon.h"
0010 #include "acresrc.h"
0011 
0012 #define _COMPONENT          ACPI_RESOURCES
0013 ACPI_MODULE_NAME("rsaddr")
0014 
0015 /*******************************************************************************
0016  *
0017  * acpi_rs_convert_address16 - All WORD (16-bit) address resources
0018  *
0019  ******************************************************************************/
0020 struct acpi_rsconvert_info acpi_rs_convert_address16[5] = {
0021     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS16,
0022      ACPI_RS_SIZE(struct acpi_resource_address16),
0023      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address16)},
0024 
0025     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS16,
0026      sizeof(struct aml_resource_address16),
0027      0},
0028 
0029     /* Resource Type, General Flags, and Type-Specific Flags */
0030 
0031     {ACPI_RSC_ADDRESS, 0, 0, 0},
0032 
0033     /*
0034      * These fields are contiguous in both the source and destination:
0035      * Address Granularity
0036      * Address Range Minimum
0037      * Address Range Maximum
0038      * Address Translation Offset
0039      * Address Length
0040      */
0041     {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.address16.address.granularity),
0042      AML_OFFSET(address16.granularity),
0043      5},
0044 
0045     /* Optional resource_source (Index and String) */
0046 
0047     {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address16.resource_source),
0048      0,
0049      sizeof(struct aml_resource_address16)}
0050 };
0051 
0052 /*******************************************************************************
0053  *
0054  * acpi_rs_convert_address32 - All DWORD (32-bit) address resources
0055  *
0056  ******************************************************************************/
0057 
0058 struct acpi_rsconvert_info acpi_rs_convert_address32[5] = {
0059     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS32,
0060      ACPI_RS_SIZE(struct acpi_resource_address32),
0061      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address32)},
0062 
0063     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS32,
0064      sizeof(struct aml_resource_address32),
0065      0},
0066 
0067     /* Resource Type, General Flags, and Type-Specific Flags */
0068 
0069     {ACPI_RSC_ADDRESS, 0, 0, 0},
0070 
0071     /*
0072      * These fields are contiguous in both the source and destination:
0073      * Address Granularity
0074      * Address Range Minimum
0075      * Address Range Maximum
0076      * Address Translation Offset
0077      * Address Length
0078      */
0079     {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.address32.address.granularity),
0080      AML_OFFSET(address32.granularity),
0081      5},
0082 
0083     /* Optional resource_source (Index and String) */
0084 
0085     {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address32.resource_source),
0086      0,
0087      sizeof(struct aml_resource_address32)}
0088 };
0089 
0090 /*******************************************************************************
0091  *
0092  * acpi_rs_convert_address64 - All QWORD (64-bit) address resources
0093  *
0094  ******************************************************************************/
0095 
0096 struct acpi_rsconvert_info acpi_rs_convert_address64[5] = {
0097     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS64,
0098      ACPI_RS_SIZE(struct acpi_resource_address64),
0099      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address64)},
0100 
0101     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS64,
0102      sizeof(struct aml_resource_address64),
0103      0},
0104 
0105     /* Resource Type, General Flags, and Type-Specific Flags */
0106 
0107     {ACPI_RSC_ADDRESS, 0, 0, 0},
0108 
0109     /*
0110      * These fields are contiguous in both the source and destination:
0111      * Address Granularity
0112      * Address Range Minimum
0113      * Address Range Maximum
0114      * Address Translation Offset
0115      * Address Length
0116      */
0117     {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.address64.address.granularity),
0118      AML_OFFSET(address64.granularity),
0119      5},
0120 
0121     /* Optional resource_source (Index and String) */
0122 
0123     {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address64.resource_source),
0124      0,
0125      sizeof(struct aml_resource_address64)}
0126 };
0127 
0128 /*******************************************************************************
0129  *
0130  * acpi_rs_convert_ext_address64 - All Extended (64-bit) address resources
0131  *
0132  ******************************************************************************/
0133 
0134 struct acpi_rsconvert_info acpi_rs_convert_ext_address64[5] = {
0135     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
0136      ACPI_RS_SIZE(struct acpi_resource_extended_address64),
0137      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_address64)},
0138 
0139     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
0140      sizeof(struct aml_resource_extended_address64),
0141      0},
0142 
0143     /* Resource Type, General Flags, and Type-Specific Flags */
0144 
0145     {ACPI_RSC_ADDRESS, 0, 0, 0},
0146 
0147     /* Revision ID */
0148 
0149     {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.ext_address64.revision_ID),
0150      AML_OFFSET(ext_address64.revision_ID),
0151      1},
0152     /*
0153      * These fields are contiguous in both the source and destination:
0154      * Address Granularity
0155      * Address Range Minimum
0156      * Address Range Maximum
0157      * Address Translation Offset
0158      * Address Length
0159      * Type-Specific Attribute
0160      */
0161     {ACPI_RSC_MOVE64,
0162      ACPI_RS_OFFSET(data.ext_address64.address.granularity),
0163      AML_OFFSET(ext_address64.granularity),
0164      6}
0165 };
0166 
0167 /*******************************************************************************
0168  *
0169  * acpi_rs_convert_general_flags - Flags common to all address descriptors
0170  *
0171  ******************************************************************************/
0172 
0173 static struct acpi_rsconvert_info acpi_rs_convert_general_flags[6] = {
0174     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.flags),
0175      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_general_flags)},
0176 
0177     /* Resource Type (Memory, Io, bus_number, etc.) */
0178 
0179     {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.address.resource_type),
0180      AML_OFFSET(address.resource_type),
0181      1},
0182 
0183     /* General flags - Consume, Decode, min_fixed, max_fixed */
0184 
0185     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.producer_consumer),
0186      AML_OFFSET(address.flags),
0187      0},
0188 
0189     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.decode),
0190      AML_OFFSET(address.flags),
0191      1},
0192 
0193     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.min_address_fixed),
0194      AML_OFFSET(address.flags),
0195      2},
0196 
0197     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.max_address_fixed),
0198      AML_OFFSET(address.flags),
0199      3}
0200 };
0201 
0202 /*******************************************************************************
0203  *
0204  * acpi_rs_convert_mem_flags - Flags common to Memory address descriptors
0205  *
0206  ******************************************************************************/
0207 
0208 static struct acpi_rsconvert_info acpi_rs_convert_mem_flags[5] = {
0209     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
0210      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_mem_flags)},
0211 
0212     /* Memory-specific flags */
0213 
0214     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.write_protect),
0215      AML_OFFSET(address.specific_flags),
0216      0},
0217 
0218     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.caching),
0219      AML_OFFSET(address.specific_flags),
0220      1},
0221 
0222     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.range_type),
0223      AML_OFFSET(address.specific_flags),
0224      3},
0225 
0226     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.translation),
0227      AML_OFFSET(address.specific_flags),
0228      5}
0229 };
0230 
0231 /*******************************************************************************
0232  *
0233  * acpi_rs_convert_io_flags - Flags common to I/O address descriptors
0234  *
0235  ******************************************************************************/
0236 
0237 static struct acpi_rsconvert_info acpi_rs_convert_io_flags[4] = {
0238     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
0239      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io_flags)},
0240 
0241     /* I/O-specific flags */
0242 
0243     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.io.range_type),
0244      AML_OFFSET(address.specific_flags),
0245      0},
0246 
0247     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.io.translation),
0248      AML_OFFSET(address.specific_flags),
0249      4},
0250 
0251     {ACPI_RSC_1BITFLAG,
0252      ACPI_RS_OFFSET(data.address.info.io.translation_type),
0253      AML_OFFSET(address.specific_flags),
0254      5}
0255 };
0256 
0257 /*******************************************************************************
0258  *
0259  * FUNCTION:    acpi_rs_get_address_common
0260  *
0261  * PARAMETERS:  resource            - Pointer to the internal resource struct
0262  *              aml                 - Pointer to the AML resource descriptor
0263  *
0264  * RETURN:      TRUE if the resource_type field is OK, FALSE otherwise
0265  *
0266  * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
0267  *              to an internal resource descriptor
0268  *
0269  ******************************************************************************/
0270 
0271 u8
0272 acpi_rs_get_address_common(struct acpi_resource *resource,
0273                union aml_resource *aml)
0274 {
0275     ACPI_FUNCTION_ENTRY();
0276 
0277     /* Validate the Resource Type */
0278 
0279     if ((aml->address.resource_type > 2) &&
0280         (aml->address.resource_type < 0xC0)) {
0281         return (FALSE);
0282     }
0283 
0284     /* Get the Resource Type and General Flags */
0285 
0286     (void)acpi_rs_convert_aml_to_resource(resource, aml,
0287                           acpi_rs_convert_general_flags);
0288 
0289     /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
0290 
0291     if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
0292         (void)acpi_rs_convert_aml_to_resource(resource, aml,
0293                               acpi_rs_convert_mem_flags);
0294     } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
0295         (void)acpi_rs_convert_aml_to_resource(resource, aml,
0296                               acpi_rs_convert_io_flags);
0297     } else {
0298         /* Generic resource type, just grab the type_specific byte */
0299 
0300         resource->data.address.info.type_specific =
0301             aml->address.specific_flags;
0302     }
0303 
0304     return (TRUE);
0305 }
0306 
0307 /*******************************************************************************
0308  *
0309  * FUNCTION:    acpi_rs_set_address_common
0310  *
0311  * PARAMETERS:  aml                 - Pointer to the AML resource descriptor
0312  *              resource            - Pointer to the internal resource struct
0313  *
0314  * RETURN:      None
0315  *
0316  * DESCRIPTION: Convert common flag fields from a resource descriptor to an
0317  *              AML descriptor
0318  *
0319  ******************************************************************************/
0320 
0321 void
0322 acpi_rs_set_address_common(union aml_resource *aml,
0323                struct acpi_resource *resource)
0324 {
0325     ACPI_FUNCTION_ENTRY();
0326 
0327     /* Set the Resource Type and General Flags */
0328 
0329     (void)acpi_rs_convert_resource_to_aml(resource, aml,
0330                           acpi_rs_convert_general_flags);
0331 
0332     /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
0333 
0334     if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
0335         (void)acpi_rs_convert_resource_to_aml(resource, aml,
0336                               acpi_rs_convert_mem_flags);
0337     } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
0338         (void)acpi_rs_convert_resource_to_aml(resource, aml,
0339                               acpi_rs_convert_io_flags);
0340     } else {
0341         /* Generic resource type, just copy the type_specific byte */
0342 
0343         aml->address.specific_flags =
0344             resource->data.address.info.type_specific;
0345     }
0346 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!