drivers/platform/x86/wmi.c

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