sys/contrib/dev/acpica/components/resources/rsaddr.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsaddr - Address resource descriptors (16/32/64)
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 #define __RSADDR_C__
  45
  46 #include <contrib/dev/acpica/include/acpi.h>
  47 #include <contrib/dev/acpica/include/accommon.h>
  48 #include <contrib/dev/acpica/include/acresrc.h>
  49
  50 #define _COMPONENT          ACPI_RESOURCES
  51         ACPI_MODULE_NAME    ("rsaddr")
  52
  53
  54 /*******************************************************************************
  55  *
  56  * AcpiRsConvertAddress16 - All WORD (16-bit) address resources
  57  *
  58  ******************************************************************************/
  59
  60 ACPI_RSCONVERT_INFO     AcpiRsConvertAddress16[5] =
  61 {
  62     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS16,
  63                         ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS16),
  64                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress16)},
  65
  66     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS16,
  67                         sizeof (AML_RESOURCE_ADDRESS16),
  68                         0},
  69
  70     /* Resource Type, General Flags, and Type-Specific Flags */
  71
  72     {ACPI_RSC_ADDRESS,  0, 0, 0},
  73
  74     /*
  75      * These fields are contiguous in both the source and destination:
  76      * Address Granularity
  77      * Address Range Minimum
  78      * Address Range Maximum
  79      * Address Translation Offset
  80      * Address Length
  81      */
  82     {ACPI_RSC_MOVE16,   ACPI_RS_OFFSET (Data.Address16.Granularity),
  83                         AML_OFFSET (Address16.Granularity),
  84                         5},
  85
  86     /* Optional ResourceSource (Index and String) */
  87
  88     {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address16.ResourceSource),
  89                         0,
  90                         sizeof (AML_RESOURCE_ADDRESS16)}
  91 };
  92
  93
  94 /*******************************************************************************
  95  *
  96  * AcpiRsConvertAddress32 - All DWORD (32-bit) address resources
  97  *
  98  ******************************************************************************/
  99
 100 ACPI_RSCONVERT_INFO     AcpiRsConvertAddress32[5] =
 101 {
 102     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS32,
 103                         ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS32),
 104                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress32)},
 105
 106     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS32,
 107                         sizeof (AML_RESOURCE_ADDRESS32),
 108                         0},
 109
 110     /* Resource Type, General Flags, and Type-Specific Flags */
 111
 112     {ACPI_RSC_ADDRESS,  0, 0, 0},
 113
 114     /*
 115      * These fields are contiguous in both the source and destination:
 116      * Address Granularity
 117      * Address Range Minimum
 118      * Address Range Maximum
 119      * Address Translation Offset
 120      * Address Length
 121      */
 122     {ACPI_RSC_MOVE32,   ACPI_RS_OFFSET (Data.Address32.Granularity),
 123                         AML_OFFSET (Address32.Granularity),
 124                         5},
 125
 126     /* Optional ResourceSource (Index and String) */
 127
 128     {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address32.ResourceSource),
 129                         0,
 130                         sizeof (AML_RESOURCE_ADDRESS32)}
 131 };
 132
 133
 134 /*******************************************************************************
 135  *
 136  * AcpiRsConvertAddress64 - All QWORD (64-bit) address resources
 137  *
 138  ******************************************************************************/
 139
 140 ACPI_RSCONVERT_INFO     AcpiRsConvertAddress64[5] =
 141 {
 142     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_ADDRESS64,
 143                         ACPI_RS_SIZE (ACPI_RESOURCE_ADDRESS64),
 144                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertAddress64)},
 145
 146     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_ADDRESS64,
 147                         sizeof (AML_RESOURCE_ADDRESS64),
 148                         0},
 149
 150     /* Resource Type, General Flags, and Type-Specific Flags */
 151
 152     {ACPI_RSC_ADDRESS,  0, 0, 0},
 153
 154     /*
 155      * These fields are contiguous in both the source and destination:
 156      * Address Granularity
 157      * Address Range Minimum
 158      * Address Range Maximum
 159      * Address Translation Offset
 160      * Address Length
 161      */
 162     {ACPI_RSC_MOVE64,   ACPI_RS_OFFSET (Data.Address64.Granularity),
 163                         AML_OFFSET (Address64.Granularity),
 164                         5},
 165
 166     /* Optional ResourceSource (Index and String) */
 167
 168     {ACPI_RSC_SOURCE,   ACPI_RS_OFFSET (Data.Address64.ResourceSource),
 169                         0,
 170                         sizeof (AML_RESOURCE_ADDRESS64)}
 171 };
 172
 173
 174 /*******************************************************************************
 175  *
 176  * AcpiRsConvertExtAddress64 - All Extended (64-bit) address resources
 177  *
 178  ******************************************************************************/
 179
 180 ACPI_RSCONVERT_INFO     AcpiRsConvertExtAddress64[5] =
 181 {
 182     {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
 183                         ACPI_RS_SIZE (ACPI_RESOURCE_EXTENDED_ADDRESS64),
 184                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertExtAddress64)},
 185
 186     {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
 187                         sizeof (AML_RESOURCE_EXTENDED_ADDRESS64),
 188                         0},
 189
 190     /* Resource Type, General Flags, and Type-Specific Flags */
 191
 192     {ACPI_RSC_ADDRESS,  0, 0, 0},
 193
 194     /* Revision ID */
 195
 196     {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.ExtAddress64.RevisionID),
 197                         AML_OFFSET (ExtAddress64.RevisionID),
 198                         1},
 199     /*
 200      * These fields are contiguous in both the source and destination:
 201      * Address Granularity
 202      * Address Range Minimum
 203      * Address Range Maximum
 204      * Address Translation Offset
 205      * Address Length
 206      * Type-Specific Attribute
 207      */
 208     {ACPI_RSC_MOVE64,   ACPI_RS_OFFSET (Data.ExtAddress64.Granularity),
 209                         AML_OFFSET (ExtAddress64.Granularity),
 210                         6}
 211 };
 212
 213
 214 /*******************************************************************************
 215  *
 216  * AcpiRsConvertGeneralFlags - Flags common to all address descriptors
 217  *
 218  ******************************************************************************/
 219
 220 static ACPI_RSCONVERT_INFO  AcpiRsConvertGeneralFlags[6] =
 221 {
 222     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.Flags),
 223                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertGeneralFlags)},
 224
 225     /* Resource Type (Memory, Io, BusNumber, etc.) */
 226
 227     {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.Address.ResourceType),
 228                         AML_OFFSET (Address.ResourceType),
 229                         1},
 230
 231     /* General Flags - Consume, Decode, MinFixed, MaxFixed */
 232
 233     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.ProducerConsumer),
 234                         AML_OFFSET (Address.Flags),
 235                         0},
 236
 237     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Decode),
 238                         AML_OFFSET (Address.Flags),
 239                         1},
 240
 241     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.MinAddressFixed),
 242                         AML_OFFSET (Address.Flags),
 243                         2},
 244
 245     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.MaxAddressFixed),
 246                         AML_OFFSET (Address.Flags),
 247                         3}
 248 };
 249
 250
 251 /*******************************************************************************
 252  *
 253  * AcpiRsConvertMemFlags - Flags common to Memory address descriptors
 254  *
 255  ******************************************************************************/
 256
 257 static ACPI_RSCONVERT_INFO  AcpiRsConvertMemFlags[5] =
 258 {
 259     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.SpecificFlags),
 260                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertMemFlags)},
 261
 262     /* Memory-specific flags */
 263
 264     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.WriteProtect),
 265                         AML_OFFSET (Address.SpecificFlags),
 266                         0},
 267
 268     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.Caching),
 269                         AML_OFFSET (Address.SpecificFlags),
 270                         1},
 271
 272     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.RangeType),
 273                         AML_OFFSET (Address.SpecificFlags),
 274                         3},
 275
 276     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Mem.Translation),
 277                         AML_OFFSET (Address.SpecificFlags),
 278                         5}
 279 };
 280
 281
 282 /*******************************************************************************
 283  *
 284  * AcpiRsConvertIoFlags - Flags common to I/O address descriptors
 285  *
 286  ******************************************************************************/
 287
 288 static ACPI_RSCONVERT_INFO  AcpiRsConvertIoFlags[4] =
 289 {
 290     {ACPI_RSC_FLAGINIT, 0, AML_OFFSET (Address.SpecificFlags),
 291                         ACPI_RSC_TABLE_SIZE (AcpiRsConvertIoFlags)},
 292
 293     /* I/O-specific flags */
 294
 295     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.RangeType),
 296                         AML_OFFSET (Address.SpecificFlags),
 297                         0},
 298
 299     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.Translation),
 300                         AML_OFFSET (Address.SpecificFlags),
 301                         4},
 302
 303     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Address.Info.Io.TranslationType),
 304                         AML_OFFSET (Address.SpecificFlags),
 305                         5}
 306 };
 307
 308
 309 /*******************************************************************************
 310  *
 311  * FUNCTION:    AcpiRsGetAddressCommon
 312  *
 313  * PARAMETERS:  Resource            - Pointer to the internal resource struct
 314  *              Aml                 - Pointer to the AML resource descriptor
 315  *
 316  * RETURN:      TRUE if the ResourceType field is OK, FALSE otherwise
 317  *
 318  * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
 319  *              to an internal resource descriptor
 320  *
 321  ******************************************************************************/
 322
 323 BOOLEAN
 324 AcpiRsGetAddressCommon (
 325     ACPI_RESOURCE           *Resource,
 326     AML_RESOURCE            *Aml)
 327 {
 328     ACPI_FUNCTION_ENTRY ();
 329
 330
 331     /* Validate the Resource Type */
 332
 333     if ((Aml->Address.ResourceType > 2) && (Aml->Address.ResourceType < 0xC0))
 334     {
 335         return (FALSE);
 336     }
 337
 338     /* Get the Resource Type and General Flags */
 339
 340     (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertGeneralFlags);
 341
 342     /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
 343
 344     if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
 345     {
 346         (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertMemFlags);
 347     }
 348     else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
 349     {
 350         (void) AcpiRsConvertAmlToResource (Resource, Aml, AcpiRsConvertIoFlags);
 351     }
 352     else
 353     {
 354         /* Generic resource type, just grab the TypeSpecific byte */
 355
 356         Resource->Data.Address.Info.TypeSpecific = Aml->Address.SpecificFlags;
 357     }
 358
 359     return (TRUE);
 360 }
 361
 362
 363 /*******************************************************************************
 364  *
 365  * FUNCTION:    AcpiRsSetAddressCommon
 366  *
 367  * PARAMETERS:  Aml                 - Pointer to the AML resource descriptor
 368  *              Resource            - Pointer to the internal resource struct
 369  *
 370  * RETURN:      None
 371  *
 372  * DESCRIPTION: Convert common flag fields from a resource descriptor to an
 373  *              AML descriptor
 374  *
 375  ******************************************************************************/
 376
 377 void
 378 AcpiRsSetAddressCommon (
 379     AML_RESOURCE            *Aml,
 380     ACPI_RESOURCE           *Resource)
 381 {
 382     ACPI_FUNCTION_ENTRY ();
 383
 384
 385     /* Set the Resource Type and General Flags */
 386
 387     (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertGeneralFlags);
 388
 389     /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
 390
 391     if (Resource->Data.Address.ResourceType == ACPI_MEMORY_RANGE)
 392     {
 393         (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertMemFlags);
 394     }
 395     else if (Resource->Data.Address.ResourceType == ACPI_IO_RANGE)
 396     {
 397         (void) AcpiRsConvertResourceToAml (Resource, Aml, AcpiRsConvertIoFlags);
 398     }
 399     else
 400     {
 401         /* Generic resource type, just copy the TypeSpecific byte */
 402
 403         Aml->Address.SpecificFlags = Resource->Data.Address.Info.TypeSpecific;
 404     }
 405 }