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