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