drivers/acpi/acpica/utpredef.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utpredef - support functions for predefined names
   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 #include <acpi/acpi.h>
  45 #include "accommon.h"
  46 #include "acpredef.h"
  47
  48 #define _COMPONENT          ACPI_UTILITIES
  49 ACPI_MODULE_NAME("utpredef")
  50
  51 /*
  52  * Names for the types that can be returned by the predefined objects.
  53  * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
  54  */
  55 static const char *ut_rtype_names[] = {
  56         "/Integer",
  57         "/String",
  58         "/Buffer",
  59         "/Package",
  60         "/Reference",
  61 };
  62
  63 /*******************************************************************************
  64  *
  65  * FUNCTION:    acpi_ut_get_next_predefined_method
  66  *
  67  * PARAMETERS:  this_name           - Entry in the predefined method/name table
  68  *
  69  * RETURN:      Pointer to next entry in predefined table.
  70  *
  71  * DESCRIPTION: Get the next entry in the predefine method table. Handles the
  72  *              cases where a package info entry follows a method name that
  73  *              returns a package.
  74  *
  75  ******************************************************************************/
  76
  77 const union acpi_predefined_info *acpi_ut_get_next_predefined_method(const union
  78                                                                      acpi_predefined_info
  79                                                                      *this_name)
  80 {
  81
  82         /*
  83          * Skip next entry in the table if this name returns a Package
  84          * (next entry contains the package info)
  85          */
  86         if ((this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) &&
  87             (this_name->info.expected_btypes != ACPI_RTYPE_ALL)) {
  88                 this_name++;
  89         }
  90
  91         this_name++;
  92         return (this_name);
  93 }
  94
  95 /*******************************************************************************
  96  *
  97  * FUNCTION:    acpi_ut_match_predefined_method
  98  *
  99  * PARAMETERS:  name                - Name to find
 100  *
 101  * RETURN:      Pointer to entry in predefined table. NULL indicates not found.
 102  *
 103  * DESCRIPTION: Check an object name against the predefined object list.
 104  *
 105  ******************************************************************************/
 106
 107 const union acpi_predefined_info *acpi_ut_match_predefined_method(char *name)
 108 {
 109         const union acpi_predefined_info *this_name;
 110
 111         /* Quick check for a predefined name, first character must be underscore */
 112
 113         if (name[0] != '_') {
 114                 return (NULL);
 115         }
 116
 117         /* Search info table for a predefined method/object name */
 118
 119         this_name = acpi_gbl_predefined_methods;
 120         while (this_name->info.name[0]) {
 121                 if (ACPI_COMPARE_NAME(name, this_name->info.name)) {
 122                         return (this_name);
 123                 }
 124
 125                 this_name = acpi_ut_get_next_predefined_method(this_name);
 126         }
 127
 128         return (NULL);          /* Not found */
 129 }
 130
 131 /*******************************************************************************
 132  *
 133  * FUNCTION:    acpi_ut_get_expected_return_types
 134  *
 135  * PARAMETERS:  buffer              - Where the formatted string is returned
 136  *              expected_Btypes     - Bitfield of expected data types
 137  *
 138  * RETURN:      Formatted string in Buffer.
 139  *
 140  * DESCRIPTION: Format the expected object types into a printable string.
 141  *
 142  ******************************************************************************/
 143
 144 void acpi_ut_get_expected_return_types(char *buffer, u32 expected_btypes)
 145 {
 146         u32 this_rtype;
 147         u32 i;
 148         u32 j;
 149
 150         j = 1;
 151         buffer[0] = 0;
 152         this_rtype = ACPI_RTYPE_INTEGER;
 153
 154         for (i = 0; i < ACPI_NUM_RTYPES; i++) {
 155
 156                 /* If one of the expected types, concatenate the name of this type */
 157
 158                 if (expected_btypes & this_rtype) {
 159                         ACPI_STRCAT(buffer, &ut_rtype_names[i][j]);
 160                         j = 0;  /* Use name separator from now on */
 161                 }
 162
 163                 this_rtype <<= 1;       /* Next Rtype */
 164         }
 165 }
 166
 167 /*******************************************************************************
 168  *
 169  * The remaining functions are used by iASL and acpi_help only
 170  *
 171  ******************************************************************************/
 172
 173 #if (defined ACPI_ASL_COMPILER || defined ACPI_HELP_APP)
 174 #include <stdio.h>
 175 #include <string.h>
 176
 177 /* Local prototypes */
 178
 179 static u32 acpi_ut_get_argument_types(char *buffer, u16 argument_types);
 180
 181 /* Types that can be returned externally by a predefined name */
 182
 183 static const char *ut_external_type_names[] =   /* Indexed by ACPI_TYPE_* */
 184 {
 185         ", UNSUPPORTED-TYPE",
 186         ", Integer",
 187         ", String",
 188         ", Buffer",
 189         ", Package"
 190 };
 191
 192 /* Bit widths for resource descriptor predefined names */
 193
 194 static const char *ut_resource_type_names[] = {
 195         "/1",
 196         "/2",
 197         "/3",
 198         "/8",
 199         "/16",
 200         "/32",
 201         "/64",
 202         "/variable",
 203 };
 204
 205 /*******************************************************************************
 206  *
 207  * FUNCTION:    acpi_ut_match_resource_name
 208  *
 209  * PARAMETERS:  name                - Name to find
 210  *
 211  * RETURN:      Pointer to entry in the resource table. NULL indicates not
 212  *              found.
 213  *
 214  * DESCRIPTION: Check an object name against the predefined resource
 215  *              descriptor object list.
 216  *
 217  ******************************************************************************/
 218
 219 const union acpi_predefined_info *acpi_ut_match_resource_name(char *name)
 220 {
 221         const union acpi_predefined_info *this_name;
 222
 223         /* Quick check for a predefined name, first character must be underscore */
 224
 225         if (name[0] != '_') {
 226                 return (NULL);
 227         }
 228
 229         /* Search info table for a predefined method/object name */
 230
 231         this_name = acpi_gbl_resource_names;
 232         while (this_name->info.name[0]) {
 233                 if (ACPI_COMPARE_NAME(name, this_name->info.name)) {
 234                         return (this_name);
 235                 }
 236
 237                 this_name++;
 238         }
 239
 240         return (NULL);          /* Not found */
 241 }
 242
 243 /*******************************************************************************
 244  *
 245  * FUNCTION:    acpi_ut_display_predefined_method
 246  *
 247  * PARAMETERS:  buffer              - Scratch buffer for this function
 248  *              this_name           - Entry in the predefined method/name table
 249  *              multi_line          - TRUE if output should be on >1 line
 250  *
 251  * RETURN:      None
 252  *
 253  * DESCRIPTION: Display information about a predefined method. Number and
 254  *              type of the input arguments, and expected type(s) for the
 255  *              return value, if any.
 256  *
 257  ******************************************************************************/
 258
 259 void
 260 acpi_ut_display_predefined_method(char *buffer,
 261                                   const union acpi_predefined_info *this_name,
 262                                   u8 multi_line)
 263 {
 264         u32 arg_count;
 265
 266         /*
 267          * Get the argument count and the string buffer
 268          * containing all argument types
 269          */
 270         arg_count = acpi_ut_get_argument_types(buffer,
 271                                                this_name->info.argument_list);
 272
 273         if (multi_line) {
 274                 printf("      ");
 275         }
 276
 277         printf("%4.4s    Requires %s%u argument%s",
 278                this_name->info.name,
 279                (this_name->info.argument_list & ARG_COUNT_IS_MINIMUM) ?
 280                "(at least) " : "", arg_count, arg_count != 1 ? "s" : "");
 281
 282         /* Display the types for any arguments */
 283
 284         if (arg_count > 0) {
 285                 printf(" (%s)", buffer);
 286         }
 287
 288         if (multi_line) {
 289                 printf("\n    ");
 290         }
 291
 292         /* Get the return value type(s) allowed */
 293
 294         if (this_name->info.expected_btypes) {
 295                 acpi_ut_get_expected_return_types(buffer,
 296                                                   this_name->info.
 297                                                   expected_btypes);
 298                 printf("  Return value types: %s\n", buffer);
 299         } else {
 300                 printf("  No return value\n");
 301         }
 302 }
 303
 304 /*******************************************************************************
 305  *
 306  * FUNCTION:    acpi_ut_get_argument_types
 307  *
 308  * PARAMETERS:  buffer              - Where to return the formatted types
 309  *              argument_types      - Types field for this method
 310  *
 311  * RETURN:      count - the number of arguments required for this method
 312  *
 313  * DESCRIPTION: Format the required data types for this method (Integer,
 314  *              String, Buffer, or Package) and return the required argument
 315  *              count.
 316  *
 317  ******************************************************************************/
 318
 319 static u32 acpi_ut_get_argument_types(char *buffer, u16 argument_types)
 320 {
 321         u16 this_argument_type;
 322         u16 sub_index;
 323         u16 arg_count;
 324         u32 i;
 325
 326         *buffer = 0;
 327         sub_index = 2;
 328
 329         /* First field in the types list is the count of args to follow */
 330
 331         arg_count = (argument_types & METHOD_ARG_MASK);
 332         argument_types >>= METHOD_ARG_BIT_WIDTH;
 333
 334         if (arg_count > METHOD_PREDEF_ARGS_MAX) {
 335                 printf("**** Invalid argument count (%u) "
 336                        "in predefined info structure\n", arg_count);
 337                 return (arg_count);
 338         }
 339
 340         /* Get each argument from the list, convert to ascii, store to buffer */
 341
 342         for (i = 0; i < arg_count; i++) {
 343                 this_argument_type = (argument_types & METHOD_ARG_MASK);
 344                 if (!this_argument_type
 345                     || (this_argument_type > METHOD_MAX_ARG_TYPE)) {
 346                         printf("**** Invalid argument type (%u) "
 347                                "in predefined info structure\n",
 348                                this_argument_type);
 349                         return (arg_count);
 350                 }
 351
 352                 strcat(buffer,
 353                        ut_external_type_names[this_argument_type] + sub_index);
 354
 355                 /* Shift to next argument type field */
 356
 357                 argument_types >>= METHOD_ARG_BIT_WIDTH;
 358                 sub_index = 0;
 359         }
 360
 361         return (arg_count);
 362 }
 363
 364 /*******************************************************************************
 365  *
 366  * FUNCTION:    acpi_ut_get_resource_bit_width
 367  *
 368  * PARAMETERS:  buffer              - Where the formatted string is returned
 369  *              types               - Bitfield of expected data types
 370  *
 371  * RETURN:      Count of return types. Formatted string in Buffer.
 372  *
 373  * DESCRIPTION: Format the resource bit widths into a printable string.
 374  *
 375  ******************************************************************************/
 376
 377 u32 acpi_ut_get_resource_bit_width(char *buffer, u16 types)
 378 {
 379         u32 i;
 380         u16 sub_index;
 381         u32 found;
 382
 383         *buffer = 0;
 384         sub_index = 1;
 385         found = 0;
 386
 387         for (i = 0; i < NUM_RESOURCE_WIDTHS; i++) {
 388                 if (types & 1) {
 389                         strcat(buffer, &(ut_resource_type_names[i][sub_index]));
 390                         sub_index = 0;
 391                         found++;
 392                 }
 393
 394                 types >>= 1;
 395         }
 396
 397         return (found);
 398 }
 399 #endif