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