sys/contrib/dev/acpica/source/common/dmrestag.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dmrestag - Add tags to resource descriptors (Application-level)
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, 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.h"
  45 #include "accommon.h"
  46 #include "acparser.h"
  47 #include "acdisasm.h"
  48 #include "acnamesp.h"
  49 #include "amlcode.h"
  50
  51 /* This module used for application-level code only */
  52
  53 #define _COMPONENT          ACPI_CA_DISASSEMBLER
  54         ACPI_MODULE_NAME    ("dmrestag")
  55
  56 /* Local prototypes */
  57
  58 static void
  59 AcpiDmUpdateResourceName (
  60     ACPI_NAMESPACE_NODE     *ResourceNode);
  61
  62 static char *
  63 AcpiDmSearchTagList (
  64     UINT32                  BitIndex,
  65     const ACPI_RESOURCE_TAG *TagList);
  66
  67 static char *
  68 AcpiDmGetResourceTag (
  69     UINT32                  BitIndex,
  70     AML_RESOURCE            *Resource,
  71     UINT8                   ResourceIndex);
  72
  73 static char *
  74 AcpiGetTagPathname (
  75     ACPI_PARSE_OBJECT       *Op,
  76     ACPI_NAMESPACE_NODE     *BufferNode,
  77     ACPI_NAMESPACE_NODE     *ResourceNode,
  78     UINT32                  BitIndex);
  79
  80 static ACPI_NAMESPACE_NODE *
  81 AcpiDmGetResourceNode (
  82     ACPI_NAMESPACE_NODE     *BufferNode,
  83     UINT32                  BitIndex);
  84
  85 static ACPI_STATUS
  86 AcpiDmAddResourceToNamespace (
  87     UINT8                   *Aml,
  88     UINT32                  Length,
  89     UINT32                  Offset,
  90     UINT8                   ResourceIndex,
  91     void                    **Context);
  92
  93 static void
  94 AcpiDmAddResourcesToNamespace (
  95     ACPI_NAMESPACE_NODE     *BufferNode,
  96     ACPI_PARSE_OBJECT       *Op);
  97
  98
  99 /******************************************************************************
 100  *
 101  * Resource Tag tables
 102  *
 103  * These are the predefined tags that refer to elements of a resource
 104  * descriptor. Each name and offset is defined in the ACPI specification.
 105  *
 106  * Each table entry contains the bit offset of the field and the associated
 107  * name.
 108  *
 109  ******************************************************************************/
 110
 111 static const ACPI_RESOURCE_TAG      AcpiDmIrqTags[] =
 112 {
 113     {( 1 * 8),      ACPI_RESTAG_INTERRUPT},
 114     {( 3 * 8) + 0,  ACPI_RESTAG_INTERRUPTTYPE},
 115     {( 3 * 8) + 3,  ACPI_RESTAG_INTERRUPTLEVEL},
 116     {( 3 * 8) + 4,  ACPI_RESTAG_INTERRUPTSHARE},
 117     {0,             NULL}
 118 };
 119
 120 static const ACPI_RESOURCE_TAG      AcpiDmDmaTags[] =
 121 {
 122     {( 1 * 8),      ACPI_RESTAG_DMA},
 123     {( 2 * 8) + 0,  ACPI_RESTAG_XFERTYPE},
 124     {( 2 * 8) + 2,  ACPI_RESTAG_BUSMASTER},
 125     {( 2 * 8) + 5,  ACPI_RESTAG_DMATYPE},
 126     {0,             NULL}
 127 };
 128
 129 static const ACPI_RESOURCE_TAG      AcpiDmIoTags[] =
 130 {
 131     {( 1 * 8) + 0,  ACPI_RESTAG_DECODE},
 132     {( 2 * 8),      ACPI_RESTAG_MINADDR},
 133     {( 4 * 8),      ACPI_RESTAG_MAXADDR},
 134     {( 6 * 8),      ACPI_RESTAG_ALIGNMENT},
 135     {( 7 * 8),      ACPI_RESTAG_LENGTH},
 136     {0,             NULL}
 137 };
 138
 139 static const ACPI_RESOURCE_TAG      AcpiDmFixedIoTags[] =
 140 {
 141     {( 1 * 8),      ACPI_RESTAG_BASEADDRESS},
 142     {( 3 * 8),      ACPI_RESTAG_LENGTH},
 143     {0,             NULL}
 144 };
 145
 146 static const ACPI_RESOURCE_TAG      AcpiDmFixedDmaTags[] =
 147 {
 148     {( 1 * 8),      ACPI_RESTAG_DMA},
 149     {( 3 * 8),      ACPI_RESTAG_DMATYPE},
 150     {( 5 * 8),      ACPI_RESTAG_XFERTYPE},
 151     {0,             NULL}
 152 };
 153
 154 static const ACPI_RESOURCE_TAG      AcpiDmMemory24Tags[] =
 155 {
 156     {( 3 * 8) + 0,  ACPI_RESTAG_READWRITETYPE},
 157     {( 4 * 8),      ACPI_RESTAG_MINADDR},
 158     {( 6 * 8),      ACPI_RESTAG_MAXADDR},
 159     {( 8 * 8),      ACPI_RESTAG_ALIGNMENT},
 160     {(10 * 8),      ACPI_RESTAG_LENGTH},
 161     {0,             NULL}
 162 };
 163
 164 static const ACPI_RESOURCE_TAG      AcpiDmRegisterTags[] =
 165 {
 166     {( 3 * 8),      ACPI_RESTAG_ADDRESSSPACE},
 167     {( 4 * 8),      ACPI_RESTAG_REGISTERBITWIDTH},
 168     {( 5 * 8),      ACPI_RESTAG_REGISTERBITOFFSET},
 169     {( 6 * 8),      ACPI_RESTAG_ACCESSSIZE},
 170     {( 7 * 8),      ACPI_RESTAG_ADDRESS},
 171     {0,             NULL}
 172 };
 173
 174 static const ACPI_RESOURCE_TAG      AcpiDmMemory32Tags[] =
 175 {
 176     {( 3 * 8) + 0,  ACPI_RESTAG_READWRITETYPE},
 177     {( 4 * 8),      ACPI_RESTAG_MINADDR},
 178     {( 8 * 8),      ACPI_RESTAG_MAXADDR},
 179     {(12 * 8),      ACPI_RESTAG_ALIGNMENT},
 180     {(16 * 8),      ACPI_RESTAG_LENGTH},
 181     {0,             NULL}
 182 };
 183
 184 static const ACPI_RESOURCE_TAG      AcpiDmFixedMemory32Tags[] =
 185 {
 186     {( 3 * 8) + 0,  ACPI_RESTAG_READWRITETYPE},
 187     {( 4 * 8),      ACPI_RESTAG_BASEADDRESS},
 188     {( 8 * 8),      ACPI_RESTAG_LENGTH},
 189     {0,             NULL}
 190 };
 191
 192 static const ACPI_RESOURCE_TAG      AcpiDmInterruptTags[] =
 193 {
 194     {( 3 * 8) + 1,  ACPI_RESTAG_INTERRUPTTYPE},
 195     {( 3 * 8) + 2,  ACPI_RESTAG_INTERRUPTLEVEL},
 196     {( 3 * 8) + 3,  ACPI_RESTAG_INTERRUPTSHARE},
 197     {( 5 * 8),      ACPI_RESTAG_INTERRUPT},
 198     {0,             NULL}
 199 };
 200
 201 static const ACPI_RESOURCE_TAG      AcpiDmAddress16Tags[] =
 202 {
 203     {( 4 * 8) + 1,  ACPI_RESTAG_DECODE},
 204     {( 4 * 8) + 2,  ACPI_RESTAG_MINTYPE},
 205     {( 4 * 8) + 3,  ACPI_RESTAG_MAXTYPE},
 206     {( 6 * 8),      ACPI_RESTAG_GRANULARITY},
 207     {( 8 * 8),      ACPI_RESTAG_MINADDR},
 208     {(10 * 8),      ACPI_RESTAG_MAXADDR},
 209     {(12 * 8),      ACPI_RESTAG_TRANSLATION},
 210     {(14 * 8),      ACPI_RESTAG_LENGTH},
 211     {0,             NULL}
 212 };
 213
 214 static const ACPI_RESOURCE_TAG      AcpiDmAddress32Tags[] =
 215 {
 216     {( 4 * 8) + 1,  ACPI_RESTAG_DECODE},
 217     {( 4 * 8) + 2,  ACPI_RESTAG_MINTYPE},
 218     {( 4 * 8) + 3,  ACPI_RESTAG_MAXTYPE},
 219     {( 6 * 8),      ACPI_RESTAG_GRANULARITY},
 220     {(10 * 8),      ACPI_RESTAG_MINADDR},
 221     {(14 * 8),      ACPI_RESTAG_MAXADDR},
 222     {(18 * 8),      ACPI_RESTAG_TRANSLATION},
 223     {(22 * 8),      ACPI_RESTAG_LENGTH},
 224     {0,             NULL}
 225 };
 226
 227 static const ACPI_RESOURCE_TAG      AcpiDmAddress64Tags[] =
 228 {
 229     {( 4 * 8) + 1,  ACPI_RESTAG_DECODE},
 230     {( 4 * 8) + 2,  ACPI_RESTAG_MINTYPE},
 231     {( 4 * 8) + 3,  ACPI_RESTAG_MAXTYPE},
 232     {( 6 * 8),      ACPI_RESTAG_GRANULARITY},
 233     {(14 * 8),      ACPI_RESTAG_MINADDR},
 234     {(22 * 8),      ACPI_RESTAG_MAXADDR},
 235     {(30 * 8),      ACPI_RESTAG_TRANSLATION},
 236     {(38 * 8),      ACPI_RESTAG_LENGTH},
 237     {0,             NULL}
 238 };
 239
 240 static const ACPI_RESOURCE_TAG      AcpiDmExtendedAddressTags[] =
 241 {
 242     {( 4 * 8) + 1,  ACPI_RESTAG_DECODE},
 243     {( 4 * 8) + 2,  ACPI_RESTAG_MINTYPE},
 244     {( 4 * 8) + 3,  ACPI_RESTAG_MAXTYPE},
 245     {( 8 * 8),      ACPI_RESTAG_GRANULARITY},
 246     {(16 * 8),      ACPI_RESTAG_MINADDR},
 247     {(24 * 8),      ACPI_RESTAG_MAXADDR},
 248     {(32 * 8),      ACPI_RESTAG_TRANSLATION},
 249     {(40 * 8),      ACPI_RESTAG_LENGTH},
 250     {(48 * 8),      ACPI_RESTAG_TYPESPECIFICATTRIBUTES},
 251     {0,             NULL}
 252 };
 253
 254 /* Subtype tables for GPIO descriptors */
 255
 256 static const ACPI_RESOURCE_TAG      AcpiDmGpioIntTags[] =
 257 {
 258     {( 7 * 8) + 0,  ACPI_RESTAG_MODE},
 259     {( 7 * 8) + 1,  ACPI_RESTAG_POLARITY},
 260     {( 7 * 8) + 3,  ACPI_RESTAG_INTERRUPTSHARE},
 261     {( 9 * 8),      ACPI_RESTAG_PINCONFIG},
 262     {(10 * 8),      ACPI_RESTAG_DRIVESTRENGTH},
 263     {(12 * 8),      ACPI_RESTAG_DEBOUNCETIME},
 264     {0,             NULL}
 265 };
 266
 267 static const ACPI_RESOURCE_TAG      AcpiDmGpioIoTags[] =
 268 {
 269     {( 7 * 8) + 0,  ACPI_RESTAG_IORESTRICTION},
 270     {( 7 * 8) + 3,  ACPI_RESTAG_INTERRUPTSHARE},
 271     {( 9 * 8),      ACPI_RESTAG_PINCONFIG},
 272     {(10 * 8),      ACPI_RESTAG_DRIVESTRENGTH},
 273     {(12 * 8),      ACPI_RESTAG_DEBOUNCETIME},
 274     {0,             NULL}
 275 };
 276
 277 /* Subtype tables for SerialBus descriptors */
 278
 279 static const ACPI_RESOURCE_TAG      AcpiDmI2cSerialBusTags[] =
 280 {
 281     {( 6 * 8) + 0,  ACPI_RESTAG_SLAVEMODE},
 282     {( 7 * 8) + 0,  ACPI_RESTAG_MODE},
 283     {(12 * 8),      ACPI_RESTAG_SPEED},
 284     {(16 * 8),      ACPI_RESTAG_ADDRESS},
 285     {0,             NULL}
 286 };
 287
 288 static const ACPI_RESOURCE_TAG      AcpiDmSpiSerialBusTags[] =
 289 {
 290     {( 6 * 8) + 0,  ACPI_RESTAG_SLAVEMODE},
 291     {( 7 * 8) + 0,  ACPI_RESTAG_MODE},
 292     {( 7 * 8) + 1,  ACPI_RESTAG_DEVICEPOLARITY},
 293     {(12 * 8),      ACPI_RESTAG_SPEED},
 294     {(16 * 8),      ACPI_RESTAG_LENGTH},
 295     {(17 * 8),      ACPI_RESTAG_PHASE},
 296     {(18 * 8),      ACPI_RESTAG_POLARITY},
 297     {(19 * 8),      ACPI_RESTAG_ADDRESS},
 298     {0,             NULL}
 299 };
 300
 301 static const ACPI_RESOURCE_TAG      AcpiDmUartSerialBusTags[] =
 302 {
 303     {( 6 * 8) + 0,  ACPI_RESTAG_SLAVEMODE}, /* Note: not part of original macro */
 304     {( 7 * 8) + 0,  ACPI_RESTAG_FLOWCONTROL},
 305     {( 7 * 8) + 2,  ACPI_RESTAG_STOPBITS},
 306     {( 7 * 8) + 4,  ACPI_RESTAG_LENGTH},
 307     {( 7 * 8) + 7,  ACPI_RESTAG_ENDIANNESS},
 308     {(12 * 8),      ACPI_RESTAG_SPEED},
 309     {(16 * 8),      ACPI_RESTAG_LENGTH_RX},
 310     {(18 * 8),      ACPI_RESTAG_LENGTH_TX},
 311     {(20 * 8),      ACPI_RESTAG_PARITY},
 312     {(21 * 8),      ACPI_RESTAG_LINE},
 313     {0,             NULL}
 314 };
 315
 316 /* Subtype tables for Address descriptor type-specific flags */
 317
 318 static const ACPI_RESOURCE_TAG      AcpiDmMemoryFlagTags[] =
 319 {
 320     {( 5 * 8) + 0,  ACPI_RESTAG_READWRITETYPE},
 321     {( 5 * 8) + 1,  ACPI_RESTAG_MEMTYPE},
 322     {( 5 * 8) + 3,  ACPI_RESTAG_MEMATTRIBUTES},
 323     {( 5 * 8) + 5,  ACPI_RESTAG_TYPE},
 324     {0,             NULL}
 325 };
 326
 327 static const ACPI_RESOURCE_TAG      AcpiDmIoFlagTags[] =
 328 {
 329     {( 5 * 8) + 0,  ACPI_RESTAG_RANGETYPE},
 330     {( 5 * 8) + 4,  ACPI_RESTAG_TYPE},
 331     {( 5 * 8) + 5,  ACPI_RESTAG_TRANSTYPE},
 332     {0,             NULL}
 333 };
 334
 335
 336 /*
 337  * Dispatch table used to obtain the correct tag table for a descriptor.
 338  *
 339  * A NULL in this table means one of three things:
 340  * 1) The descriptor ID is reserved and invalid
 341  * 2) The descriptor has no tags associated with it
 342  * 3) The descriptor has subtypes and a separate table will be used.
 343  */
 344 static const ACPI_RESOURCE_TAG      *AcpiGbl_ResourceTags[] =
 345 {
 346     /* Small descriptors */
 347
 348     NULL,                           /* 0x00, Reserved */
 349     NULL,                           /* 0x01, Reserved */
 350     NULL,                           /* 0x02, Reserved */
 351     NULL,                           /* 0x03, Reserved */
 352     AcpiDmIrqTags,                  /* 0x04, ACPI_RESOURCE_NAME_IRQ_FORMAT */
 353     AcpiDmDmaTags,                  /* 0x05, ACPI_RESOURCE_NAME_DMA_FORMAT */
 354     NULL,                           /* 0x06, ACPI_RESOURCE_NAME_START_DEPENDENT */
 355     NULL,                           /* 0x07, ACPI_RESOURCE_NAME_END_DEPENDENT */
 356     AcpiDmIoTags,                   /* 0x08, ACPI_RESOURCE_NAME_IO_PORT */
 357     AcpiDmFixedIoTags,              /* 0x09, ACPI_RESOURCE_NAME_FIXED_IO_PORT */
 358     AcpiDmFixedDmaTags,             /* 0x0A, ACPI_RESOURCE_NAME_FIXED_DMA */
 359     NULL,                           /* 0x0B, Reserved */
 360     NULL,                           /* 0x0C, Reserved */
 361     NULL,                           /* 0x0D, Reserved */
 362     NULL,                           /* 0x0E, ACPI_RESOURCE_NAME_SMALL_VENDOR */
 363     NULL,                           /* 0x0F, ACPI_RESOURCE_NAME_END_TAG (not used) */
 364
 365     /* Large descriptors */
 366
 367     NULL,                           /* 0x00, Reserved */
 368     AcpiDmMemory24Tags,             /* 0x01, ACPI_RESOURCE_NAME_MEMORY_24 */
 369     AcpiDmRegisterTags,             /* 0x02, ACPI_RESOURCE_NAME_GENERIC_REGISTER */
 370     NULL,                           /* 0x03, Reserved */
 371     NULL,                           /* 0x04, ACPI_RESOURCE_NAME_LARGE_VENDOR */
 372     AcpiDmMemory32Tags,             /* 0x05, ACPI_RESOURCE_NAME_MEMORY_32 */
 373     AcpiDmFixedMemory32Tags,        /* 0x06, ACPI_RESOURCE_NAME_FIXED_MEMORY_32 */
 374     AcpiDmAddress32Tags,            /* 0x07, ACPI_RESOURCE_NAME_DWORD_ADDRESS_SPACE */
 375     AcpiDmAddress16Tags,            /* 0x08, ACPI_RESOURCE_NAME_WORD_ADDRESS_SPACE */
 376     AcpiDmInterruptTags,            /* 0x09, ACPI_RESOURCE_NAME_EXTENDED_XRUPT */
 377     AcpiDmAddress64Tags,            /* 0x0A, ACPI_RESOURCE_NAME_QWORD_ADDRESS_SPACE */
 378     AcpiDmExtendedAddressTags,      /* 0x0B, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS_SPACE */
 379     NULL,                           /* 0x0C, ACPI_RESOURCE_NAME_GPIO - Use Subtype table below */
 380     NULL,                           /* 0x0D, Reserved */
 381     NULL                            /* 0x0E, ACPI_RESOURCE_NAME_SERIAL_BUS - Use Subtype table below */
 382 };
 383
 384 /* GPIO Subtypes */
 385
 386 static const ACPI_RESOURCE_TAG      *AcpiGbl_GpioResourceTags[] =
 387 {
 388     AcpiDmGpioIntTags,              /* 0x00 Interrupt Connection */
 389     AcpiDmGpioIoTags                /* 0x01 I/O Connection */
 390 };
 391
 392 /* Serial Bus Subtypes */
 393
 394 static const ACPI_RESOURCE_TAG      *AcpiGbl_SerialResourceTags[] =
 395 {
 396     NULL,                           /* 0x00 Reserved */
 397     AcpiDmI2cSerialBusTags,         /* 0x01 I2C SerialBus */
 398     AcpiDmSpiSerialBusTags,         /* 0x02 SPI SerialBus */
 399     AcpiDmUartSerialBusTags         /* 0x03 UART SerialBus */
 400 };
 401
 402 /*
 403  * Globals used to generate unique resource descriptor names. We use names that
 404  * start with underscore and a prefix letter that is not used by other ACPI
 405  * reserved names. To this, we append hex 0x00 through 0xFF. These 5 prefixes
 406  * allow for 5*256 = 1280 unique names, probably sufficient for any single ASL
 407  * file. If this becomes too small, we can use alpha+numerals for a total
 408  * of 5*36*36 = 6480.
 409  */
 410 #define ACPI_NUM_RES_PREFIX     5
 411
 412 static UINT32                   AcpiGbl_NextResourceId = 0;
 413 static UINT8                    AcpiGbl_NextPrefix = 0;
 414 static char                     AcpiGbl_Prefix[ACPI_NUM_RES_PREFIX] =
 415                                     {'Y','Z','J','K','X'};
 416
 417
 418 /*******************************************************************************
 419  *
 420  * FUNCTION:    AcpiDmCheckResourceReference
 421  *
 422  * PARAMETERS:  Op                  - Parse Op for the AML opcode
 423  *              WalkState           - Current walk state (with valid scope)
 424  *
 425  * RETURN:      None
 426  *
 427  * DESCRIPTION: Convert a reference to a resource descriptor to a symbolic
 428  *              reference if possible
 429  *
 430  * NOTE:        Bit index is used to transparently handle both resource bit
 431  *              fields and byte fields.
 432  *
 433  ******************************************************************************/
 434
 435 void
 436 AcpiDmCheckResourceReference (
 437     ACPI_PARSE_OBJECT       *Op,
 438     ACPI_WALK_STATE         *WalkState)
 439 {
 440     ACPI_STATUS             Status;
 441     ACPI_PARSE_OBJECT       *BufferNameOp;
 442     ACPI_PARSE_OBJECT       *IndexOp;
 443     ACPI_NAMESPACE_NODE     *BufferNode;
 444     ACPI_NAMESPACE_NODE     *ResourceNode;
 445     const ACPI_OPCODE_INFO  *OpInfo;
 446     UINT32                  BitIndex;
 447
 448
 449     /* We are only interested in the CreateXxxxField opcodes */
 450
 451     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 452     if (OpInfo->Type != AML_TYPE_CREATE_FIELD)
 453     {
 454         return;
 455     }
 456
 457     /* Get the buffer term operand */
 458
 459     BufferNameOp = AcpiPsGetDepthNext (NULL, Op);
 460
 461     /* Must be a named buffer, not an arg or local or method call */
 462
 463     if (BufferNameOp->Common.AmlOpcode != AML_INT_NAMEPATH_OP)
 464     {
 465         return;
 466     }
 467
 468     /* Get the Index term, must be an integer constant to convert */
 469
 470     IndexOp = BufferNameOp->Common.Next;
 471
 472     /* Major cheat: The Node field is also used for the Tag ptr. Clear it now */
 473
 474     IndexOp->Common.Node = NULL;
 475
 476     OpInfo = AcpiPsGetOpcodeInfo (IndexOp->Common.AmlOpcode);
 477     if (OpInfo->ObjectType != ACPI_TYPE_INTEGER)
 478     {
 479         return;
 480     }
 481
 482     /* Get the bit offset of the descriptor within the buffer */
 483
 484     if ((Op->Common.AmlOpcode == AML_CREATE_BIT_FIELD_OP) ||
 485         (Op->Common.AmlOpcode == AML_CREATE_FIELD_OP))
 486     {
 487         /* Index operand is a bit offset */
 488
 489         BitIndex = (UINT32) IndexOp->Common.Value.Integer;
 490     }
 491     else
 492     {
 493         /* Index operand is a byte offset, convert to bits */
 494
 495         BitIndex = (UINT32) ACPI_MUL_8 (IndexOp->Common.Value.Integer);
 496     }
 497
 498     /* Lookup the buffer in the namespace */
 499
 500     Status = AcpiNsLookup (WalkState->ScopeInfo,
 501                 BufferNameOp->Common.Value.String, ACPI_TYPE_BUFFER,
 502                 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState,
 503                 &BufferNode);
 504     if (ACPI_FAILURE (Status))
 505     {
 506         return;
 507     }
 508
 509     /* Validate object type, we must have a buffer */
 510
 511     if (BufferNode->Type != ACPI_TYPE_BUFFER)
 512     {
 513         return;
 514     }
 515
 516     /* Find the resource descriptor node corresponding to the index */
 517
 518     ResourceNode = AcpiDmGetResourceNode (BufferNode, BitIndex);
 519     if (!ResourceNode)
 520     {
 521         return;
 522     }
 523
 524     /* Translate the Index to a resource tag pathname */
 525
 526     AcpiGetTagPathname (IndexOp, BufferNode, ResourceNode, BitIndex);
 527 }
 528
 529
 530 /*******************************************************************************
 531  *
 532  * FUNCTION:    AcpiDmGetResourceNode
 533  *
 534  * PARAMETERS:  BufferNode          - Node for the parent buffer
 535  *              BitIndex            - Index into the resource descriptor
 536  *
 537  * RETURN:      Namespace node for the resource descriptor. NULL if not found
 538  *
 539  * DESCRIPTION: Find a resource descriptor that corresponds to the bit index
 540  *
 541  ******************************************************************************/
 542
 543 static ACPI_NAMESPACE_NODE *
 544 AcpiDmGetResourceNode (
 545     ACPI_NAMESPACE_NODE     *BufferNode,
 546     UINT32                  BitIndex)
 547 {
 548     ACPI_NAMESPACE_NODE     *Node;
 549     UINT32                  ByteIndex = ACPI_DIV_8 (BitIndex);
 550
 551
 552     /*
 553      * Child list contains an entry for each resource descriptor. Find
 554      * the descriptor that corresponds to the Index.
 555      *
 556      * If there are no children, this is not a resource template
 557      */
 558     Node = BufferNode->Child;
 559     while (Node)
 560     {
 561         /*
 562          * Check if the Index falls within this resource.
 563          *
 564          * Value contains the resource offset, Object contains the resource
 565          * length (both in bytes)
 566          */
 567         if ((ByteIndex >= Node->Value) &&
 568             (ByteIndex < (Node->Value + Node->Length)))
 569         {
 570             return (Node);
 571         }
 572
 573         Node = Node->Peer;
 574     }
 575
 576     return (NULL);
 577 }
 578
 579
 580 /*******************************************************************************
 581  *
 582  * FUNCTION:    AcpiGetTagPathname
 583  *
 584  * PARAMETERS:  BufferNode          - Node for the parent buffer
 585  *              ResourceNode        - Node for a resource descriptor
 586  *              BitIndex            - Index into the resource descriptor
 587  *
 588  * RETURN:      Full pathname for a resource tag. NULL if no match.
 589  *              Path is returned in AML (packed) format.
 590  *
 591  * DESCRIPTION: Convert a BitIndex into a symbolic resource tag (full pathname)
 592  *
 593  ******************************************************************************/
 594
 595 static char *
 596 AcpiGetTagPathname (
 597     ACPI_PARSE_OBJECT       *IndexOp,
 598     ACPI_NAMESPACE_NODE     *BufferNode,
 599     ACPI_NAMESPACE_NODE     *ResourceNode,
 600     UINT32                  BitIndex)
 601 {
 602     ACPI_STATUS             Status;
 603     UINT32                  ResourceBitIndex;
 604     UINT8                   ResourceTableIndex;
 605     ACPI_SIZE               RequiredSize;
 606     char                    *Pathname;
 607     AML_RESOURCE            *Aml;
 608     ACPI_PARSE_OBJECT       *Op;
 609     char                    *InternalPath;
 610     char                    *Tag;
 611
 612
 613     /* Get the Op that contains the actual buffer data */
 614
 615     Op = BufferNode->Op->Common.Value.Arg;
 616     Op = Op->Common.Next;
 617     if (!Op)
 618     {
 619         return (NULL);
 620     }
 621
 622     /* Get the individual resource descriptor and validate it */
 623
 624     Aml = ACPI_CAST_PTR (AML_RESOURCE,
 625             &Op->Named.Data[ResourceNode->Value]);
 626
 627     Status = AcpiUtValidateResource (NULL, Aml, &ResourceTableIndex);
 628     if (ACPI_FAILURE (Status))
 629     {
 630         return (NULL);
 631     }
 632
 633     /* Get offset into this descriptor (from offset into entire buffer) */
 634
 635     ResourceBitIndex = BitIndex - ACPI_MUL_8 (ResourceNode->Value);
 636
 637     /* Get the tag associated with this resource descriptor and offset */
 638
 639     Tag = AcpiDmGetResourceTag (ResourceBitIndex, Aml, ResourceTableIndex);
 640     if (!Tag)
 641     {
 642         return (NULL);
 643     }
 644
 645     /*
 646      * Now that we know that we have a reference that can be converted to a
 647      * symbol, change the name of the resource to a unique name.
 648      */
 649     AcpiDmUpdateResourceName (ResourceNode);
 650
 651     /* Get the full pathname to the parent buffer */
 652
 653     RequiredSize = AcpiNsGetPathnameLength (BufferNode);
 654     if (!RequiredSize)
 655     {
 656         return (NULL);
 657     }
 658
 659     Pathname = ACPI_ALLOCATE_ZEROED (RequiredSize + ACPI_PATH_SEGMENT_LENGTH);
 660     if (!Pathname)
 661     {
 662         return (NULL);
 663     }
 664
 665     Status = AcpiNsBuildExternalPath (BufferNode, RequiredSize, Pathname);
 666     if (ACPI_FAILURE (Status))
 667     {
 668         ACPI_FREE (Pathname);
 669         return (NULL);
 670     }
 671
 672     /*
 673      * Create the full path to the resource and tag by: remove the buffer name,
 674      * append the resource descriptor name, append a dot, append the tag name.
 675      *
 676      * TBD: Always using the full path is a bit brute force, the path can be
 677      * often be optimized with carats (if the original buffer namepath is a
 678      * single nameseg). This doesn't really matter, because these paths do not
 679      * end up in the final compiled AML, it's just an appearance issue for the
 680      * disassembled code.
 681      */
 682     Pathname[ACPI_STRLEN (Pathname) - ACPI_NAME_SIZE] = 0;
 683     ACPI_STRNCAT (Pathname, ResourceNode->Name.Ascii, ACPI_NAME_SIZE);
 684     ACPI_STRCAT (Pathname, ".");
 685     ACPI_STRNCAT (Pathname, Tag, ACPI_NAME_SIZE);
 686
 687     /* Internalize the namepath to AML format */
 688
 689     AcpiNsInternalizeName (Pathname, &InternalPath);
 690     ACPI_FREE (Pathname);
 691
 692     /* Update the Op with the symbol */
 693
 694     AcpiPsInitOp (IndexOp, AML_INT_NAMEPATH_OP);
 695     IndexOp->Common.Value.String = InternalPath;
 696
 697     /* We will need the tag later. Cheat by putting it in the Node field */
 698
 699     IndexOp->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Tag);
 700     return (InternalPath);
 701 }
 702
 703
 704 /*******************************************************************************
 705  *
 706  * FUNCTION:    AcpiDmUpdateResourceName
 707  *
 708  * PARAMETERS:  ResourceNode        - Node for a resource descriptor
 709  *
 710  * RETURN:      Stores new name in the ResourceNode
 711  *
 712  * DESCRIPTION: Create a new, unique name for a resource descriptor. Used by
 713  *              both the disassembly of the descriptor itself and any symbolic
 714  *              references to the descriptor. Ignored if a unique name has
 715  *              already been assigned to the resource.
 716  *
 717  * NOTE: Single threaded, suitable for applications only!
 718  *
 719  ******************************************************************************/
 720
 721 static void
 722 AcpiDmUpdateResourceName (
 723     ACPI_NAMESPACE_NODE     *ResourceNode)
 724 {
 725     char                    Name[ACPI_NAME_SIZE];
 726
 727
 728     /* Ignore if a unique name has already been assigned */
 729
 730     if (ResourceNode->Name.Integer != ACPI_DEFAULT_RESNAME)
 731     {
 732         return;
 733     }
 734
 735     /* Generate a new ACPI name for the descriptor */
 736
 737     Name[0] = '_';
 738     Name[1] = AcpiGbl_Prefix[AcpiGbl_NextPrefix];
 739     Name[2] = AcpiUtHexToAsciiChar ((UINT64) AcpiGbl_NextResourceId, 4);
 740     Name[3] = AcpiUtHexToAsciiChar ((UINT64) AcpiGbl_NextResourceId, 0);
 741
 742     /* Update globals for next name */
 743
 744     AcpiGbl_NextResourceId++;
 745     if (AcpiGbl_NextResourceId >= 256)
 746     {
 747         AcpiGbl_NextResourceId = 0;
 748         AcpiGbl_NextPrefix++;
 749         if (AcpiGbl_NextPrefix > ACPI_NUM_RES_PREFIX)
 750         {
 751             AcpiGbl_NextPrefix = 0;
 752         }
 753     }
 754
 755     /* Change the resource descriptor name */
 756
 757     ResourceNode->Name.Integer = *ACPI_CAST_PTR (UINT32, &Name[0]);
 758 }
 759
 760
 761 /*******************************************************************************
 762  *
 763  * FUNCTION:    AcpiDmGetResourceTag
 764  *
 765  * PARAMETERS:  BitIndex            - Index into the resource descriptor
 766  *              Resource            - Pointer to the raw resource data
 767  *              ResourceIndex       - Index correspoinding to the resource type
 768  *
 769  * RETURN:      Pointer to the resource tag (ACPI_NAME). NULL if no match.
 770  *
 771  * DESCRIPTION: Convert a BitIndex into a symbolic resource tag.
 772  *
 773  * Note: ResourceIndex should be previously validated and guaranteed to ve
 774  *       valid.
 775  *
 776  ******************************************************************************/
 777
 778 static char *
 779 AcpiDmGetResourceTag (
 780     UINT32                  BitIndex,
 781     AML_RESOURCE            *Resource,
 782     UINT8                   ResourceIndex)
 783 {
 784     const ACPI_RESOURCE_TAG *TagList;
 785     char                    *Tag = NULL;
 786
 787
 788     /* Get the tag list for this resource descriptor type */
 789
 790     TagList = AcpiGbl_ResourceTags[ResourceIndex];
 791
 792     /*
 793      * Handle descriptors that have multiple subtypes
 794      */
 795     switch (Resource->DescriptorType)
 796     {
 797     case ACPI_RESOURCE_NAME_ADDRESS16:
 798     case ACPI_RESOURCE_NAME_ADDRESS32:
 799     case ACPI_RESOURCE_NAME_ADDRESS64:
 800     case ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64:
 801         /*
 802          * Subtype differentiation is the flags.
 803          * Kindof brute force, but just blindly search for an index match
 804          */
 805         if (Resource->Address.ResourceType == ACPI_ADDRESS_TYPE_MEMORY_RANGE)
 806         {
 807             Tag = AcpiDmSearchTagList (BitIndex, AcpiDmMemoryFlagTags);
 808         }
 809         else if (Resource->Address.ResourceType == ACPI_ADDRESS_TYPE_IO_RANGE)
 810         {
 811             Tag = AcpiDmSearchTagList (BitIndex, AcpiDmIoFlagTags);
 812         }
 813
 814         /* If we found a match, all done. Else, drop to normal search below */
 815
 816         if (Tag)
 817         {
 818             return (Tag);
 819         }
 820         break;
 821
 822     case ACPI_RESOURCE_NAME_GPIO:
 823
 824         /* GPIO connection has 2 subtypes: Interrupt and I/O */
 825
 826         if (Resource->Gpio.ConnectionType > AML_RESOURCE_MAX_GPIOTYPE)
 827         {
 828             return (NULL);
 829         }
 830
 831         TagList = AcpiGbl_GpioResourceTags[Resource->Gpio.ConnectionType];
 832         break;
 833
 834     case ACPI_RESOURCE_NAME_SERIAL_BUS:
 835
 836         /* SerialBus has 3 subtypes: I2C, SPI, and UART */
 837
 838         if ((Resource->CommonSerialBus.Type == 0) ||
 839             (Resource->CommonSerialBus.Type > AML_RESOURCE_MAX_SERIALBUSTYPE))
 840         {
 841             return (NULL);
 842         }
 843
 844         TagList = AcpiGbl_SerialResourceTags[Resource->CommonSerialBus.Type];
 845         break;
 846
 847     default:
 848
 849         break;
 850     }
 851
 852     /* Search for a match against the BitIndex */
 853
 854     if (TagList)
 855     {
 856         Tag = AcpiDmSearchTagList (BitIndex, TagList);
 857     }
 858
 859     return (Tag);
 860 }
 861
 862
 863 /*******************************************************************************
 864  *
 865  * FUNCTION:    AcpiDmSearchTagList
 866  *
 867  * PARAMETERS:  BitIndex            - Index into the resource descriptor
 868  *              TagList             - List to search
 869  *
 870  * RETURN:      Pointer to a tag (ACPI_NAME). NULL if no match found.
 871  *
 872  * DESCRIPTION: Search a tag list for a match to the input BitIndex. Matches
 873  *              a fixed offset to a symbolic resource tag name.
 874  *
 875  ******************************************************************************/
 876
 877 static char *
 878 AcpiDmSearchTagList (
 879     UINT32                  BitIndex,
 880     const ACPI_RESOURCE_TAG *TagList)
 881 {
 882
 883     /*
 884      * Walk the null-terminated tag list to find a matching bit offset.
 885      * We are looking for an exact match.
 886      */
 887     for ( ; TagList->Tag; TagList++)
 888     {
 889         if (BitIndex == TagList->BitIndex)
 890         {
 891             return (TagList->Tag);
 892         }
 893     }
 894
 895     /* A matching offset was not found */
 896
 897     return (NULL);
 898 }
 899
 900
 901 /*******************************************************************************
 902  *
 903  * FUNCTION:    AcpiDmFindResources
 904  *
 905  * PARAMETERS:  Root                - Root of the parse tree
 906  *
 907  * RETURN:      None
 908  *
 909  * DESCRIPTION: Add all ResourceTemplate declarations to the namespace. Each
 910  *              resource descriptor in each template is given a node -- used
 911  *              for later conversion of resource references to symbolic refs.
 912  *
 913  ******************************************************************************/
 914
 915 void
 916 AcpiDmFindResources (
 917     ACPI_PARSE_OBJECT       *Root)
 918 {
 919     ACPI_PARSE_OBJECT       *Op = Root;
 920     ACPI_PARSE_OBJECT       *Parent;
 921
 922
 923     /* Walk the entire parse tree */
 924
 925     while (Op)
 926     {
 927         /* We are interested in Buffer() declarations */
 928
 929         if (Op->Common.AmlOpcode == AML_BUFFER_OP)
 930         {
 931             /* And only declarations of the form Name (XXXX, Buffer()... ) */
 932
 933             Parent = Op->Common.Parent;
 934             if (Parent->Common.AmlOpcode == AML_NAME_OP)
 935             {
 936                 /*
 937                  * If the buffer is a resource template, add the individual
 938                  * resource descriptors to the namespace, as children of the
 939                  * buffer node.
 940                  */
 941                 if (ACPI_SUCCESS (AcpiDmIsResourceTemplate (NULL, Op)))
 942                 {
 943                     Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE;
 944                     AcpiDmAddResourcesToNamespace (Parent->Common.Node, Op);
 945                 }
 946             }
 947         }
 948
 949         Op = AcpiPsGetDepthNext (Root, Op);
 950     }
 951 }
 952
 953
 954 /*******************************************************************************
 955  *
 956  * FUNCTION:    AcpiDmAddResourcesToNamespace
 957  *
 958  * PARAMETERS:  BufferNode          - Node for the parent buffer
 959  *              Op                  - Parse op for the buffer
 960  *
 961  * RETURN:      None
 962  *
 963  * DESCRIPTION: Add an entire resource template to the namespace. Each
 964  *              resource descriptor is added as a namespace node.
 965  *
 966  ******************************************************************************/
 967
 968 static void
 969 AcpiDmAddResourcesToNamespace (
 970     ACPI_NAMESPACE_NODE     *BufferNode,
 971     ACPI_PARSE_OBJECT       *Op)
 972 {
 973     ACPI_PARSE_OBJECT       *NextOp;
 974
 975
 976     /* Get to the ByteData list */
 977
 978     NextOp = Op->Common.Value.Arg;
 979     NextOp = NextOp->Common.Next;
 980     if (!NextOp)
 981     {
 982         return;
 983     }
 984
 985     /* Set Node and Op to point to each other */
 986
 987     BufferNode->Op = Op;
 988     Op->Common.Node = BufferNode;
 989
 990     /*
 991      * Insert each resource into the namespace
 992      * NextOp contains the Aml pointer and the Aml length
 993      */
 994     AcpiUtWalkAmlResources (NULL, (UINT8 *) NextOp->Named.Data,
 995         (ACPI_SIZE) NextOp->Common.Value.Integer,
 996         AcpiDmAddResourceToNamespace, (void **) BufferNode);
 997 }
 998
 999
1000 /*******************************************************************************
1001  *
1002  * FUNCTION:    AcpiDmAddResourceToNamespace
1003  *
1004  * PARAMETERS:  ACPI_WALK_AML_CALLBACK
1005  *              BufferNode              - Node for the parent buffer
1006  *
1007  * RETURN:      Status
1008  *
1009  * DESCRIPTION: Add one resource descriptor to the namespace as a child of the
1010  *              parent buffer. The same name is used for each descriptor. This
1011  *              is changed later to a unique name if the resource is actually
1012  *              referenced by an AML operator.
1013  *
1014  ******************************************************************************/
1015
1016 static ACPI_STATUS
1017 AcpiDmAddResourceToNamespace (
1018     UINT8                   *Aml,
1019     UINT32                  Length,
1020     UINT32                  Offset,
1021     UINT8                   ResourceIndex,
1022     void                    **Context)
1023 {
1024     ACPI_STATUS             Status;
1025     ACPI_GENERIC_STATE      ScopeInfo;
1026     ACPI_NAMESPACE_NODE     *Node;
1027
1028
1029     /* TBD: Don't need to add descriptors that have no tags defined? */
1030
1031     /* Add the resource to the namespace, as child of the buffer */
1032
1033     ScopeInfo.Scope.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Context);
1034     Status = AcpiNsLookup (&ScopeInfo, "_TMP", ACPI_TYPE_LOCAL_RESOURCE,
1035                 ACPI_IMODE_LOAD_PASS2,
1036                 ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE | ACPI_NS_PREFIX_IS_SCOPE,
1037                 NULL, &Node);
1038     if (ACPI_FAILURE (Status))
1039     {
1040         return (AE_OK);
1041     }
1042
1043     /* Set the name to the default, changed later if resource is referenced */
1044
1045     Node->Name.Integer = ACPI_DEFAULT_RESNAME;
1046
1047     /* Save the offset of the descriptor (within the original buffer) */
1048
1049     Node->Value = Offset;
1050     Node->Length = Length;
1051     return (AE_OK);
1052 }