1 /* 2 * acpi_utils.c - ACPI Utility Functions ($Revision: 10 $) 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or (at 12 * your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write to the Free Software Foundation, Inc., 21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 22 * 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 */ 25 26 #include <linux/kernel.h> 27 #include <linux/module.h> 28 #include <linux/init.h> 29 #include <linux/types.h> 30 #include <acpi/acpi_bus.h> 31 #include <acpi/acpi_drivers.h> 32 33 #define _COMPONENT ACPI_BUS_COMPONENT 34 ACPI_MODULE_NAME("acpi_utils") 35 36 /* -------------------------------------------------------------------------- 37 Object Evaluation Helpers 38 -------------------------------------------------------------------------- */ 39 #ifdef ACPI_DEBUG_OUTPUT 40 #define acpi_util_eval_error(h,p,s) {\ 41 char prefix[80] = {'\0'};\ 42 struct acpi_buffer buffer = {sizeof(prefix), prefix};\ 43 acpi_get_name(h, ACPI_FULL_PATHNAME, &buffer);\ 44 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n",\ 45 (char *) prefix, p, acpi_format_exception(s))); } 46 #else 47 #define acpi_util_eval_error(h,p,s) 48 #endif 49 acpi_status 50 acpi_extract_package(union acpi_object *package, 51 struct acpi_buffer *format, struct acpi_buffer *buffer) 52 { 53 u32 size_required = 0; 54 u32 tail_offset = 0; 55 char *format_string = NULL; 56 u32 format_count = 0; 57 u32 i = 0; 58 u8 *head = NULL; 59 u8 *tail = NULL; 60 61 ACPI_FUNCTION_TRACE("acpi_extract_package"); 62 63 if (!package || (package->type != ACPI_TYPE_PACKAGE) 64 || (package->package.count < 1)) { 65 ACPI_DEBUG_PRINT((ACPI_DB_WARN, 66 "Invalid 'package' argument\n")); 67 return_ACPI_STATUS(AE_BAD_PARAMETER); 68 } 69 70 if (!format || !format->pointer || (format->length < 1)) { 71 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid 'format' argument\n")); 72 return_ACPI_STATUS(AE_BAD_PARAMETER); 73 } 74 75 if (!buffer) { 76 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid 'buffer' argument\n")); 77 return_ACPI_STATUS(AE_BAD_PARAMETER); 78 } 79 80 format_count = (format->length / sizeof(char)) - 1; 81 if (format_count > package->package.count) { 82 ACPI_DEBUG_PRINT((ACPI_DB_WARN, 83 "Format specifies more objects [%d] than exist in package [%d].", 84 format_count, package->package.count)); 85 return_ACPI_STATUS(AE_BAD_DATA); 86 } 87 88 format_string = (char *)format->pointer; 89 90 /* 91 * Calculate size_required. 92 */ 93 for (i = 0; i < format_count; i++) { 94 95 union acpi_object *element = &(package->package.elements[i]); 96 97 if (!element) { 98 return_ACPI_STATUS(AE_BAD_DATA); 99 } 100 101 switch (element->type) { 102 103 case ACPI_TYPE_INTEGER: 104 switch (format_string[i]) { 105 case 'N': 106 size_required += sizeof(acpi_integer); 107 tail_offset += sizeof(acpi_integer); 108 break; 109 case 'S': 110 size_required += 111 sizeof(char *) + sizeof(acpi_integer) + 112 sizeof(char); 113 tail_offset += sizeof(char *); 114 break; 115 default: 116 ACPI_DEBUG_PRINT((ACPI_DB_WARN, 117 "Invalid package element [%d]: got number, expecing [%c].\n", 118 i, format_string[i])); 119 return_ACPI_STATUS(AE_BAD_DATA); 120 break; 121 } 122 break; 123 124 case ACPI_TYPE_STRING: 125 case ACPI_TYPE_BUFFER: 126 switch (format_string[i]) { 127 case 'S': 128 size_required += 129 sizeof(char *) + 130 (element->string.length * sizeof(char)) + 131 sizeof(char); 132 tail_offset += sizeof(char *); 133 break; 134 case 'B': 135 size_required += 136 sizeof(u8 *) + 137 (element->buffer.length * sizeof(u8)); 138 tail_offset += sizeof(u8 *); 139 break; 140 default: 141 ACPI_DEBUG_PRINT((ACPI_DB_WARN, 142 "Invalid package element [%d] got string/buffer, expecing [%c].\n", 143 i, format_string[i])); 144 return_ACPI_STATUS(AE_BAD_DATA); 145 break; 146 } 147 break; 148 149 case ACPI_TYPE_PACKAGE: 150 default: 151 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 152 "Found unsupported element at index=%d\n", 153 i)); 154 /* TBD: handle nested packages... */ 155 return_ACPI_STATUS(AE_SUPPORT); 156 break; 157 } 158 } 159 160 /* 161 * Validate output buffer. 162 */ 163 if (buffer->length < size_required) { 164 buffer->length = size_required; 165 return_ACPI_STATUS(AE_BUFFER_OVERFLOW); 166 } else if (buffer->length != size_required || !buffer->pointer) { 167 return_ACPI_STATUS(AE_BAD_PARAMETER); 168 } 169 170 head = buffer->pointer; 171 tail = buffer->pointer + tail_offset; 172 173 /* 174 * Extract package data. 175 */ 176 for (i = 0; i < format_count; i++) { 177 178 u8 **pointer = NULL; 179 union acpi_object *element = &(package->package.elements[i]); 180 181 if (!element) { 182 return_ACPI_STATUS(AE_BAD_DATA); 183 } 184 185 switch (element->type) { 186 187 case ACPI_TYPE_INTEGER: 188 switch (format_string[i]) { 189 case 'N': 190 *((acpi_integer *) head) = 191 element->integer.value; 192 head += sizeof(acpi_integer); 193 break; 194 case 'S': 195 pointer = (u8 **) head; 196 *pointer = tail; 197 *((acpi_integer *) tail) = 198 element->integer.value; 199 head += sizeof(acpi_integer *); 200 tail += sizeof(acpi_integer); 201 /* NULL terminate string */ 202 *tail = (char)0; 203 tail += sizeof(char); 204 break; 205 default: 206 /* Should never get here */ 207 break; 208 } 209 break; 210 211 case ACPI_TYPE_STRING: 212 case ACPI_TYPE_BUFFER: 213 switch (format_string[i]) { 214 case 'S': 215 pointer = (u8 **) head; 216 *pointer = tail; 217 memcpy(tail, element->string.pointer, 218 element->string.length); 219 head += sizeof(char *); 220 tail += element->string.length * sizeof(char); 221 /* NULL terminate string */ 222 *tail = (char)0; 223 tail += sizeof(char); 224 break; 225 case 'B': 226 pointer = (u8 **) head; 227 *pointer = tail; 228 memcpy(tail, element->buffer.pointer, 229 element->buffer.length); 230 head += sizeof(u8 *); 231 tail += element->buffer.length * sizeof(u8); 232 break; 233 default: 234 /* Should never get here */ 235 break; 236 } 237 break; 238 239 case ACPI_TYPE_PACKAGE: 240 /* TBD: handle nested packages... */ 241 default: 242 /* Should never get here */ 243 break; 244 } 245 } 246 247 return_ACPI_STATUS(AE_OK); 248 } 249 250 EXPORT_SYMBOL(acpi_extract_package); 251 252 acpi_status 253 acpi_evaluate_integer(acpi_handle handle, 254 acpi_string pathname, 255 struct acpi_object_list *arguments, unsigned long *data) 256 { 257 acpi_status status = AE_OK; 258 union acpi_object *element; 259 struct acpi_buffer buffer = { 0, NULL }; 260 261 ACPI_FUNCTION_TRACE("acpi_evaluate_integer"); 262 263 if (!data) 264 return_ACPI_STATUS(AE_BAD_PARAMETER); 265 266 element = kmalloc(sizeof(union acpi_object), GFP_KERNEL); 267 if (!element) 268 return_ACPI_STATUS(AE_NO_MEMORY); 269 270 memset(element, 0, sizeof(union acpi_object)); 271 buffer.length = sizeof(union acpi_object); 272 buffer.pointer = element; 273 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 274 if (ACPI_FAILURE(status)) { 275 acpi_util_eval_error(handle, pathname, status); 276 return_ACPI_STATUS(status); 277 } 278 279 if (element->type != ACPI_TYPE_INTEGER) { 280 acpi_util_eval_error(handle, pathname, AE_BAD_DATA); 281 return_ACPI_STATUS(AE_BAD_DATA); 282 } 283 284 *data = element->integer.value; 285 kfree(element); 286 287 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%lu]\n", *data)); 288 289 return_ACPI_STATUS(AE_OK); 290 } 291 292 EXPORT_SYMBOL(acpi_evaluate_integer); 293 294 #if 0 295 acpi_status 296 acpi_evaluate_string(acpi_handle handle, 297 acpi_string pathname, 298 acpi_object_list * arguments, acpi_string * data) 299 { 300 acpi_status status = AE_OK; 301 acpi_object *element = NULL; 302 acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 303 304 ACPI_FUNCTION_TRACE("acpi_evaluate_string"); 305 306 if (!data) 307 return_ACPI_STATUS(AE_BAD_PARAMETER); 308 309 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 310 if (ACPI_FAILURE(status)) { 311 acpi_util_eval_error(handle, pathname, status); 312 return_ACPI_STATUS(status); 313 } 314 315 element = (acpi_object *) buffer.pointer; 316 317 if ((element->type != ACPI_TYPE_STRING) 318 || (element->type != ACPI_TYPE_BUFFER) 319 || !element->string.length) { 320 acpi_util_eval_error(handle, pathname, AE_BAD_DATA); 321 return_ACPI_STATUS(AE_BAD_DATA); 322 } 323 324 *data = kmalloc(element->string.length + 1, GFP_KERNEL); 325 if (!data) { 326 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Memory allocation error\n")); 327 return_VALUE(-ENOMEM); 328 } 329 memset(*data, 0, element->string.length + 1); 330 331 memcpy(*data, element->string.pointer, element->string.length); 332 333 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%s]\n", *data)); 334 335 acpi_os_free(buffer.pointer); 336 337 return_ACPI_STATUS(AE_OK); 338 } 339 #endif 340 341 acpi_status 342 acpi_evaluate_reference(acpi_handle handle, 343 acpi_string pathname, 344 struct acpi_object_list *arguments, 345 struct acpi_handle_list *list) 346 { 347 acpi_status status = AE_OK; 348 union acpi_object *package = NULL; 349 union acpi_object *element = NULL; 350 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 351 u32 i = 0; 352 353 ACPI_FUNCTION_TRACE("acpi_evaluate_reference"); 354 355 if (!list) { 356 return_ACPI_STATUS(AE_BAD_PARAMETER); 357 } 358 359 /* Evaluate object. */ 360 361 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 362 if (ACPI_FAILURE(status)) 363 goto end; 364 365 package = (union acpi_object *)buffer.pointer; 366 367 if ((buffer.length == 0) || !package) { 368 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 369 "No return object (len %X ptr %p)\n", 370 (unsigned)buffer.length, package)); 371 status = AE_BAD_DATA; 372 acpi_util_eval_error(handle, pathname, status); 373 goto end; 374 } 375 if (package->type != ACPI_TYPE_PACKAGE) { 376 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 377 "Expecting a [Package], found type %X\n", 378 package->type)); 379 status = AE_BAD_DATA; 380 acpi_util_eval_error(handle, pathname, status); 381 goto end; 382 } 383 if (!package->package.count) { 384 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 385 "[Package] has zero elements (%p)\n", 386 package)); 387 status = AE_BAD_DATA; 388 acpi_util_eval_error(handle, pathname, status); 389 goto end; 390 } 391 392 if (package->package.count > ACPI_MAX_HANDLES) { 393 return_ACPI_STATUS(AE_NO_MEMORY); 394 } 395 list->count = package->package.count; 396 397 /* Extract package data. */ 398 399 for (i = 0; i < list->count; i++) { 400 401 element = &(package->package.elements[i]); 402 403 if (element->type != ACPI_TYPE_ANY) { 404 status = AE_BAD_DATA; 405 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 406 "Expecting a [Reference] package element, found type %X\n", 407 element->type)); 408 acpi_util_eval_error(handle, pathname, status); 409 break; 410 } 411 412 /* Get the acpi_handle. */ 413 414 list->handles[i] = element->reference.handle; 415 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found reference [%p]\n", 416 list->handles[i])); 417 } 418 419 end: 420 if (ACPI_FAILURE(status)) { 421 list->count = 0; 422 //kfree(list->handles); 423 } 424 425 acpi_os_free(buffer.pointer); 426 427 return_ACPI_STATUS(status); 428 } 429 430 EXPORT_SYMBOL(acpi_evaluate_reference); 431