1 /* 2 * ACPI-WMI mapping driver 3 * 4 * Copyright (C) 2007-2008 Carlos Corbacho <carlos@strangeworlds.co.uk> 5 * 6 * GUID parsing code from ldm.c is: 7 * Copyright (C) 2001,2002 Richard Russon <ldm@flatcap.org> 8 * Copyright (c) 2001-2007 Anton Altaparmakov 9 * Copyright (C) 2001,2002 Jakob Kemi <jakob.kemi@telia.com> 10 * 11 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or (at 16 * your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, but 19 * WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 * General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License along 24 * with this program; if not, write to the Free Software Foundation, Inc., 25 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 26 * 27 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 28 */ 29 30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 31 32 #include <linux/kernel.h> 33 #include <linux/init.h> 34 #include <linux/types.h> 35 #include <linux/device.h> 36 #include <linux/list.h> 37 #include <linux/acpi.h> 38 #include <linux/slab.h> 39 #include <linux/module.h> 40 41 ACPI_MODULE_NAME("wmi"); 42 MODULE_AUTHOR("Carlos Corbacho"); 43 MODULE_DESCRIPTION("ACPI-WMI Mapping Driver"); 44 MODULE_LICENSE("GPL"); 45 46 #define ACPI_WMI_CLASS "wmi" 47 48 static DEFINE_MUTEX(wmi_data_lock); 49 static LIST_HEAD(wmi_block_list); 50 51 struct guid_block { 52 char guid[16]; 53 union { 54 char object_id[2]; 55 struct { 56 unsigned char notify_id; 57 unsigned char reserved; 58 }; 59 }; 60 u8 instance_count; 61 u8 flags; 62 }; 63 64 struct wmi_block { 65 struct list_head list; 66 struct guid_block gblock; 67 acpi_handle handle; 68 wmi_notify_handler handler; 69 void *handler_data; 70 struct device dev; 71 }; 72 73 74 /* 75 * If the GUID data block is marked as expensive, we must enable and 76 * explicitily disable data collection. 77 */ 78 #define ACPI_WMI_EXPENSIVE 0x1 79 #define ACPI_WMI_METHOD 0x2 /* GUID is a method */ 80 #define ACPI_WMI_STRING 0x4 /* GUID takes & returns a string */ 81 #define ACPI_WMI_EVENT 0x8 /* GUID is an event */ 82 83 static bool debug_event; 84 module_param(debug_event, bool, 0444); 85 MODULE_PARM_DESC(debug_event, 86 "Log WMI Events [0/1]"); 87 88 static bool debug_dump_wdg; 89 module_param(debug_dump_wdg, bool, 0444); 90 MODULE_PARM_DESC(debug_dump_wdg, 91 "Dump available WMI interfaces [0/1]"); 92 93 static int acpi_wmi_remove(struct acpi_device *device); 94 static int acpi_wmi_add(struct acpi_device *device); 95 static void acpi_wmi_notify(struct acpi_device *device, u32 event); 96 97 static const struct acpi_device_id wmi_device_ids[] = { 98 {"PNP0C14", 0}, 99 {"pnp0c14", 0}, 100 {"", 0}, 101 }; 102 MODULE_DEVICE_TABLE(acpi, wmi_device_ids); 103 104 static struct acpi_driver acpi_wmi_driver = { 105 .name = "wmi", 106 .class = ACPI_WMI_CLASS, 107 .ids = wmi_device_ids, 108 .ops = { 109 .add = acpi_wmi_add, 110 .remove = acpi_wmi_remove, 111 .notify = acpi_wmi_notify, 112 }, 113 }; 114 115 /* 116 * GUID parsing functions 117 */ 118 119 /** 120 * wmi_parse_hexbyte - Convert a ASCII hex number to a byte 121 * @src: Pointer to at least 2 characters to convert. 122 * 123 * Convert a two character ASCII hex string to a number. 124 * 125 * Return: 0-255 Success, the byte was parsed correctly 126 * -1 Error, an invalid character was supplied 127 */ 128 static int wmi_parse_hexbyte(const u8 *src) 129 { 130 int h; 131 int value; 132 133 /* high part */ 134 h = value = hex_to_bin(src[0]); 135 if (value < 0) 136 return -1; 137 138 /* low part */ 139 value = hex_to_bin(src[1]); 140 if (value >= 0) 141 return (h << 4) | value; 142 return -1; 143 } 144 145 /** 146 * wmi_swap_bytes - Rearrange GUID bytes to match GUID binary 147 * @src: Memory block holding binary GUID (16 bytes) 148 * @dest: Memory block to hold byte swapped binary GUID (16 bytes) 149 * 150 * Byte swap a binary GUID to match it's real GUID value 151 */ 152 static void wmi_swap_bytes(u8 *src, u8 *dest) 153 { 154 int i; 155 156 for (i = 0; i <= 3; i++) 157 memcpy(dest + i, src + (3 - i), 1); 158 159 for (i = 0; i <= 1; i++) 160 memcpy(dest + 4 + i, src + (5 - i), 1); 161 162 for (i = 0; i <= 1; i++) 163 memcpy(dest + 6 + i, src + (7 - i), 1); 164 165 memcpy(dest + 8, src + 8, 8); 166 } 167 168 /** 169 * wmi_parse_guid - Convert GUID from ASCII to binary 170 * @src: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 171 * @dest: Memory block to hold binary GUID (16 bytes) 172 * 173 * N.B. The GUID need not be NULL terminated. 174 * 175 * Return: 'true' @dest contains binary GUID 176 * 'false' @dest contents are undefined 177 */ 178 static bool wmi_parse_guid(const u8 *src, u8 *dest) 179 { 180 static const int size[] = { 4, 2, 2, 2, 6 }; 181 int i, j, v; 182 183 if (src[8] != '-' || src[13] != '-' || 184 src[18] != '-' || src[23] != '-') 185 return false; 186 187 for (j = 0; j < 5; j++, src++) { 188 for (i = 0; i < size[j]; i++, src += 2, *dest++ = v) { 189 v = wmi_parse_hexbyte(src); 190 if (v < 0) 191 return false; 192 } 193 } 194 195 return true; 196 } 197 198 /* 199 * Convert a raw GUID to the ACII string representation 200 */ 201 static int wmi_gtoa(const char *in, char *out) 202 { 203 int i; 204 205 for (i = 3; i >= 0; i--) 206 out += sprintf(out, "%02X", in[i] & 0xFF); 207 208 out += sprintf(out, "-"); 209 out += sprintf(out, "%02X", in[5] & 0xFF); 210 out += sprintf(out, "%02X", in[4] & 0xFF); 211 out += sprintf(out, "-"); 212 out += sprintf(out, "%02X", in[7] & 0xFF); 213 out += sprintf(out, "%02X", in[6] & 0xFF); 214 out += sprintf(out, "-"); 215 out += sprintf(out, "%02X", in[8] & 0xFF); 216 out += sprintf(out, "%02X", in[9] & 0xFF); 217 out += sprintf(out, "-"); 218 219 for (i = 10; i <= 15; i++) 220 out += sprintf(out, "%02X", in[i] & 0xFF); 221 222 *out = '\0'; 223 return 0; 224 } 225 226 static bool find_guid(const char *guid_string, struct wmi_block **out) 227 { 228 char tmp[16], guid_input[16]; 229 struct wmi_block *wblock; 230 struct guid_block *block; 231 struct list_head *p; 232 233 wmi_parse_guid(guid_string, tmp); 234 wmi_swap_bytes(tmp, guid_input); 235 236 list_for_each(p, &wmi_block_list) { 237 wblock = list_entry(p, struct wmi_block, list); 238 block = &wblock->gblock; 239 240 if (memcmp(block->guid, guid_input, 16) == 0) { 241 if (out) 242 *out = wblock; 243 return 1; 244 } 245 } 246 return 0; 247 } 248 249 static acpi_status wmi_method_enable(struct wmi_block *wblock, int enable) 250 { 251 struct guid_block *block = NULL; 252 char method[5]; 253 acpi_status status; 254 acpi_handle handle; 255 256 block = &wblock->gblock; 257 handle = wblock->handle; 258 259 snprintf(method, 5, "WE%02X", block->notify_id); 260 status = acpi_execute_simple_method(handle, method, enable); 261 262 if (status != AE_OK && status != AE_NOT_FOUND) 263 return status; 264 else 265 return AE_OK; 266 } 267 268 /* 269 * Exported WMI functions 270 */ 271 /** 272 * wmi_evaluate_method - Evaluate a WMI method 273 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 274 * @instance: Instance index 275 * @method_id: Method ID to call 276 * &in: Buffer containing input for the method call 277 * &out: Empty buffer to return the method results 278 * 279 * Call an ACPI-WMI method 280 */ 281 acpi_status wmi_evaluate_method(const char *guid_string, u8 instance, 282 u32 method_id, const struct acpi_buffer *in, struct acpi_buffer *out) 283 { 284 struct guid_block *block = NULL; 285 struct wmi_block *wblock = NULL; 286 acpi_handle handle; 287 acpi_status status; 288 struct acpi_object_list input; 289 union acpi_object params[3]; 290 char method[5] = "WM"; 291 292 if (!find_guid(guid_string, &wblock)) 293 return AE_ERROR; 294 295 block = &wblock->gblock; 296 handle = wblock->handle; 297 298 if (!(block->flags & ACPI_WMI_METHOD)) 299 return AE_BAD_DATA; 300 301 if (block->instance_count < instance) 302 return AE_BAD_PARAMETER; 303 304 input.count = 2; 305 input.pointer = params; 306 params[0].type = ACPI_TYPE_INTEGER; 307 params[0].integer.value = instance; 308 params[1].type = ACPI_TYPE_INTEGER; 309 params[1].integer.value = method_id; 310 311 if (in) { 312 input.count = 3; 313 314 if (block->flags & ACPI_WMI_STRING) { 315 params[2].type = ACPI_TYPE_STRING; 316 } else { 317 params[2].type = ACPI_TYPE_BUFFER; 318 } 319 params[2].buffer.length = in->length; 320 params[2].buffer.pointer = in->pointer; 321 } 322 323 strncat(method, block->object_id, 2); 324 325 status = acpi_evaluate_object(handle, method, &input, out); 326 327 return status; 328 } 329 EXPORT_SYMBOL_GPL(wmi_evaluate_method); 330 331 /** 332 * wmi_query_block - Return contents of a WMI block 333 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 334 * @instance: Instance index 335 * &out: Empty buffer to return the contents of the data block to 336 * 337 * Return the contents of an ACPI-WMI data block to a buffer 338 */ 339 acpi_status wmi_query_block(const char *guid_string, u8 instance, 340 struct acpi_buffer *out) 341 { 342 struct guid_block *block = NULL; 343 struct wmi_block *wblock = NULL; 344 acpi_handle handle; 345 acpi_status status, wc_status = AE_ERROR; 346 struct acpi_object_list input; 347 union acpi_object wq_params[1]; 348 char method[5]; 349 char wc_method[5] = "WC"; 350 351 if (!guid_string || !out) 352 return AE_BAD_PARAMETER; 353 354 if (!find_guid(guid_string, &wblock)) 355 return AE_ERROR; 356 357 block = &wblock->gblock; 358 handle = wblock->handle; 359 360 if (block->instance_count < instance) 361 return AE_BAD_PARAMETER; 362 363 /* Check GUID is a data block */ 364 if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD)) 365 return AE_ERROR; 366 367 input.count = 1; 368 input.pointer = wq_params; 369 wq_params[0].type = ACPI_TYPE_INTEGER; 370 wq_params[0].integer.value = instance; 371 372 /* 373 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method first to 374 * enable collection. 375 */ 376 if (block->flags & ACPI_WMI_EXPENSIVE) { 377 strncat(wc_method, block->object_id, 2); 378 379 /* 380 * Some GUIDs break the specification by declaring themselves 381 * expensive, but have no corresponding WCxx method. So we 382 * should not fail if this happens. 383 */ 384 if (acpi_has_method(handle, wc_method)) 385 wc_status = acpi_execute_simple_method(handle, 386 wc_method, 1); 387 } 388 389 strcpy(method, "WQ"); 390 strncat(method, block->object_id, 2); 391 392 status = acpi_evaluate_object(handle, method, &input, out); 393 394 /* 395 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method, even if 396 * the WQxx method failed - we should disable collection anyway. 397 */ 398 if ((block->flags & ACPI_WMI_EXPENSIVE) && ACPI_SUCCESS(wc_status)) { 399 status = acpi_execute_simple_method(handle, wc_method, 0); 400 } 401 402 return status; 403 } 404 EXPORT_SYMBOL_GPL(wmi_query_block); 405 406 /** 407 * wmi_set_block - Write to a WMI block 408 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 409 * @instance: Instance index 410 * &in: Buffer containing new values for the data block 411 * 412 * Write the contents of the input buffer to an ACPI-WMI data block 413 */ 414 acpi_status wmi_set_block(const char *guid_string, u8 instance, 415 const struct acpi_buffer *in) 416 { 417 struct guid_block *block = NULL; 418 struct wmi_block *wblock = NULL; 419 acpi_handle handle; 420 struct acpi_object_list input; 421 union acpi_object params[2]; 422 char method[5] = "WS"; 423 424 if (!guid_string || !in) 425 return AE_BAD_DATA; 426 427 if (!find_guid(guid_string, &wblock)) 428 return AE_ERROR; 429 430 block = &wblock->gblock; 431 handle = wblock->handle; 432 433 if (block->instance_count < instance) 434 return AE_BAD_PARAMETER; 435 436 /* Check GUID is a data block */ 437 if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD)) 438 return AE_ERROR; 439 440 input.count = 2; 441 input.pointer = params; 442 params[0].type = ACPI_TYPE_INTEGER; 443 params[0].integer.value = instance; 444 445 if (block->flags & ACPI_WMI_STRING) { 446 params[1].type = ACPI_TYPE_STRING; 447 } else { 448 params[1].type = ACPI_TYPE_BUFFER; 449 } 450 params[1].buffer.length = in->length; 451 params[1].buffer.pointer = in->pointer; 452 453 strncat(method, block->object_id, 2); 454 455 return acpi_evaluate_object(handle, method, &input, NULL); 456 } 457 EXPORT_SYMBOL_GPL(wmi_set_block); 458 459 static void wmi_dump_wdg(const struct guid_block *g) 460 { 461 char guid_string[37]; 462 463 wmi_gtoa(g->guid, guid_string); 464 465 pr_info("%s:\n", guid_string); 466 pr_info("\tobject_id: %c%c\n", g->object_id[0], g->object_id[1]); 467 pr_info("\tnotify_id: %02X\n", g->notify_id); 468 pr_info("\treserved: %02X\n", g->reserved); 469 pr_info("\tinstance_count: %d\n", g->instance_count); 470 pr_info("\tflags: %#x", g->flags); 471 if (g->flags) { 472 if (g->flags & ACPI_WMI_EXPENSIVE) 473 pr_cont(" ACPI_WMI_EXPENSIVE"); 474 if (g->flags & ACPI_WMI_METHOD) 475 pr_cont(" ACPI_WMI_METHOD"); 476 if (g->flags & ACPI_WMI_STRING) 477 pr_cont(" ACPI_WMI_STRING"); 478 if (g->flags & ACPI_WMI_EVENT) 479 pr_cont(" ACPI_WMI_EVENT"); 480 } 481 pr_cont("\n"); 482 483 } 484 485 static void wmi_notify_debug(u32 value, void *context) 486 { 487 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; 488 union acpi_object *obj; 489 acpi_status status; 490 491 status = wmi_get_event_data(value, &response); 492 if (status != AE_OK) { 493 pr_info("bad event status 0x%x\n", status); 494 return; 495 } 496 497 obj = (union acpi_object *)response.pointer; 498 499 if (!obj) 500 return; 501 502 pr_info("DEBUG Event "); 503 switch(obj->type) { 504 case ACPI_TYPE_BUFFER: 505 pr_cont("BUFFER_TYPE - length %d\n", obj->buffer.length); 506 break; 507 case ACPI_TYPE_STRING: 508 pr_cont("STRING_TYPE - %s\n", obj->string.pointer); 509 break; 510 case ACPI_TYPE_INTEGER: 511 pr_cont("INTEGER_TYPE - %llu\n", obj->integer.value); 512 break; 513 case ACPI_TYPE_PACKAGE: 514 pr_cont("PACKAGE_TYPE - %d elements\n", obj->package.count); 515 break; 516 default: 517 pr_cont("object type 0x%X\n", obj->type); 518 } 519 kfree(obj); 520 } 521 522 /** 523 * wmi_install_notify_handler - Register handler for WMI events 524 * @handler: Function to handle notifications 525 * @data: Data to be returned to handler when event is fired 526 * 527 * Register a handler for events sent to the ACPI-WMI mapper device. 528 */ 529 acpi_status wmi_install_notify_handler(const char *guid, 530 wmi_notify_handler handler, void *data) 531 { 532 struct wmi_block *block; 533 acpi_status status = AE_NOT_EXIST; 534 char tmp[16], guid_input[16]; 535 struct list_head *p; 536 537 if (!guid || !handler) 538 return AE_BAD_PARAMETER; 539 540 wmi_parse_guid(guid, tmp); 541 wmi_swap_bytes(tmp, guid_input); 542 543 list_for_each(p, &wmi_block_list) { 544 acpi_status wmi_status; 545 block = list_entry(p, struct wmi_block, list); 546 547 if (memcmp(block->gblock.guid, guid_input, 16) == 0) { 548 if (block->handler && 549 block->handler != wmi_notify_debug) 550 return AE_ALREADY_ACQUIRED; 551 552 block->handler = handler; 553 block->handler_data = data; 554 555 wmi_status = wmi_method_enable(block, 1); 556 if ((wmi_status != AE_OK) || 557 ((wmi_status == AE_OK) && (status == AE_NOT_EXIST))) 558 status = wmi_status; 559 } 560 } 561 562 return status; 563 } 564 EXPORT_SYMBOL_GPL(wmi_install_notify_handler); 565 566 /** 567 * wmi_uninstall_notify_handler - Unregister handler for WMI events 568 * 569 * Unregister handler for events sent to the ACPI-WMI mapper device. 570 */ 571 acpi_status wmi_remove_notify_handler(const char *guid) 572 { 573 struct wmi_block *block; 574 acpi_status status = AE_NOT_EXIST; 575 char tmp[16], guid_input[16]; 576 struct list_head *p; 577 578 if (!guid) 579 return AE_BAD_PARAMETER; 580 581 wmi_parse_guid(guid, tmp); 582 wmi_swap_bytes(tmp, guid_input); 583 584 list_for_each(p, &wmi_block_list) { 585 acpi_status wmi_status; 586 block = list_entry(p, struct wmi_block, list); 587 588 if (memcmp(block->gblock.guid, guid_input, 16) == 0) { 589 if (!block->handler || 590 block->handler == wmi_notify_debug) 591 return AE_NULL_ENTRY; 592 593 if (debug_event) { 594 block->handler = wmi_notify_debug; 595 status = AE_OK; 596 } else { 597 wmi_status = wmi_method_enable(block, 0); 598 block->handler = NULL; 599 block->handler_data = NULL; 600 if ((wmi_status != AE_OK) || 601 ((wmi_status == AE_OK) && 602 (status == AE_NOT_EXIST))) 603 status = wmi_status; 604 } 605 } 606 } 607 608 return status; 609 } 610 EXPORT_SYMBOL_GPL(wmi_remove_notify_handler); 611 612 /** 613 * wmi_get_event_data - Get WMI data associated with an event 614 * 615 * @event: Event to find 616 * @out: Buffer to hold event data. out->pointer should be freed with kfree() 617 * 618 * Returns extra data associated with an event in WMI. 619 */ 620 acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out) 621 { 622 struct acpi_object_list input; 623 union acpi_object params[1]; 624 struct guid_block *gblock; 625 struct wmi_block *wblock; 626 struct list_head *p; 627 628 input.count = 1; 629 input.pointer = params; 630 params[0].type = ACPI_TYPE_INTEGER; 631 params[0].integer.value = event; 632 633 list_for_each(p, &wmi_block_list) { 634 wblock = list_entry(p, struct wmi_block, list); 635 gblock = &wblock->gblock; 636 637 if ((gblock->flags & ACPI_WMI_EVENT) && 638 (gblock->notify_id == event)) 639 return acpi_evaluate_object(wblock->handle, "_WED", 640 &input, out); 641 } 642 643 return AE_NOT_FOUND; 644 } 645 EXPORT_SYMBOL_GPL(wmi_get_event_data); 646 647 /** 648 * wmi_has_guid - Check if a GUID is available 649 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 650 * 651 * Check if a given GUID is defined by _WDG 652 */ 653 bool wmi_has_guid(const char *guid_string) 654 { 655 return find_guid(guid_string, NULL); 656 } 657 EXPORT_SYMBOL_GPL(wmi_has_guid); 658 659 /* 660 * sysfs interface 661 */ 662 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 663 char *buf) 664 { 665 char guid_string[37]; 666 struct wmi_block *wblock; 667 668 wblock = dev_get_drvdata(dev); 669 if (!wblock) { 670 strcat(buf, "\n"); 671 return strlen(buf); 672 } 673 674 wmi_gtoa(wblock->gblock.guid, guid_string); 675 676 return sprintf(buf, "wmi:%s\n", guid_string); 677 } 678 static DEVICE_ATTR_RO(modalias); 679 680 static struct attribute *wmi_attrs[] = { 681 &dev_attr_modalias.attr, 682 NULL, 683 }; 684 ATTRIBUTE_GROUPS(wmi); 685 686 static int wmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env) 687 { 688 char guid_string[37]; 689 690 struct wmi_block *wblock; 691 692 if (add_uevent_var(env, "MODALIAS=")) 693 return -ENOMEM; 694 695 wblock = dev_get_drvdata(dev); 696 if (!wblock) 697 return -ENOMEM; 698 699 wmi_gtoa(wblock->gblock.guid, guid_string); 700 701 strcpy(&env->buf[env->buflen - 1], "wmi:"); 702 memcpy(&env->buf[env->buflen - 1 + 4], guid_string, 36); 703 env->buflen += 40; 704 705 return 0; 706 } 707 708 static void wmi_dev_free(struct device *dev) 709 { 710 struct wmi_block *wmi_block = container_of(dev, struct wmi_block, dev); 711 712 kfree(wmi_block); 713 } 714 715 static struct class wmi_class = { 716 .name = "wmi", 717 .dev_release = wmi_dev_free, 718 .dev_uevent = wmi_dev_uevent, 719 .dev_groups = wmi_groups, 720 }; 721 722 static int wmi_create_device(const struct guid_block *gblock, 723 struct wmi_block *wblock, acpi_handle handle) 724 { 725 char guid_string[37]; 726 727 wblock->dev.class = &wmi_class; 728 729 wmi_gtoa(gblock->guid, guid_string); 730 dev_set_name(&wblock->dev, "%s", guid_string); 731 732 dev_set_drvdata(&wblock->dev, wblock); 733 734 return device_register(&wblock->dev); 735 } 736 737 static void wmi_free_devices(void) 738 { 739 struct wmi_block *wblock, *next; 740 741 /* Delete devices for all the GUIDs */ 742 list_for_each_entry_safe(wblock, next, &wmi_block_list, list) { 743 list_del(&wblock->list); 744 if (wblock->dev.class) 745 device_unregister(&wblock->dev); 746 else 747 kfree(wblock); 748 } 749 } 750 751 static bool guid_already_parsed(const char *guid_string) 752 { 753 struct wmi_block *wblock; 754 755 list_for_each_entry(wblock, &wmi_block_list, list) 756 if (memcmp(wblock->gblock.guid, guid_string, 16) == 0) 757 return true; 758 759 return false; 760 } 761 762 /* 763 * Parse the _WDG method for the GUID data blocks 764 */ 765 static int parse_wdg(acpi_handle handle) 766 { 767 struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL}; 768 union acpi_object *obj; 769 const struct guid_block *gblock; 770 struct wmi_block *wblock; 771 acpi_status status; 772 int retval; 773 u32 i, total; 774 775 status = acpi_evaluate_object(handle, "_WDG", NULL, &out); 776 if (ACPI_FAILURE(status)) 777 return -ENXIO; 778 779 obj = (union acpi_object *) out.pointer; 780 if (!obj) 781 return -ENXIO; 782 783 if (obj->type != ACPI_TYPE_BUFFER) { 784 retval = -ENXIO; 785 goto out_free_pointer; 786 } 787 788 gblock = (const struct guid_block *)obj->buffer.pointer; 789 total = obj->buffer.length / sizeof(struct guid_block); 790 791 for (i = 0; i < total; i++) { 792 if (debug_dump_wdg) 793 wmi_dump_wdg(&gblock[i]); 794 795 wblock = kzalloc(sizeof(struct wmi_block), GFP_KERNEL); 796 if (!wblock) 797 return -ENOMEM; 798 799 wblock->handle = handle; 800 wblock->gblock = gblock[i]; 801 802 /* 803 Some WMI devices, like those for nVidia hooks, have a 804 duplicate GUID. It's not clear what we should do in this 805 case yet, so for now, we'll just ignore the duplicate 806 for device creation. 807 */ 808 if (!guid_already_parsed(gblock[i].guid)) { 809 retval = wmi_create_device(&gblock[i], wblock, handle); 810 if (retval) { 811 wmi_free_devices(); 812 goto out_free_pointer; 813 } 814 } 815 816 list_add_tail(&wblock->list, &wmi_block_list); 817 818 if (debug_event) { 819 wblock->handler = wmi_notify_debug; 820 wmi_method_enable(wblock, 1); 821 } 822 } 823 824 retval = 0; 825 826 out_free_pointer: 827 kfree(out.pointer); 828 829 return retval; 830 } 831 832 /* 833 * WMI can have EmbeddedControl access regions. In which case, we just want to 834 * hand these off to the EC driver. 835 */ 836 static acpi_status 837 acpi_wmi_ec_space_handler(u32 function, acpi_physical_address address, 838 u32 bits, u64 *value, 839 void *handler_context, void *region_context) 840 { 841 int result = 0, i = 0; 842 u8 temp = 0; 843 844 if ((address > 0xFF) || !value) 845 return AE_BAD_PARAMETER; 846 847 if (function != ACPI_READ && function != ACPI_WRITE) 848 return AE_BAD_PARAMETER; 849 850 if (bits != 8) 851 return AE_BAD_PARAMETER; 852 853 if (function == ACPI_READ) { 854 result = ec_read(address, &temp); 855 (*value) |= ((u64)temp) << i; 856 } else { 857 temp = 0xff & ((*value) >> i); 858 result = ec_write(address, temp); 859 } 860 861 switch (result) { 862 case -EINVAL: 863 return AE_BAD_PARAMETER; 864 break; 865 case -ENODEV: 866 return AE_NOT_FOUND; 867 break; 868 case -ETIME: 869 return AE_TIME; 870 break; 871 default: 872 return AE_OK; 873 } 874 } 875 876 static void acpi_wmi_notify(struct acpi_device *device, u32 event) 877 { 878 struct guid_block *block; 879 struct wmi_block *wblock; 880 struct list_head *p; 881 char guid_string[37]; 882 883 list_for_each(p, &wmi_block_list) { 884 wblock = list_entry(p, struct wmi_block, list); 885 block = &wblock->gblock; 886 887 if ((block->flags & ACPI_WMI_EVENT) && 888 (block->notify_id == event)) { 889 if (wblock->handler) 890 wblock->handler(event, wblock->handler_data); 891 if (debug_event) { 892 wmi_gtoa(wblock->gblock.guid, guid_string); 893 pr_info("DEBUG Event GUID: %s\n", guid_string); 894 } 895 896 acpi_bus_generate_netlink_event( 897 device->pnp.device_class, dev_name(&device->dev), 898 event, 0); 899 break; 900 } 901 } 902 } 903 904 static int acpi_wmi_remove(struct acpi_device *device) 905 { 906 acpi_remove_address_space_handler(device->handle, 907 ACPI_ADR_SPACE_EC, &acpi_wmi_ec_space_handler); 908 wmi_free_devices(); 909 910 return 0; 911 } 912 913 static int acpi_wmi_add(struct acpi_device *device) 914 { 915 acpi_status status; 916 int error; 917 918 status = acpi_install_address_space_handler(device->handle, 919 ACPI_ADR_SPACE_EC, 920 &acpi_wmi_ec_space_handler, 921 NULL, NULL); 922 if (ACPI_FAILURE(status)) { 923 pr_err("Error installing EC region handler\n"); 924 return -ENODEV; 925 } 926 927 error = parse_wdg(device->handle); 928 if (error) { 929 acpi_remove_address_space_handler(device->handle, 930 ACPI_ADR_SPACE_EC, 931 &acpi_wmi_ec_space_handler); 932 pr_err("Failed to parse WDG method\n"); 933 return error; 934 } 935 936 return 0; 937 } 938 939 static int __init acpi_wmi_init(void) 940 { 941 int error; 942 943 if (acpi_disabled) 944 return -ENODEV; 945 946 error = class_register(&wmi_class); 947 if (error) 948 return error; 949 950 error = acpi_bus_register_driver(&acpi_wmi_driver); 951 if (error) { 952 pr_err("Error loading mapper\n"); 953 class_unregister(&wmi_class); 954 return error; 955 } 956 957 pr_info("Mapper loaded\n"); 958 return 0; 959 } 960 961 static void __exit acpi_wmi_exit(void) 962 { 963 acpi_bus_unregister_driver(&acpi_wmi_driver); 964 class_unregister(&wmi_class); 965 966 pr_info("Mapper unloaded\n"); 967 } 968 969 subsys_initcall(acpi_wmi_init); 970 module_exit(acpi_wmi_exit); 971