xref: /linux/drivers/platform/x86/wmi.c (revision d163d60258c755845cbc9cfe0e45fca71e649488)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  ACPI-WMI mapping driver
4  *
5  *  Copyright (C) 2007-2008 Carlos Corbacho <carlos@strangeworlds.co.uk>
6  *
7  *  GUID parsing code from ldm.c is:
8  *   Copyright (C) 2001,2002 Richard Russon <ldm@flatcap.org>
9  *   Copyright (c) 2001-2007 Anton Altaparmakov
10  *   Copyright (C) 2001,2002 Jakob Kemi <jakob.kemi@telia.com>
11  *
12  *  WMI bus infrastructure by Andrew Lutomirski and Darren Hart:
13  *    Copyright (C) 2015 Andrew Lutomirski
14  *    Copyright (C) 2017 VMware, Inc. All Rights Reserved.
15  */
16 
17 #define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt
18 
19 #include <linux/acpi.h>
20 #include <linux/bits.h>
21 #include <linux/build_bug.h>
22 #include <linux/device.h>
23 #include <linux/init.h>
24 #include <linux/kernel.h>
25 #include <linux/list.h>
26 #include <linux/module.h>
27 #include <linux/platform_device.h>
28 #include <linux/rwsem.h>
29 #include <linux/slab.h>
30 #include <linux/sysfs.h>
31 #include <linux/types.h>
32 #include <linux/uuid.h>
33 #include <linux/wmi.h>
34 #include <linux/fs.h>
35 
36 MODULE_AUTHOR("Carlos Corbacho");
37 MODULE_DESCRIPTION("ACPI-WMI Mapping Driver");
38 MODULE_LICENSE("GPL");
39 
40 static LIST_HEAD(wmi_block_list);
41 
42 struct guid_block {
43 	guid_t guid;
44 	union {
45 		char object_id[2];
46 		struct {
47 			unsigned char notify_id;
48 			unsigned char reserved;
49 		};
50 	};
51 	u8 instance_count;
52 	u8 flags;
53 } __packed;
54 static_assert(sizeof(typeof_member(struct guid_block, guid)) == 16);
55 static_assert(sizeof(struct guid_block) == 20);
56 static_assert(__alignof__(struct guid_block) == 1);
57 
58 enum {	/* wmi_block flags */
59 	WMI_READ_TAKES_NO_ARGS,
60 	WMI_GUID_DUPLICATED,
61 	WMI_NO_EVENT_DATA,
62 };
63 
64 struct wmi_block {
65 	struct wmi_device dev;
66 	struct list_head list;
67 	struct guid_block gblock;
68 	struct acpi_device *acpi_device;
69 	struct rw_semaphore notify_lock;	/* Protects notify callback add/remove */
70 	wmi_notify_handler handler;
71 	void *handler_data;
72 	bool driver_ready;
73 	unsigned long flags;
74 };
75 
76 
77 /*
78  * If the GUID data block is marked as expensive, we must enable and
79  * explicitily disable data collection.
80  */
81 #define ACPI_WMI_EXPENSIVE   BIT(0)
82 #define ACPI_WMI_METHOD      BIT(1)	/* GUID is a method */
83 #define ACPI_WMI_STRING      BIT(2)	/* GUID takes & returns a string */
84 #define ACPI_WMI_EVENT       BIT(3)	/* GUID is an event */
85 
86 static const struct acpi_device_id wmi_device_ids[] = {
87 	{"PNP0C14", 0},
88 	{"pnp0c14", 0},
89 	{ }
90 };
91 MODULE_DEVICE_TABLE(acpi, wmi_device_ids);
92 
93 #define dev_to_wblock(__dev)	container_of_const(__dev, struct wmi_block, dev.dev)
94 #define dev_to_wdev(__dev)	container_of_const(__dev, struct wmi_device, dev)
95 
96 /*
97  * GUID parsing functions
98  */
99 
100 static bool guid_parse_and_compare(const char *string, const guid_t *guid)
101 {
102 	guid_t guid_input;
103 
104 	if (guid_parse(string, &guid_input))
105 		return false;
106 
107 	return guid_equal(&guid_input, guid);
108 }
109 
110 static const void *find_guid_context(struct wmi_block *wblock,
111 				     struct wmi_driver *wdriver)
112 {
113 	const struct wmi_device_id *id;
114 
115 	id = wdriver->id_table;
116 	if (!id)
117 		return NULL;
118 
119 	while (*id->guid_string) {
120 		if (guid_parse_and_compare(id->guid_string, &wblock->gblock.guid))
121 			return id->context;
122 		id++;
123 	}
124 	return NULL;
125 }
126 
127 static acpi_status wmi_method_enable(struct wmi_block *wblock, bool enable)
128 {
129 	struct guid_block *block;
130 	char method[5];
131 	acpi_status status;
132 	acpi_handle handle;
133 
134 	block = &wblock->gblock;
135 	handle = wblock->acpi_device->handle;
136 
137 	snprintf(method, 5, "WE%02X", block->notify_id);
138 	status = acpi_execute_simple_method(handle, method, enable);
139 	if (status == AE_NOT_FOUND)
140 		return AE_OK;
141 
142 	return status;
143 }
144 
145 #define WMI_ACPI_METHOD_NAME_SIZE 5
146 
147 static inline void get_acpi_method_name(const struct wmi_block *wblock,
148 					const char method,
149 					char buffer[static WMI_ACPI_METHOD_NAME_SIZE])
150 {
151 	static_assert(ARRAY_SIZE(wblock->gblock.object_id) == 2);
152 	static_assert(WMI_ACPI_METHOD_NAME_SIZE >= 5);
153 
154 	buffer[0] = 'W';
155 	buffer[1] = method;
156 	buffer[2] = wblock->gblock.object_id[0];
157 	buffer[3] = wblock->gblock.object_id[1];
158 	buffer[4] = '\0';
159 }
160 
161 static inline acpi_object_type get_param_acpi_type(const struct wmi_block *wblock)
162 {
163 	if (wblock->gblock.flags & ACPI_WMI_STRING)
164 		return ACPI_TYPE_STRING;
165 	else
166 		return ACPI_TYPE_BUFFER;
167 }
168 
169 static acpi_status get_event_data(const struct wmi_block *wblock, struct acpi_buffer *out)
170 {
171 	union acpi_object param = {
172 		.integer = {
173 			.type = ACPI_TYPE_INTEGER,
174 			.value = wblock->gblock.notify_id,
175 		}
176 	};
177 	struct acpi_object_list input = {
178 		.count = 1,
179 		.pointer = &param,
180 	};
181 
182 	return acpi_evaluate_object(wblock->acpi_device->handle, "_WED", &input, out);
183 }
184 
185 static int wmidev_match_guid(struct device *dev, const void *data)
186 {
187 	struct wmi_block *wblock = dev_to_wblock(dev);
188 	const guid_t *guid = data;
189 
190 	/* Legacy GUID-based functions are restricted to only see
191 	 * a single WMI device for each GUID.
192 	 */
193 	if (test_bit(WMI_GUID_DUPLICATED, &wblock->flags))
194 		return 0;
195 
196 	if (guid_equal(guid, &wblock->gblock.guid))
197 		return 1;
198 
199 	return 0;
200 }
201 
202 static int wmidev_match_notify_id(struct device *dev, const void *data)
203 {
204 	struct wmi_block *wblock = dev_to_wblock(dev);
205 	const u32 *notify_id = data;
206 
207 	/* Legacy GUID-based functions are restricted to only see
208 	 * a single WMI device for each GUID.
209 	 */
210 	if (test_bit(WMI_GUID_DUPLICATED, &wblock->flags))
211 		return 0;
212 
213 	if (wblock->gblock.flags & ACPI_WMI_EVENT && wblock->gblock.notify_id == *notify_id)
214 		return 1;
215 
216 	return 0;
217 }
218 
219 static const struct bus_type wmi_bus_type;
220 
221 static struct wmi_device *wmi_find_device_by_guid(const char *guid_string)
222 {
223 	struct device *dev;
224 	guid_t guid;
225 	int ret;
226 
227 	ret = guid_parse(guid_string, &guid);
228 	if (ret < 0)
229 		return ERR_PTR(ret);
230 
231 	dev = bus_find_device(&wmi_bus_type, NULL, &guid, wmidev_match_guid);
232 	if (!dev)
233 		return ERR_PTR(-ENODEV);
234 
235 	return dev_to_wdev(dev);
236 }
237 
238 static struct wmi_device *wmi_find_event_by_notify_id(const u32 notify_id)
239 {
240 	struct device *dev;
241 
242 	dev = bus_find_device(&wmi_bus_type, NULL, &notify_id, wmidev_match_notify_id);
243 	if (!dev)
244 		return ERR_PTR(-ENODEV);
245 
246 	return to_wmi_device(dev);
247 }
248 
249 static void wmi_device_put(struct wmi_device *wdev)
250 {
251 	put_device(&wdev->dev);
252 }
253 
254 /*
255  * Exported WMI functions
256  */
257 
258 /**
259  * wmi_instance_count - Get number of WMI object instances
260  * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
261  *
262  * Get the number of WMI object instances.
263  *
264  * Returns: Number of WMI object instances or negative error code.
265  */
266 int wmi_instance_count(const char *guid_string)
267 {
268 	struct wmi_device *wdev;
269 	int ret;
270 
271 	wdev = wmi_find_device_by_guid(guid_string);
272 	if (IS_ERR(wdev))
273 		return PTR_ERR(wdev);
274 
275 	ret = wmidev_instance_count(wdev);
276 	wmi_device_put(wdev);
277 
278 	return ret;
279 }
280 EXPORT_SYMBOL_GPL(wmi_instance_count);
281 
282 /**
283  * wmidev_instance_count - Get number of WMI object instances
284  * @wdev: A wmi bus device from a driver
285  *
286  * Get the number of WMI object instances.
287  *
288  * Returns: Number of WMI object instances.
289  */
290 u8 wmidev_instance_count(struct wmi_device *wdev)
291 {
292 	struct wmi_block *wblock = container_of(wdev, struct wmi_block, dev);
293 
294 	return wblock->gblock.instance_count;
295 }
296 EXPORT_SYMBOL_GPL(wmidev_instance_count);
297 
298 /**
299  * wmi_evaluate_method - Evaluate a WMI method (deprecated)
300  * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
301  * @instance: Instance index
302  * @method_id: Method ID to call
303  * @in: Mandatory buffer containing input for the method call
304  * @out: Empty buffer to return the method results
305  *
306  * Call an ACPI-WMI method, the caller must free @out.
307  *
308  * Return: acpi_status signaling success or error.
309  */
310 acpi_status wmi_evaluate_method(const char *guid_string, u8 instance, u32 method_id,
311 				const struct acpi_buffer *in, struct acpi_buffer *out)
312 {
313 	struct wmi_device *wdev;
314 	acpi_status status;
315 
316 	wdev = wmi_find_device_by_guid(guid_string);
317 	if (IS_ERR(wdev))
318 		return AE_ERROR;
319 
320 	status = wmidev_evaluate_method(wdev, instance, method_id, in, out);
321 
322 	wmi_device_put(wdev);
323 
324 	return status;
325 }
326 EXPORT_SYMBOL_GPL(wmi_evaluate_method);
327 
328 /**
329  * wmidev_evaluate_method - Evaluate a WMI method
330  * @wdev: A wmi bus device from a driver
331  * @instance: Instance index
332  * @method_id: Method ID to call
333  * @in: Mandatory buffer containing input for the method call
334  * @out: Empty buffer to return the method results
335  *
336  * Call an ACPI-WMI method, the caller must free @out.
337  *
338  * Return: acpi_status signaling success or error.
339  */
340 acpi_status wmidev_evaluate_method(struct wmi_device *wdev, u8 instance, u32 method_id,
341 				   const struct acpi_buffer *in, struct acpi_buffer *out)
342 {
343 	struct guid_block *block;
344 	struct wmi_block *wblock;
345 	acpi_handle handle;
346 	struct acpi_object_list input;
347 	union acpi_object params[3];
348 	char method[WMI_ACPI_METHOD_NAME_SIZE];
349 
350 	wblock = container_of(wdev, struct wmi_block, dev);
351 	block = &wblock->gblock;
352 	handle = wblock->acpi_device->handle;
353 
354 	if (!in)
355 		return AE_BAD_DATA;
356 
357 	if (!(block->flags & ACPI_WMI_METHOD))
358 		return AE_BAD_DATA;
359 
360 	if (block->instance_count <= instance)
361 		return AE_BAD_PARAMETER;
362 
363 	input.count = 3;
364 	input.pointer = params;
365 
366 	params[0].type = ACPI_TYPE_INTEGER;
367 	params[0].integer.value = instance;
368 	params[1].type = ACPI_TYPE_INTEGER;
369 	params[1].integer.value = method_id;
370 	params[2].type = get_param_acpi_type(wblock);
371 	params[2].buffer.length = in->length;
372 	params[2].buffer.pointer = in->pointer;
373 
374 	get_acpi_method_name(wblock, 'M', method);
375 
376 	return acpi_evaluate_object(handle, method, &input, out);
377 }
378 EXPORT_SYMBOL_GPL(wmidev_evaluate_method);
379 
380 static acpi_status __query_block(struct wmi_block *wblock, u8 instance,
381 				 struct acpi_buffer *out)
382 {
383 	struct guid_block *block;
384 	acpi_handle handle;
385 	acpi_status status, wc_status = AE_ERROR;
386 	struct acpi_object_list input;
387 	union acpi_object wq_params[1];
388 	char wc_method[WMI_ACPI_METHOD_NAME_SIZE];
389 	char method[WMI_ACPI_METHOD_NAME_SIZE];
390 
391 	if (!out)
392 		return AE_BAD_PARAMETER;
393 
394 	block = &wblock->gblock;
395 	handle = wblock->acpi_device->handle;
396 
397 	if (block->instance_count <= instance)
398 		return AE_BAD_PARAMETER;
399 
400 	/* Check GUID is a data block */
401 	if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD))
402 		return AE_ERROR;
403 
404 	input.count = 1;
405 	input.pointer = wq_params;
406 	wq_params[0].type = ACPI_TYPE_INTEGER;
407 	wq_params[0].integer.value = instance;
408 
409 	if (instance == 0 && test_bit(WMI_READ_TAKES_NO_ARGS, &wblock->flags))
410 		input.count = 0;
411 
412 	/*
413 	 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method first to
414 	 * enable collection.
415 	 */
416 	if (block->flags & ACPI_WMI_EXPENSIVE) {
417 		get_acpi_method_name(wblock, 'C', wc_method);
418 
419 		/*
420 		 * Some GUIDs break the specification by declaring themselves
421 		 * expensive, but have no corresponding WCxx method. So we
422 		 * should not fail if this happens.
423 		 */
424 		wc_status = acpi_execute_simple_method(handle, wc_method, 1);
425 	}
426 
427 	get_acpi_method_name(wblock, 'Q', method);
428 	status = acpi_evaluate_object(handle, method, &input, out);
429 
430 	/*
431 	 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method, even if
432 	 * the WQxx method failed - we should disable collection anyway.
433 	 */
434 	if ((block->flags & ACPI_WMI_EXPENSIVE) && ACPI_SUCCESS(wc_status)) {
435 		/*
436 		 * Ignore whether this WCxx call succeeds or not since
437 		 * the previously executed WQxx method call might have
438 		 * succeeded, and returning the failing status code
439 		 * of this call would throw away the result of the WQxx
440 		 * call, potentially leaking memory.
441 		 */
442 		acpi_execute_simple_method(handle, wc_method, 0);
443 	}
444 
445 	return status;
446 }
447 
448 /**
449  * wmi_query_block - Return contents of a WMI block (deprecated)
450  * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
451  * @instance: Instance index
452  * @out: Empty buffer to return the contents of the data block to
453  *
454  * Query a ACPI-WMI block, the caller must free @out.
455  *
456  * Return: ACPI object containing the content of the WMI block.
457  */
458 acpi_status wmi_query_block(const char *guid_string, u8 instance,
459 			    struct acpi_buffer *out)
460 {
461 	struct wmi_block *wblock;
462 	struct wmi_device *wdev;
463 	acpi_status status;
464 
465 	wdev = wmi_find_device_by_guid(guid_string);
466 	if (IS_ERR(wdev))
467 		return AE_ERROR;
468 
469 	wblock = container_of(wdev, struct wmi_block, dev);
470 	status = __query_block(wblock, instance, out);
471 
472 	wmi_device_put(wdev);
473 
474 	return status;
475 }
476 EXPORT_SYMBOL_GPL(wmi_query_block);
477 
478 /**
479  * wmidev_block_query - Return contents of a WMI block
480  * @wdev: A wmi bus device from a driver
481  * @instance: Instance index
482  *
483  * Query an ACPI-WMI block, the caller must free the result.
484  *
485  * Return: ACPI object containing the content of the WMI block.
486  */
487 union acpi_object *wmidev_block_query(struct wmi_device *wdev, u8 instance)
488 {
489 	struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
490 	struct wmi_block *wblock = container_of(wdev, struct wmi_block, dev);
491 
492 	if (ACPI_FAILURE(__query_block(wblock, instance, &out)))
493 		return NULL;
494 
495 	return out.pointer;
496 }
497 EXPORT_SYMBOL_GPL(wmidev_block_query);
498 
499 /**
500  * wmi_set_block - Write to a WMI block (deprecated)
501  * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
502  * @instance: Instance index
503  * @in: Buffer containing new values for the data block
504  *
505  * Write the contents of the input buffer to an ACPI-WMI data block.
506  *
507  * Return: acpi_status signaling success or error.
508  */
509 acpi_status wmi_set_block(const char *guid_string, u8 instance, const struct acpi_buffer *in)
510 {
511 	struct wmi_device *wdev;
512 	acpi_status status;
513 
514 	wdev = wmi_find_device_by_guid(guid_string);
515 	if (IS_ERR(wdev))
516 		return AE_ERROR;
517 
518 	status =  wmidev_block_set(wdev, instance, in);
519 	wmi_device_put(wdev);
520 
521 	return status;
522 }
523 EXPORT_SYMBOL_GPL(wmi_set_block);
524 
525 /**
526  * wmidev_block_set - Write to a WMI block
527  * @wdev: A wmi bus device from a driver
528  * @instance: Instance index
529  * @in: Buffer containing new values for the data block
530  *
531  * Write contents of the input buffer to an ACPI-WMI data block.
532  *
533  * Return: acpi_status signaling success or error.
534  */
535 acpi_status wmidev_block_set(struct wmi_device *wdev, u8 instance, const struct acpi_buffer *in)
536 {
537 	struct wmi_block *wblock = container_of(wdev, struct wmi_block, dev);
538 	acpi_handle handle = wblock->acpi_device->handle;
539 	struct guid_block *block = &wblock->gblock;
540 	char method[WMI_ACPI_METHOD_NAME_SIZE];
541 	struct acpi_object_list input;
542 	union acpi_object params[2];
543 
544 	if (!in)
545 		return AE_BAD_DATA;
546 
547 	if (block->instance_count <= instance)
548 		return AE_BAD_PARAMETER;
549 
550 	/* Check GUID is a data block */
551 	if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD))
552 		return AE_ERROR;
553 
554 	input.count = 2;
555 	input.pointer = params;
556 	params[0].type = ACPI_TYPE_INTEGER;
557 	params[0].integer.value = instance;
558 	params[1].type = get_param_acpi_type(wblock);
559 	params[1].buffer.length = in->length;
560 	params[1].buffer.pointer = in->pointer;
561 
562 	get_acpi_method_name(wblock, 'S', method);
563 
564 	return acpi_evaluate_object(handle, method, &input, NULL);
565 }
566 EXPORT_SYMBOL_GPL(wmidev_block_set);
567 
568 /**
569  * wmi_install_notify_handler - Register handler for WMI events (deprecated)
570  * @guid: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
571  * @handler: Function to handle notifications
572  * @data: Data to be returned to handler when event is fired
573  *
574  * Register a handler for events sent to the ACPI-WMI mapper device.
575  *
576  * Return: acpi_status signaling success or error.
577  */
578 acpi_status wmi_install_notify_handler(const char *guid,
579 				       wmi_notify_handler handler,
580 				       void *data)
581 {
582 	struct wmi_block *wblock;
583 	struct wmi_device *wdev;
584 	acpi_status status;
585 
586 	wdev = wmi_find_device_by_guid(guid);
587 	if (IS_ERR(wdev))
588 		return AE_ERROR;
589 
590 	wblock = container_of(wdev, struct wmi_block, dev);
591 
592 	down_write(&wblock->notify_lock);
593 	if (wblock->handler) {
594 		status = AE_ALREADY_ACQUIRED;
595 	} else {
596 		wblock->handler = handler;
597 		wblock->handler_data = data;
598 
599 		if (ACPI_FAILURE(wmi_method_enable(wblock, true)))
600 			dev_warn(&wblock->dev.dev, "Failed to enable device\n");
601 
602 		status = AE_OK;
603 	}
604 	up_write(&wblock->notify_lock);
605 
606 	wmi_device_put(wdev);
607 
608 	return status;
609 }
610 EXPORT_SYMBOL_GPL(wmi_install_notify_handler);
611 
612 /**
613  * wmi_remove_notify_handler - Unregister handler for WMI events (deprecated)
614  * @guid: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
615  *
616  * Unregister handler for events sent to the ACPI-WMI mapper device.
617  *
618  * Return: acpi_status signaling success or error.
619  */
620 acpi_status wmi_remove_notify_handler(const char *guid)
621 {
622 	struct wmi_block *wblock;
623 	struct wmi_device *wdev;
624 	acpi_status status;
625 
626 	wdev = wmi_find_device_by_guid(guid);
627 	if (IS_ERR(wdev))
628 		return AE_ERROR;
629 
630 	wblock = container_of(wdev, struct wmi_block, dev);
631 
632 	down_write(&wblock->notify_lock);
633 	if (!wblock->handler) {
634 		status = AE_NULL_ENTRY;
635 	} else {
636 		if (ACPI_FAILURE(wmi_method_enable(wblock, false)))
637 			dev_warn(&wblock->dev.dev, "Failed to disable device\n");
638 
639 		wblock->handler = NULL;
640 		wblock->handler_data = NULL;
641 
642 		status = AE_OK;
643 	}
644 	up_write(&wblock->notify_lock);
645 
646 	wmi_device_put(wdev);
647 
648 	return status;
649 }
650 EXPORT_SYMBOL_GPL(wmi_remove_notify_handler);
651 
652 /**
653  * wmi_get_event_data - Get WMI data associated with an event (deprecated)
654  *
655  * @event: Event to find
656  * @out: Buffer to hold event data
657  *
658  * Get extra data associated with an WMI event, the caller needs to free @out.
659  *
660  * Return: acpi_status signaling success or error.
661  */
662 acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out)
663 {
664 	struct wmi_block *wblock;
665 	struct wmi_device *wdev;
666 	acpi_status status;
667 
668 	wdev = wmi_find_event_by_notify_id(event);
669 	if (IS_ERR(wdev))
670 		return AE_NOT_FOUND;
671 
672 	wblock = container_of(wdev, struct wmi_block, dev);
673 	status = get_event_data(wblock, out);
674 
675 	wmi_device_put(wdev);
676 
677 	return status;
678 }
679 EXPORT_SYMBOL_GPL(wmi_get_event_data);
680 
681 /**
682  * wmi_has_guid - Check if a GUID is available
683  * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
684  *
685  * Check if a given GUID is defined by _WDG.
686  *
687  * Return: True if GUID is available, false otherwise.
688  */
689 bool wmi_has_guid(const char *guid_string)
690 {
691 	struct wmi_device *wdev;
692 
693 	wdev = wmi_find_device_by_guid(guid_string);
694 	if (IS_ERR(wdev))
695 		return false;
696 
697 	wmi_device_put(wdev);
698 
699 	return true;
700 }
701 EXPORT_SYMBOL_GPL(wmi_has_guid);
702 
703 /**
704  * wmi_get_acpi_device_uid() - Get _UID name of ACPI device that defines GUID (deprecated)
705  * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
706  *
707  * Find the _UID of ACPI device associated with this WMI GUID.
708  *
709  * Return: The ACPI _UID field value or NULL if the WMI GUID was not found.
710  */
711 char *wmi_get_acpi_device_uid(const char *guid_string)
712 {
713 	struct wmi_block *wblock;
714 	struct wmi_device *wdev;
715 	char *uid;
716 
717 	wdev = wmi_find_device_by_guid(guid_string);
718 	if (IS_ERR(wdev))
719 		return NULL;
720 
721 	wblock = container_of(wdev, struct wmi_block, dev);
722 	uid = acpi_device_uid(wblock->acpi_device);
723 
724 	wmi_device_put(wdev);
725 
726 	return uid;
727 }
728 EXPORT_SYMBOL_GPL(wmi_get_acpi_device_uid);
729 
730 static inline struct wmi_driver *drv_to_wdrv(struct device_driver *drv)
731 {
732 	return container_of(drv, struct wmi_driver, driver);
733 }
734 
735 /*
736  * sysfs interface
737  */
738 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
739 			     char *buf)
740 {
741 	struct wmi_block *wblock = dev_to_wblock(dev);
742 
743 	return sysfs_emit(buf, "wmi:%pUL\n", &wblock->gblock.guid);
744 }
745 static DEVICE_ATTR_RO(modalias);
746 
747 static ssize_t guid_show(struct device *dev, struct device_attribute *attr,
748 			 char *buf)
749 {
750 	struct wmi_block *wblock = dev_to_wblock(dev);
751 
752 	return sysfs_emit(buf, "%pUL\n", &wblock->gblock.guid);
753 }
754 static DEVICE_ATTR_RO(guid);
755 
756 static ssize_t instance_count_show(struct device *dev,
757 				   struct device_attribute *attr, char *buf)
758 {
759 	struct wmi_block *wblock = dev_to_wblock(dev);
760 
761 	return sysfs_emit(buf, "%d\n", (int)wblock->gblock.instance_count);
762 }
763 static DEVICE_ATTR_RO(instance_count);
764 
765 static ssize_t expensive_show(struct device *dev,
766 			      struct device_attribute *attr, char *buf)
767 {
768 	struct wmi_block *wblock = dev_to_wblock(dev);
769 
770 	return sysfs_emit(buf, "%d\n",
771 			  (wblock->gblock.flags & ACPI_WMI_EXPENSIVE) != 0);
772 }
773 static DEVICE_ATTR_RO(expensive);
774 
775 static struct attribute *wmi_attrs[] = {
776 	&dev_attr_modalias.attr,
777 	&dev_attr_guid.attr,
778 	&dev_attr_instance_count.attr,
779 	&dev_attr_expensive.attr,
780 	NULL
781 };
782 ATTRIBUTE_GROUPS(wmi);
783 
784 static ssize_t notify_id_show(struct device *dev, struct device_attribute *attr,
785 			      char *buf)
786 {
787 	struct wmi_block *wblock = dev_to_wblock(dev);
788 
789 	return sysfs_emit(buf, "%02X\n", (unsigned int)wblock->gblock.notify_id);
790 }
791 static DEVICE_ATTR_RO(notify_id);
792 
793 static struct attribute *wmi_event_attrs[] = {
794 	&dev_attr_notify_id.attr,
795 	NULL
796 };
797 ATTRIBUTE_GROUPS(wmi_event);
798 
799 static ssize_t object_id_show(struct device *dev, struct device_attribute *attr,
800 			      char *buf)
801 {
802 	struct wmi_block *wblock = dev_to_wblock(dev);
803 
804 	return sysfs_emit(buf, "%c%c\n", wblock->gblock.object_id[0],
805 			  wblock->gblock.object_id[1]);
806 }
807 static DEVICE_ATTR_RO(object_id);
808 
809 static ssize_t setable_show(struct device *dev, struct device_attribute *attr,
810 			    char *buf)
811 {
812 	struct wmi_device *wdev = dev_to_wdev(dev);
813 
814 	return sysfs_emit(buf, "%d\n", (int)wdev->setable);
815 }
816 static DEVICE_ATTR_RO(setable);
817 
818 static struct attribute *wmi_data_attrs[] = {
819 	&dev_attr_object_id.attr,
820 	&dev_attr_setable.attr,
821 	NULL
822 };
823 ATTRIBUTE_GROUPS(wmi_data);
824 
825 static struct attribute *wmi_method_attrs[] = {
826 	&dev_attr_object_id.attr,
827 	NULL
828 };
829 ATTRIBUTE_GROUPS(wmi_method);
830 
831 static int wmi_dev_uevent(const struct device *dev, struct kobj_uevent_env *env)
832 {
833 	const struct wmi_block *wblock = dev_to_wblock(dev);
834 
835 	if (add_uevent_var(env, "MODALIAS=wmi:%pUL", &wblock->gblock.guid))
836 		return -ENOMEM;
837 
838 	if (add_uevent_var(env, "WMI_GUID=%pUL", &wblock->gblock.guid))
839 		return -ENOMEM;
840 
841 	return 0;
842 }
843 
844 static void wmi_dev_release(struct device *dev)
845 {
846 	struct wmi_block *wblock = dev_to_wblock(dev);
847 
848 	kfree(wblock);
849 }
850 
851 static int wmi_dev_match(struct device *dev, struct device_driver *driver)
852 {
853 	struct wmi_driver *wmi_driver = drv_to_wdrv(driver);
854 	struct wmi_block *wblock = dev_to_wblock(dev);
855 	const struct wmi_device_id *id = wmi_driver->id_table;
856 
857 	if (id == NULL)
858 		return 0;
859 
860 	while (*id->guid_string) {
861 		if (guid_parse_and_compare(id->guid_string, &wblock->gblock.guid))
862 			return 1;
863 
864 		id++;
865 	}
866 
867 	return 0;
868 }
869 
870 static int wmi_dev_probe(struct device *dev)
871 {
872 	struct wmi_block *wblock = dev_to_wblock(dev);
873 	struct wmi_driver *wdriver = drv_to_wdrv(dev->driver);
874 	int ret = 0;
875 
876 	/* Some older WMI drivers will break if instantiated multiple times,
877 	 * so they are blocked from probing WMI devices with a duplicated GUID.
878 	 *
879 	 * New WMI drivers should support being instantiated multiple times.
880 	 */
881 	if (test_bit(WMI_GUID_DUPLICATED, &wblock->flags) && !wdriver->no_singleton) {
882 		dev_warn(dev, "Legacy driver %s cannot be instantiated multiple times\n",
883 			 dev->driver->name);
884 
885 		return -ENODEV;
886 	}
887 
888 	if (wdriver->notify) {
889 		if (test_bit(WMI_NO_EVENT_DATA, &wblock->flags) && !wdriver->no_notify_data)
890 			return -ENODEV;
891 	}
892 
893 	if (ACPI_FAILURE(wmi_method_enable(wblock, true)))
894 		dev_warn(dev, "failed to enable device -- probing anyway\n");
895 
896 	if (wdriver->probe) {
897 		ret = wdriver->probe(dev_to_wdev(dev),
898 				find_guid_context(wblock, wdriver));
899 		if (ret) {
900 			if (ACPI_FAILURE(wmi_method_enable(wblock, false)))
901 				dev_warn(dev, "Failed to disable device\n");
902 
903 			return ret;
904 		}
905 	}
906 
907 	down_write(&wblock->notify_lock);
908 	wblock->driver_ready = true;
909 	up_write(&wblock->notify_lock);
910 
911 	return 0;
912 }
913 
914 static void wmi_dev_remove(struct device *dev)
915 {
916 	struct wmi_block *wblock = dev_to_wblock(dev);
917 	struct wmi_driver *wdriver = drv_to_wdrv(dev->driver);
918 
919 	down_write(&wblock->notify_lock);
920 	wblock->driver_ready = false;
921 	up_write(&wblock->notify_lock);
922 
923 	if (wdriver->remove)
924 		wdriver->remove(dev_to_wdev(dev));
925 
926 	if (ACPI_FAILURE(wmi_method_enable(wblock, false)))
927 		dev_warn(dev, "failed to disable device\n");
928 }
929 
930 static struct class wmi_bus_class = {
931 	.name = "wmi_bus",
932 };
933 
934 static const struct bus_type wmi_bus_type = {
935 	.name = "wmi",
936 	.dev_groups = wmi_groups,
937 	.match = wmi_dev_match,
938 	.uevent = wmi_dev_uevent,
939 	.probe = wmi_dev_probe,
940 	.remove = wmi_dev_remove,
941 };
942 
943 static const struct device_type wmi_type_event = {
944 	.name = "event",
945 	.groups = wmi_event_groups,
946 	.release = wmi_dev_release,
947 };
948 
949 static const struct device_type wmi_type_method = {
950 	.name = "method",
951 	.groups = wmi_method_groups,
952 	.release = wmi_dev_release,
953 };
954 
955 static const struct device_type wmi_type_data = {
956 	.name = "data",
957 	.groups = wmi_data_groups,
958 	.release = wmi_dev_release,
959 };
960 
961 /*
962  * _WDG is a static list that is only parsed at startup,
963  * so it's safe to count entries without extra protection.
964  */
965 static int guid_count(const guid_t *guid)
966 {
967 	struct wmi_block *wblock;
968 	int count = 0;
969 
970 	list_for_each_entry(wblock, &wmi_block_list, list) {
971 		if (guid_equal(&wblock->gblock.guid, guid))
972 			count++;
973 	}
974 
975 	return count;
976 }
977 
978 static int wmi_create_device(struct device *wmi_bus_dev,
979 			     struct wmi_block *wblock,
980 			     struct acpi_device *device)
981 {
982 	char method[WMI_ACPI_METHOD_NAME_SIZE];
983 	struct acpi_device_info *info;
984 	acpi_handle method_handle;
985 	acpi_status status;
986 	uint count;
987 
988 	if (wblock->gblock.flags & ACPI_WMI_EVENT) {
989 		wblock->dev.dev.type = &wmi_type_event;
990 		goto out_init;
991 	}
992 
993 	if (wblock->gblock.flags & ACPI_WMI_METHOD) {
994 		get_acpi_method_name(wblock, 'M', method);
995 		if (!acpi_has_method(device->handle, method)) {
996 			dev_warn(wmi_bus_dev,
997 				 FW_BUG "%s method block execution control method not found\n",
998 				 method);
999 
1000 			return -ENXIO;
1001 		}
1002 
1003 		wblock->dev.dev.type = &wmi_type_method;
1004 		goto out_init;
1005 	}
1006 
1007 	/*
1008 	 * Data Block Query Control Method (WQxx by convention) is
1009 	 * required per the WMI documentation. If it is not present,
1010 	 * we ignore this data block.
1011 	 */
1012 	get_acpi_method_name(wblock, 'Q', method);
1013 	status = acpi_get_handle(device->handle, method, &method_handle);
1014 	if (ACPI_FAILURE(status)) {
1015 		dev_warn(wmi_bus_dev,
1016 			 FW_BUG "%s data block query control method not found\n",
1017 			 method);
1018 
1019 		return -ENXIO;
1020 	}
1021 
1022 	status = acpi_get_object_info(method_handle, &info);
1023 	if (ACPI_FAILURE(status))
1024 		return -EIO;
1025 
1026 	wblock->dev.dev.type = &wmi_type_data;
1027 
1028 	/*
1029 	 * The Microsoft documentation specifically states:
1030 	 *
1031 	 *   Data blocks registered with only a single instance
1032 	 *   can ignore the parameter.
1033 	 *
1034 	 * ACPICA will get mad at us if we call the method with the wrong number
1035 	 * of arguments, so check what our method expects.  (On some Dell
1036 	 * laptops, WQxx may not be a method at all.)
1037 	 */
1038 	if (info->type != ACPI_TYPE_METHOD || info->param_count == 0)
1039 		set_bit(WMI_READ_TAKES_NO_ARGS, &wblock->flags);
1040 
1041 	kfree(info);
1042 
1043 	get_acpi_method_name(wblock, 'S', method);
1044 	if (acpi_has_method(device->handle, method))
1045 		wblock->dev.setable = true;
1046 
1047  out_init:
1048 	init_rwsem(&wblock->notify_lock);
1049 	wblock->driver_ready = false;
1050 	wblock->dev.dev.bus = &wmi_bus_type;
1051 	wblock->dev.dev.parent = wmi_bus_dev;
1052 
1053 	count = guid_count(&wblock->gblock.guid);
1054 	if (count) {
1055 		dev_set_name(&wblock->dev.dev, "%pUL-%d", &wblock->gblock.guid, count);
1056 		set_bit(WMI_GUID_DUPLICATED, &wblock->flags);
1057 	} else {
1058 		dev_set_name(&wblock->dev.dev, "%pUL", &wblock->gblock.guid);
1059 	}
1060 
1061 	device_initialize(&wblock->dev.dev);
1062 
1063 	return 0;
1064 }
1065 
1066 static int wmi_add_device(struct platform_device *pdev, struct wmi_device *wdev)
1067 {
1068 	struct device_link *link;
1069 
1070 	/*
1071 	 * Many aggregate WMI drivers do not use -EPROBE_DEFER when they
1072 	 * are unable to find a WMI device during probe, instead they require
1073 	 * all WMI devices associated with an platform device to become available
1074 	 * at once. This device link thus prevents WMI drivers from probing until
1075 	 * the associated platform device has finished probing (and has registered
1076 	 * all discovered WMI devices).
1077 	 */
1078 
1079 	link = device_link_add(&wdev->dev, &pdev->dev, DL_FLAG_AUTOREMOVE_SUPPLIER);
1080 	if (!link)
1081 		return -EINVAL;
1082 
1083 	return device_add(&wdev->dev);
1084 }
1085 
1086 /*
1087  * Parse the _WDG method for the GUID data blocks
1088  */
1089 static int parse_wdg(struct device *wmi_bus_dev, struct platform_device *pdev)
1090 {
1091 	struct acpi_device *device = ACPI_COMPANION(&pdev->dev);
1092 	struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
1093 	const struct guid_block *gblock;
1094 	bool event_data_available;
1095 	struct wmi_block *wblock;
1096 	union acpi_object *obj;
1097 	acpi_status status;
1098 	u32 i, total;
1099 	int retval;
1100 
1101 	status = acpi_evaluate_object(device->handle, "_WDG", NULL, &out);
1102 	if (ACPI_FAILURE(status))
1103 		return -ENXIO;
1104 
1105 	obj = out.pointer;
1106 	if (!obj)
1107 		return -ENXIO;
1108 
1109 	if (obj->type != ACPI_TYPE_BUFFER) {
1110 		kfree(obj);
1111 		return -ENXIO;
1112 	}
1113 
1114 	event_data_available = acpi_has_method(device->handle, "_WED");
1115 	gblock = (const struct guid_block *)obj->buffer.pointer;
1116 	total = obj->buffer.length / sizeof(struct guid_block);
1117 
1118 	for (i = 0; i < total; i++) {
1119 		if (!gblock[i].instance_count) {
1120 			dev_info(wmi_bus_dev, FW_INFO "%pUL has zero instances\n", &gblock[i].guid);
1121 			continue;
1122 		}
1123 
1124 		wblock = kzalloc(sizeof(*wblock), GFP_KERNEL);
1125 		if (!wblock)
1126 			continue;
1127 
1128 		wblock->acpi_device = device;
1129 		wblock->gblock = gblock[i];
1130 		if (gblock[i].flags & ACPI_WMI_EVENT && !event_data_available)
1131 			set_bit(WMI_NO_EVENT_DATA, &wblock->flags);
1132 
1133 		retval = wmi_create_device(wmi_bus_dev, wblock, device);
1134 		if (retval) {
1135 			kfree(wblock);
1136 			continue;
1137 		}
1138 
1139 		list_add_tail(&wblock->list, &wmi_block_list);
1140 
1141 		retval = wmi_add_device(pdev, &wblock->dev);
1142 		if (retval) {
1143 			dev_err(wmi_bus_dev, "failed to register %pUL\n",
1144 				&wblock->gblock.guid);
1145 
1146 			list_del(&wblock->list);
1147 			put_device(&wblock->dev.dev);
1148 		}
1149 	}
1150 
1151 	kfree(obj);
1152 
1153 	return 0;
1154 }
1155 
1156 static int wmi_get_notify_data(struct wmi_block *wblock, union acpi_object **obj)
1157 {
1158 	struct acpi_buffer data = { ACPI_ALLOCATE_BUFFER, NULL };
1159 	acpi_status status;
1160 
1161 	if (test_bit(WMI_NO_EVENT_DATA, &wblock->flags)) {
1162 		*obj = NULL;
1163 		return 0;
1164 	}
1165 
1166 	status = get_event_data(wblock, &data);
1167 	if (ACPI_FAILURE(status)) {
1168 		dev_warn(&wblock->dev.dev, "Failed to get event data\n");
1169 		return -EIO;
1170 	}
1171 
1172 	*obj = data.pointer;
1173 
1174 	return 0;
1175 }
1176 
1177 static void wmi_notify_driver(struct wmi_block *wblock, union acpi_object *obj)
1178 {
1179 	struct wmi_driver *driver = drv_to_wdrv(wblock->dev.dev.driver);
1180 
1181 	if (!obj && !driver->no_notify_data) {
1182 		dev_warn(&wblock->dev.dev, "Event contains no event data\n");
1183 		return;
1184 	}
1185 
1186 	if (driver->notify)
1187 		driver->notify(&wblock->dev, obj);
1188 }
1189 
1190 static int wmi_notify_device(struct device *dev, void *data)
1191 {
1192 	struct wmi_block *wblock = dev_to_wblock(dev);
1193 	union acpi_object *obj;
1194 	u32 *event = data;
1195 	int ret;
1196 
1197 	if (!(wblock->gblock.flags & ACPI_WMI_EVENT && wblock->gblock.notify_id == *event))
1198 		return 0;
1199 
1200 	down_read(&wblock->notify_lock);
1201 	/* The WMI driver notify handler conflicts with the legacy WMI handler.
1202 	 * Because of this the WMI driver notify handler takes precedence.
1203 	 */
1204 	if (wblock->dev.dev.driver && wblock->driver_ready) {
1205 		ret = wmi_get_notify_data(wblock, &obj);
1206 		if (ret >= 0) {
1207 			wmi_notify_driver(wblock, obj);
1208 			kfree(obj);
1209 		}
1210 	} else {
1211 		if (wblock->handler) {
1212 			wblock->handler(*event, wblock->handler_data);
1213 		} else {
1214 			/* The ACPI WMI specification says that _WED should be
1215 			 * evaluated every time an notification is received, even
1216 			 * if no consumers are present.
1217 			 *
1218 			 * Some firmware implementations actually depend on this
1219 			 * by using a queue for events which will fill up if the
1220 			 * WMI driver core stops evaluating _WED due to missing
1221 			 * WMI event consumers.
1222 			 *
1223 			 * Because of this we need this seemingly useless call to
1224 			 * wmi_get_notify_data() which in turn evaluates _WED.
1225 			 */
1226 			ret = wmi_get_notify_data(wblock, &obj);
1227 			if (ret >= 0)
1228 				kfree(obj);
1229 		}
1230 
1231 	}
1232 	up_read(&wblock->notify_lock);
1233 
1234 	acpi_bus_generate_netlink_event("wmi", acpi_dev_name(wblock->acpi_device), *event, 0);
1235 
1236 	return -EBUSY;
1237 }
1238 
1239 static void acpi_wmi_notify_handler(acpi_handle handle, u32 event, void *context)
1240 {
1241 	struct device *wmi_bus_dev = context;
1242 
1243 	device_for_each_child(wmi_bus_dev, &event, wmi_notify_device);
1244 }
1245 
1246 static int wmi_remove_device(struct device *dev, void *data)
1247 {
1248 	struct wmi_block *wblock = dev_to_wblock(dev);
1249 
1250 	list_del(&wblock->list);
1251 	device_unregister(dev);
1252 
1253 	return 0;
1254 }
1255 
1256 static void acpi_wmi_remove(struct platform_device *device)
1257 {
1258 	struct device *wmi_bus_device = dev_get_drvdata(&device->dev);
1259 
1260 	device_for_each_child_reverse(wmi_bus_device, NULL, wmi_remove_device);
1261 }
1262 
1263 static void acpi_wmi_remove_notify_handler(void *data)
1264 {
1265 	struct acpi_device *acpi_device = data;
1266 
1267 	acpi_remove_notify_handler(acpi_device->handle, ACPI_ALL_NOTIFY, acpi_wmi_notify_handler);
1268 }
1269 
1270 static void acpi_wmi_remove_bus_device(void *data)
1271 {
1272 	struct device *wmi_bus_dev = data;
1273 
1274 	device_unregister(wmi_bus_dev);
1275 }
1276 
1277 static int acpi_wmi_probe(struct platform_device *device)
1278 {
1279 	struct acpi_device *acpi_device;
1280 	struct device *wmi_bus_dev;
1281 	acpi_status status;
1282 	int error;
1283 
1284 	acpi_device = ACPI_COMPANION(&device->dev);
1285 	if (!acpi_device) {
1286 		dev_err(&device->dev, "ACPI companion is missing\n");
1287 		return -ENODEV;
1288 	}
1289 
1290 	wmi_bus_dev = device_create(&wmi_bus_class, &device->dev, MKDEV(0, 0), NULL, "wmi_bus-%s",
1291 				    dev_name(&device->dev));
1292 	if (IS_ERR(wmi_bus_dev))
1293 		return PTR_ERR(wmi_bus_dev);
1294 
1295 	error = devm_add_action_or_reset(&device->dev, acpi_wmi_remove_bus_device, wmi_bus_dev);
1296 	if (error < 0)
1297 		return error;
1298 
1299 	dev_set_drvdata(&device->dev, wmi_bus_dev);
1300 
1301 	status = acpi_install_notify_handler(acpi_device->handle, ACPI_ALL_NOTIFY,
1302 					     acpi_wmi_notify_handler, wmi_bus_dev);
1303 	if (ACPI_FAILURE(status)) {
1304 		dev_err(&device->dev, "Error installing notify handler\n");
1305 		return -ENODEV;
1306 	}
1307 	error = devm_add_action_or_reset(&device->dev, acpi_wmi_remove_notify_handler,
1308 					 acpi_device);
1309 	if (error < 0)
1310 		return error;
1311 
1312 	error = parse_wdg(wmi_bus_dev, device);
1313 	if (error) {
1314 		dev_err(&device->dev, "Failed to parse _WDG method\n");
1315 		return error;
1316 	}
1317 
1318 	return 0;
1319 }
1320 
1321 int __must_check __wmi_driver_register(struct wmi_driver *driver,
1322 				       struct module *owner)
1323 {
1324 	driver->driver.owner = owner;
1325 	driver->driver.bus = &wmi_bus_type;
1326 
1327 	return driver_register(&driver->driver);
1328 }
1329 EXPORT_SYMBOL(__wmi_driver_register);
1330 
1331 /**
1332  * wmi_driver_unregister() - Unregister a WMI driver
1333  * @driver: WMI driver to unregister
1334  *
1335  * Unregisters a WMI driver from the WMI bus.
1336  */
1337 void wmi_driver_unregister(struct wmi_driver *driver)
1338 {
1339 	driver_unregister(&driver->driver);
1340 }
1341 EXPORT_SYMBOL(wmi_driver_unregister);
1342 
1343 static struct platform_driver acpi_wmi_driver = {
1344 	.driver = {
1345 		.name = "acpi-wmi",
1346 		.acpi_match_table = wmi_device_ids,
1347 	},
1348 	.probe = acpi_wmi_probe,
1349 	.remove_new = acpi_wmi_remove,
1350 };
1351 
1352 static int __init acpi_wmi_init(void)
1353 {
1354 	int error;
1355 
1356 	if (acpi_disabled)
1357 		return -ENODEV;
1358 
1359 	error = class_register(&wmi_bus_class);
1360 	if (error)
1361 		return error;
1362 
1363 	error = bus_register(&wmi_bus_type);
1364 	if (error)
1365 		goto err_unreg_class;
1366 
1367 	error = platform_driver_register(&acpi_wmi_driver);
1368 	if (error) {
1369 		pr_err("Error loading mapper\n");
1370 		goto err_unreg_bus;
1371 	}
1372 
1373 	return 0;
1374 
1375 err_unreg_bus:
1376 	bus_unregister(&wmi_bus_type);
1377 
1378 err_unreg_class:
1379 	class_unregister(&wmi_bus_class);
1380 
1381 	return error;
1382 }
1383 
1384 static void __exit acpi_wmi_exit(void)
1385 {
1386 	platform_driver_unregister(&acpi_wmi_driver);
1387 	bus_unregister(&wmi_bus_type);
1388 	class_unregister(&wmi_bus_class);
1389 }
1390 
1391 subsys_initcall_sync(acpi_wmi_init);
1392 module_exit(acpi_wmi_exit);
1393