1 /****************************************************************************** 2 * 3 * Module Name: utpredef - support functions for predefined names 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2018, 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 if (!expected_btypes) { 151 strcpy(buffer, "NONE"); 152 return; 153 } 154 155 j = 1; 156 buffer[0] = 0; 157 this_rtype = ACPI_RTYPE_INTEGER; 158 159 for (i = 0; i < ACPI_NUM_RTYPES; i++) { 160 161 /* If one of the expected types, concatenate the name of this type */ 162 163 if (expected_btypes & this_rtype) { 164 strcat(buffer, &ut_rtype_names[i][j]); 165 j = 0; /* Use name separator from now on */ 166 } 167 168 this_rtype <<= 1; /* Next Rtype */ 169 } 170 } 171 172 /******************************************************************************* 173 * 174 * The remaining functions are used by iASL and acpi_help only 175 * 176 ******************************************************************************/ 177 178 #if (defined ACPI_ASL_COMPILER || defined ACPI_HELP_APP) 179 180 /* Local prototypes */ 181 182 static u32 acpi_ut_get_argument_types(char *buffer, u16 argument_types); 183 184 /* Types that can be returned externally by a predefined name */ 185 186 static const char *ut_external_type_names[] = /* Indexed by ACPI_TYPE_* */ 187 { 188 ", UNSUPPORTED-TYPE", 189 ", Integer", 190 ", String", 191 ", Buffer", 192 ", Package" 193 }; 194 195 /* Bit widths for resource descriptor predefined names */ 196 197 static const char *ut_resource_type_names[] = { 198 "/1", 199 "/2", 200 "/3", 201 "/8", 202 "/16", 203 "/32", 204 "/64", 205 "/variable", 206 }; 207 208 /******************************************************************************* 209 * 210 * FUNCTION: acpi_ut_match_resource_name 211 * 212 * PARAMETERS: name - Name to find 213 * 214 * RETURN: Pointer to entry in the resource table. NULL indicates not 215 * found. 216 * 217 * DESCRIPTION: Check an object name against the predefined resource 218 * descriptor object list. 219 * 220 ******************************************************************************/ 221 222 const union acpi_predefined_info *acpi_ut_match_resource_name(char *name) 223 { 224 const union acpi_predefined_info *this_name; 225 226 /* 227 * Quick check for a predefined name, first character must 228 * be underscore 229 */ 230 if (name[0] != '_') { 231 return (NULL); 232 } 233 234 /* Search info table for a predefined method/object name */ 235 236 this_name = acpi_gbl_resource_names; 237 while (this_name->info.name[0]) { 238 if (ACPI_COMPARE_NAME(name, this_name->info.name)) { 239 return (this_name); 240 } 241 242 this_name++; 243 } 244 245 return (NULL); /* Not found */ 246 } 247 248 /******************************************************************************* 249 * 250 * FUNCTION: acpi_ut_display_predefined_method 251 * 252 * PARAMETERS: buffer - Scratch buffer for this function 253 * this_name - Entry in the predefined method/name table 254 * multi_line - TRUE if output should be on >1 line 255 * 256 * RETURN: None 257 * 258 * DESCRIPTION: Display information about a predefined method. Number and 259 * type of the input arguments, and expected type(s) for the 260 * return value, if any. 261 * 262 ******************************************************************************/ 263 264 void 265 acpi_ut_display_predefined_method(char *buffer, 266 const union acpi_predefined_info *this_name, 267 u8 multi_line) 268 { 269 u32 arg_count; 270 271 /* 272 * Get the argument count and the string buffer 273 * containing all argument types 274 */ 275 arg_count = acpi_ut_get_argument_types(buffer, 276 this_name->info.argument_list); 277 278 if (multi_line) { 279 printf(" "); 280 } 281 282 printf("%4.4s Requires %s%u argument%s", 283 this_name->info.name, 284 (this_name->info.argument_list & ARG_COUNT_IS_MINIMUM) ? 285 "(at least) " : "", arg_count, arg_count != 1 ? "s" : ""); 286 287 /* Display the types for any arguments */ 288 289 if (arg_count > 0) { 290 printf(" (%s)", buffer); 291 } 292 293 if (multi_line) { 294 printf("\n "); 295 } 296 297 /* Get the return value type(s) allowed */ 298 299 if (this_name->info.expected_btypes) { 300 acpi_ut_get_expected_return_types(buffer, 301 this_name->info. 302 expected_btypes); 303 printf(" Return value types: %s\n", buffer); 304 } else { 305 printf(" No return value\n"); 306 } 307 } 308 309 /******************************************************************************* 310 * 311 * FUNCTION: acpi_ut_get_argument_types 312 * 313 * PARAMETERS: buffer - Where to return the formatted types 314 * argument_types - Types field for this method 315 * 316 * RETURN: count - the number of arguments required for this method 317 * 318 * DESCRIPTION: Format the required data types for this method (Integer, 319 * String, Buffer, or Package) and return the required argument 320 * count. 321 * 322 ******************************************************************************/ 323 324 static u32 acpi_ut_get_argument_types(char *buffer, u16 argument_types) 325 { 326 u16 this_argument_type; 327 u16 sub_index; 328 u16 arg_count; 329 u32 i; 330 331 *buffer = 0; 332 sub_index = 2; 333 334 /* First field in the types list is the count of args to follow */ 335 336 arg_count = METHOD_GET_ARG_COUNT(argument_types); 337 if (arg_count > METHOD_PREDEF_ARGS_MAX) { 338 printf("**** Invalid argument count (%u) " 339 "in predefined info structure\n", arg_count); 340 return (arg_count); 341 } 342 343 /* Get each argument from the list, convert to ascii, store to buffer */ 344 345 for (i = 0; i < arg_count; i++) { 346 this_argument_type = METHOD_GET_NEXT_TYPE(argument_types); 347 348 if (!this_argument_type 349 || (this_argument_type > METHOD_MAX_ARG_TYPE)) { 350 printf("**** Invalid argument type (%u) " 351 "in predefined info structure\n", 352 this_argument_type); 353 return (arg_count); 354 } 355 356 strcat(buffer, 357 ut_external_type_names[this_argument_type] + sub_index); 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 400