drivers/acpi/interpreter/amnames.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: amnames - interpreter/scanner name load/execute
   5  *              $Revision: 71 $
   6  *
   7  *****************************************************************************/
   8
   9 /*
  10  *  Copyright (C) 2000 R. Byron Moore
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27
  28 #include "acpi.h"
  29 #include "acinterp.h"
  30 #include "amlcode.h"
  31 #include "acnamesp.h"
  32
  33 #define _COMPONENT          INTERPRETER
  34          MODULE_NAME         ("amnames")
  35
  36
  37 /* AML Package Length encodings */
  38
  39 #define ACPI_AML_PACKAGE_TYPE1   0x40
  40 #define ACPI_AML_PACKAGE_TYPE2   0x4000
  41 #define ACPI_AML_PACKAGE_TYPE3   0x400000
  42 #define ACPI_AML_PACKAGE_TYPE4   0x40000000
  43
  44
  45 /*******************************************************************************
  46  *
  47  * FUNCTION:    Acpi_aml_allocate_name_string
  48  *
  49  * PARAMETERS:  Prefix_count        - Count of parent levels. Special cases:
  50  *                                    (-1) = root,  0 = none
  51  *              Num_name_segs       - count of 4-character name segments
  52  *
  53  * RETURN:      A pointer to the allocated string segment.  This segment must
  54  *              be deleted by the caller.
  55  *
  56  * DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name
  57  *              string is long enough, and set up prefix if any.
  58  *
  59  ******************************************************************************/
  60
  61 NATIVE_CHAR *
  62 acpi_aml_allocate_name_string (
  63         u32                     prefix_count,
  64         u32                     num_name_segs)
  65 {
  66         NATIVE_CHAR             *temp_ptr;
  67         NATIVE_CHAR             *name_string;
  68         u32                      size_needed;
  69
  70
  71         /*
  72          * Allow room for all \ and ^ prefixes, all segments, and a Multi_name_prefix.
  73          * Also, one byte for the null terminator.
  74          * This may actually be somewhat longer than needed.
  75          */
  76
  77         if (prefix_count == (u32) -1) {
  78                 /* Special case for root */
  79
  80                 size_needed = 1 + (ACPI_NAME_SIZE * num_name_segs) + 2 + 1;
  81         }
  82         else {
  83                 size_needed = prefix_count + (ACPI_NAME_SIZE * num_name_segs) + 2 + 1;
  84         }
  85
  86         /*
  87          * Allocate a buffer for the name.
  88          * This buffer must be deleted by the caller!
  89          */
  90
  91         name_string = acpi_cm_allocate (size_needed);
  92         if (!name_string) {
  93                 REPORT_ERROR (("Aml_allocate_name_string: name allocation failure\n"));
  94                 return (NULL);
  95         }
  96
  97         temp_ptr = name_string;
  98
  99         /* Set up Root or Parent prefixes if needed */
 100
 101         if (prefix_count == (u32) -1) {
 102                 *temp_ptr++ = AML_ROOT_PREFIX;
 103         }
 104
 105         else {
 106                 while (prefix_count--) {
 107                         *temp_ptr++ = AML_PARENT_PREFIX;
 108                 }
 109         }
 110
 111
 112         /* Set up Dual or Multi prefixes if needed */
 113
 114         if (num_name_segs > 2) {
 115                 /* Set up multi prefixes   */
 116
 117                 *temp_ptr++ = AML_MULTI_NAME_PREFIX_OP;
 118                 *temp_ptr++ = (char) num_name_segs;
 119         }
 120
 121         else if (2 == num_name_segs) {
 122                 /* Set up dual prefixes */
 123
 124                 *temp_ptr++ = AML_DUAL_NAME_PREFIX;
 125         }
 126
 127         /*
 128          * Terminate string following prefixes. Acpi_aml_exec_name_segment() will
 129          * append the segment(s)
 130          */
 131
 132         *temp_ptr = 0;
 133
 134         return (name_string);
 135 }
 136
 137 /*******************************************************************************
 138  *
 139  * FUNCTION:    Acpi_aml_exec_name_segment
 140  *
 141  * PARAMETERS:  Interpreter_mode    - Current running mode (load1/Load2/Exec)
 142  *
 143  * RETURN:      Status
 144  *
 145  * DESCRIPTION: Execute a name segment (4 bytes)
 146  *
 147  ******************************************************************************/
 148
 149 ACPI_STATUS
 150 acpi_aml_exec_name_segment (
 151         u8                      **in_aml_address,
 152         NATIVE_CHAR             *name_string)
 153 {
 154         u8                      *aml_address = *in_aml_address;
 155         ACPI_STATUS             status = AE_OK;
 156         u32                     index;
 157         NATIVE_CHAR             char_buf[5];
 158
 159
 160         /*
 161          * If first character is a digit, then we know that we aren't looking at a
 162          * valid name segment
 163          */
 164
 165         char_buf[0] = *aml_address;
 166
 167         if ('0' <= char_buf[0] && char_buf[0] <= '9') {
 168                 return (AE_CTRL_PENDING);
 169         }
 170
 171         for (index = 4;
 172                 (index > 0) && (acpi_cm_valid_acpi_character (*aml_address));
 173                 --index)
 174         {
 175                 char_buf[4 - index] = *aml_address++;
 176         }
 177
 178
 179         /* Valid name segment  */
 180
 181         if (0 == index) {
 182                 /* Found 4 valid characters */
 183
 184                 char_buf[4] = '\0';
 185
 186                 if (name_string) {
 187                         STRCAT (name_string, char_buf);
 188                 }
 189
 190         }
 191
 192         else if (4 == index) {
 193                 /*
 194                  * First character was not a valid name character,
 195                  * so we are looking at something other than a name.
 196                  */
 197                 status = AE_CTRL_PENDING;
 198         }
 199
 200         else {
 201                 /* Segment started with one or more valid characters, but fewer than 4 */
 202
 203                 status = AE_AML_BAD_NAME;
 204         }
 205
 206         *in_aml_address = aml_address;
 207
 208         return (status);
 209 }
 210
 211
 212 /*******************************************************************************
 213  *
 214  * FUNCTION:    Acpi_aml_get_name_string
 215  *
 216  * PARAMETERS:  Data_type           - Data type to be associated with this name
 217  *
 218  * RETURN:      Status
 219  *
 220  * DESCRIPTION: Get a name, including any prefixes.
 221  *
 222  ******************************************************************************/
 223
 224
 225 ACPI_STATUS
 226 acpi_aml_get_name_string (
 227         OBJECT_TYPE_INTERNAL    data_type,
 228         u8                      *in_aml_address,
 229         NATIVE_CHAR             **out_name_string,
 230         u32                     *out_name_length)
 231 {
 232         ACPI_STATUS             status = AE_OK;
 233         u8                      *aml_address = in_aml_address;
 234         NATIVE_CHAR             *name_string = NULL;
 235         u32                     num_segments;
 236         u32                     prefix_count = 0;
 237         u8                      prefix = 0;
 238         u8                      has_prefix = FALSE;
 239
 240
 241         if (INTERNAL_TYPE_DEF_FIELD == data_type  ||
 242                 INTERNAL_TYPE_BANK_FIELD == data_type ||
 243                 INTERNAL_TYPE_INDEX_FIELD == data_type)
 244         {
 245                 /* Disallow prefixes for types associated with field names */
 246
 247                 name_string = acpi_aml_allocate_name_string (0, 1);
 248                 if (!name_string) {
 249                         status = AE_NO_MEMORY;
 250                 }
 251                 else {
 252                         status = acpi_aml_exec_name_segment (&aml_address, name_string);
 253                 }
 254         }
 255
 256         else {
 257                 /*
 258                  * Data_type is not a field name.
 259                  * Examine first character of name for root or parent prefix operators
 260                  */
 261
 262                 switch (*aml_address)
 263                 {
 264
 265                 case AML_ROOT_PREFIX:
 266
 267                         prefix = *aml_address++;
 268                         /*
 269                          * Remember that we have a Root_prefix --
 270                          * see comment in Acpi_aml_allocate_name_string()
 271                          */
 272                         prefix_count = (u32) -1;
 273                         has_prefix = TRUE;
 274                         break;
 275
 276
 277                 case AML_PARENT_PREFIX:
 278
 279                         /* Increment past possibly multiple parent prefixes */
 280
 281                         do
 282                         {
 283                                 prefix = *aml_address++;
 284                                 ++prefix_count;
 285
 286                         } while (*aml_address == AML_PARENT_PREFIX);
 287                         has_prefix = TRUE;
 288                         break;
 289
 290
 291                 default:
 292
 293                         break;
 294                 }
 295
 296
 297                 /* Examine first character of name for name segment prefix operator */
 298
 299                 switch (*aml_address)
 300                 {
 301
 302                 case AML_DUAL_NAME_PREFIX:
 303
 304                         prefix = *aml_address++;
 305                         name_string = acpi_aml_allocate_name_string (prefix_count, 2);
 306                         if (!name_string) {
 307                                 status = AE_NO_MEMORY;
 308                                 break;
 309                         }
 310
 311                         /* Indicate that we processed a prefix */
 312                         has_prefix = TRUE;
 313
 314                         status = acpi_aml_exec_name_segment (&aml_address, name_string);
 315                         if (ACPI_SUCCESS (status)) {
 316                                 status = acpi_aml_exec_name_segment (&aml_address, name_string);
 317                         }
 318                         break;
 319
 320
 321                 case AML_MULTI_NAME_PREFIX_OP:
 322
 323                         prefix = *aml_address++;
 324                         /* Fetch count of segments remaining in name path */
 325
 326                         num_segments = *aml_address++;
 327
 328                         name_string = acpi_aml_allocate_name_string (prefix_count, num_segments);
 329                         if (!name_string) {
 330                                 status = AE_NO_MEMORY;
 331                                 break;
 332                         }
 333
 334                         /* Indicate that we processed a prefix */
 335                         has_prefix = TRUE;
 336
 337                         while (num_segments &&
 338                                         (status = acpi_aml_exec_name_segment (&aml_address, name_string)) == AE_OK)
 339                         {
 340                                 --num_segments;
 341                         }
 342
 343                         break;
 344
 345
 346                 case 0:
 347
 348                         /* Null_name valid as of 8-12-98 ASL/AML Grammar Update */
 349
 350
 351                         /* Consume the NULL byte */
 352
 353                         aml_address++;
 354                         name_string = acpi_aml_allocate_name_string (prefix_count, 0);
 355                         if (!name_string) {
 356                                 status = AE_NO_MEMORY;
 357                                 break;
 358                         }
 359
 360                         break;
 361
 362
 363                 default:
 364
 365                         /* Name segment string */
 366
 367                         name_string = acpi_aml_allocate_name_string (prefix_count, 1);
 368                         if (!name_string) {
 369                                 status = AE_NO_MEMORY;
 370                                 break;
 371                         }
 372
 373                         status = acpi_aml_exec_name_segment (&aml_address, name_string);
 374                         break;
 375
 376                 }   /* Switch (Peek_op ())   */
 377         }
 378
 379
 380         if (AE_CTRL_PENDING == status && has_prefix) {
 381                 /* Ran out of segments after processing a prefix */
 382
 383                 REPORT_ERROR (
 384                         ("Aml_do_name: Malformed Name at %p\n", name_string));
 385                 status = AE_AML_BAD_NAME;
 386         }
 387
 388
 389         *out_name_string = name_string;
 390         *out_name_length = (u32) (aml_address - in_aml_address);
 391
 392         return (status);
 393 }
 394
 395