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/device.h>
  21#include <linux/init.h>
  22#include <linux/kernel.h>
  23#include <linux/list.h>
  24#include <linux/miscdevice.h>
  25#include <linux/module.h>
  26#include <linux/platform_device.h>
  27#include <linux/slab.h>
  28#include <linux/types.h>
  29#include <linux/uaccess.h>
  30#include <linux/uuid.h>
  31#include <linux/wmi.h>
 
  32#include <uapi/linux/wmi.h>
  33
  34ACPI_MODULE_NAME("wmi");
  35MODULE_AUTHOR("Carlos Corbacho");
  36MODULE_DESCRIPTION("ACPI-WMI Mapping Driver");
  37MODULE_LICENSE("GPL");
  38
  39static LIST_HEAD(wmi_block_list);
  40
  41struct guid_block {
  42	char guid[16];
  43	union {
  44		char object_id[2];
  45		struct {
  46			unsigned char notify_id;
  47			unsigned char reserved;
  48		};
  49	};
  50	u8 instance_count;
  51	u8 flags;
  52};
  53
  54struct wmi_block {
  55	struct wmi_device dev;
  56	struct list_head list;
  57	struct guid_block gblock;
  58	struct miscdevice char_dev;
  59	struct mutex char_mutex;
  60	struct acpi_device *acpi_device;
  61	wmi_notify_handler handler;
  62	void *handler_data;
  63	u64 req_buf_size;
  64
  65	bool read_takes_no_args;
  66};
  67
  68
  69/*
  70 * If the GUID data block is marked as expensive, we must enable and
  71 * explicitily disable data collection.
  72 */
  73#define ACPI_WMI_EXPENSIVE   0x1
  74#define ACPI_WMI_METHOD      0x2	/* GUID is a method */
  75#define ACPI_WMI_STRING      0x4	/* GUID takes & returns a string */
  76#define ACPI_WMI_EVENT       0x8	/* GUID is an event */
  77
  78static bool debug_event;
  79module_param(debug_event, bool, 0444);
  80MODULE_PARM_DESC(debug_event,
  81		 "Log WMI Events [0/1]");
  82
  83static bool debug_dump_wdg;
  84module_param(debug_dump_wdg, bool, 0444);
  85MODULE_PARM_DESC(debug_dump_wdg,
  86		 "Dump available WMI interfaces [0/1]");
  87
  88static int acpi_wmi_remove(struct platform_device *device);
  89static int acpi_wmi_probe(struct platform_device *device);
  90
  91static const struct acpi_device_id wmi_device_ids[] = {
  92	{"PNP0C14", 0},
  93	{"pnp0c14", 0},
  94	{"", 0},
  95};
  96MODULE_DEVICE_TABLE(acpi, wmi_device_ids);
  97
  98static struct platform_driver acpi_wmi_driver = {
  99	.driver = {
 100		.name = "acpi-wmi",
 101		.acpi_match_table = wmi_device_ids,
 102	},
 103	.probe = acpi_wmi_probe,
 104	.remove = acpi_wmi_remove,
 105};
 106
 107/*
 108 * GUID parsing functions
 109 */
 110
 111static bool find_guid(const char *guid_string, struct wmi_block **out)
 112{
 113	uuid_le guid_input;
 114	struct wmi_block *wblock;
 115	struct guid_block *block;
 116
 117	if (uuid_le_to_bin(guid_string, &guid_input))
 118		return false;
 119
 120	list_for_each_entry(wblock, &wmi_block_list, list) {
 121		block = &wblock->gblock;
 122
 123		if (memcmp(block->guid, &guid_input, 16) == 0) {
 124			if (out)
 125				*out = wblock;
 126			return true;
 127		}
 128	}
 129	return false;
 130}
 131
 132static const void *find_guid_context(struct wmi_block *wblock,
 133				      struct wmi_driver *wdriver)
 134{
 135	const struct wmi_device_id *id;
 136	uuid_le guid_input;
 137
 138	if (wblock == NULL || wdriver == NULL)
 139		return NULL;
 140	if (wdriver->id_table == NULL)
 141		return NULL;
 142
 143	id = wdriver->id_table;
 144	while (*id->guid_string) {
 145		if (uuid_le_to_bin(id->guid_string, &guid_input))
 146			continue;
 147		if (!memcmp(wblock->gblock.guid, &guid_input, 16))
 148			return id->context;
 149		id++;
 150	}
 151	return NULL;
 152}
 153
 154static int get_subobj_info(acpi_handle handle, const char *pathname,
 155			   struct acpi_device_info **info)
 156{
 157	struct acpi_device_info *dummy_info, **info_ptr;
 158	acpi_handle subobj_handle;
 159	acpi_status status;
 160
 161	status = acpi_get_handle(handle, (char *)pathname, &subobj_handle);
 162	if (status == AE_NOT_FOUND)
 163		return -ENOENT;
 164	else if (ACPI_FAILURE(status))
 165		return -EIO;
 166
 167	info_ptr = info ? info : &dummy_info;
 168	status = acpi_get_object_info(subobj_handle, info_ptr);
 169	if (ACPI_FAILURE(status))
 170		return -EIO;
 171
 172	if (!info)
 173		kfree(dummy_info);
 174
 175	return 0;
 176}
 177
 178static acpi_status wmi_method_enable(struct wmi_block *wblock, int enable)
 179{
 180	struct guid_block *block = NULL;
 181	char method[5];
 182	acpi_status status;
 183	acpi_handle handle;
 184
 185	block = &wblock->gblock;
 186	handle = wblock->acpi_device->handle;
 187
 188	snprintf(method, 5, "WE%02X", block->notify_id);
 189	status = acpi_execute_simple_method(handle, method, enable);
 190
 191	if (status != AE_OK && status != AE_NOT_FOUND)
 192		return status;
 193	else
 194		return AE_OK;
 195}
 196
 197/*
 198 * Exported WMI functions
 199 */
 200
 201/**
 202 * set_required_buffer_size - Sets the buffer size needed for performing IOCTL
 203 * @wdev: A wmi bus device from a driver
 204 * @instance: Instance index
 205 *
 206 * Allocates memory needed for buffer, stores the buffer size in that memory
 207 */
 208int set_required_buffer_size(struct wmi_device *wdev, u64 length)
 209{
 210	struct wmi_block *wblock;
 211
 212	wblock = container_of(wdev, struct wmi_block, dev);
 213	wblock->req_buf_size = length;
 214
 215	return 0;
 216}
 217EXPORT_SYMBOL_GPL(set_required_buffer_size);
 218
 219/**
 220 * wmi_evaluate_method - Evaluate a WMI method
 221 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
 222 * @instance: Instance index
 223 * @method_id: Method ID to call
 224 * &in: Buffer containing input for the method call
 225 * &out: Empty buffer to return the method results
 226 *
 227 * Call an ACPI-WMI method
 228 */
 229acpi_status wmi_evaluate_method(const char *guid_string, u8 instance,
 230u32 method_id, const struct acpi_buffer *in, struct acpi_buffer *out)
 231{
 232	struct wmi_block *wblock = NULL;
 233
 234	if (!find_guid(guid_string, &wblock))
 235		return AE_ERROR;
 236	return wmidev_evaluate_method(&wblock->dev, instance, method_id,
 237				      in, out);
 238}
 239EXPORT_SYMBOL_GPL(wmi_evaluate_method);
 240
 241/**
 242 * wmidev_evaluate_method - Evaluate a WMI method
 243 * @wdev: A wmi bus device from a driver
 244 * @instance: Instance index
 245 * @method_id: Method ID to call
 246 * &in: Buffer containing input for the method call
 247 * &out: Empty buffer to return the method results
 248 *
 249 * Call an ACPI-WMI method
 250 */
 251acpi_status wmidev_evaluate_method(struct wmi_device *wdev, u8 instance,
 252	u32 method_id, const struct acpi_buffer *in, struct acpi_buffer *out)
 253{
 254	struct guid_block *block = NULL;
 255	struct wmi_block *wblock = NULL;
 256	acpi_handle handle;
 257	acpi_status status;
 258	struct acpi_object_list input;
 259	union acpi_object params[3];
 260	char method[5] = "WM";
 261
 262	wblock = container_of(wdev, struct wmi_block, dev);
 263	block = &wblock->gblock;
 264	handle = wblock->acpi_device->handle;
 265
 266	if (!(block->flags & ACPI_WMI_METHOD))
 267		return AE_BAD_DATA;
 268
 269	if (block->instance_count <= instance)
 270		return AE_BAD_PARAMETER;
 271
 272	input.count = 2;
 273	input.pointer = params;
 274	params[0].type = ACPI_TYPE_INTEGER;
 275	params[0].integer.value = instance;
 276	params[1].type = ACPI_TYPE_INTEGER;
 277	params[1].integer.value = method_id;
 278
 279	if (in) {
 280		input.count = 3;
 281
 282		if (block->flags & ACPI_WMI_STRING) {
 283			params[2].type = ACPI_TYPE_STRING;
 284		} else {
 285			params[2].type = ACPI_TYPE_BUFFER;
 286		}
 287		params[2].buffer.length = in->length;
 288		params[2].buffer.pointer = in->pointer;
 289	}
 290
 291	strncat(method, block->object_id, 2);
 292
 293	status = acpi_evaluate_object(handle, method, &input, out);
 294
 295	return status;
 296}
 297EXPORT_SYMBOL_GPL(wmidev_evaluate_method);
 298
 299static acpi_status __query_block(struct wmi_block *wblock, u8 instance,
 300				 struct acpi_buffer *out)
 301{
 302	struct guid_block *block = NULL;
 303	acpi_handle handle;
 304	acpi_status status, wc_status = AE_ERROR;
 305	struct acpi_object_list input;
 306	union acpi_object wq_params[1];
 307	char method[5];
 308	char wc_method[5] = "WC";
 309
 310	if (!out)
 311		return AE_BAD_PARAMETER;
 312
 313	block = &wblock->gblock;
 314	handle = wblock->acpi_device->handle;
 315
 316	if (block->instance_count <= instance)
 317		return AE_BAD_PARAMETER;
 318
 319	/* Check GUID is a data block */
 320	if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD))
 321		return AE_ERROR;
 322
 323	input.count = 1;
 324	input.pointer = wq_params;
 325	wq_params[0].type = ACPI_TYPE_INTEGER;
 326	wq_params[0].integer.value = instance;
 327
 328	if (instance == 0 && wblock->read_takes_no_args)
 329		input.count = 0;
 330
 331	/*
 332	 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method first to
 333	 * enable collection.
 334	 */
 335	if (block->flags & ACPI_WMI_EXPENSIVE) {
 336		strncat(wc_method, block->object_id, 2);
 337
 338		/*
 339		 * Some GUIDs break the specification by declaring themselves
 340		 * expensive, but have no corresponding WCxx method. So we
 341		 * should not fail if this happens.
 342		 */
 343		wc_status = acpi_execute_simple_method(handle, wc_method, 1);
 344	}
 345
 346	strcpy(method, "WQ");
 347	strncat(method, block->object_id, 2);
 348
 349	status = acpi_evaluate_object(handle, method, &input, out);
 350
 351	/*
 352	 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method, even if
 353	 * the WQxx method failed - we should disable collection anyway.
 354	 */
 355	if ((block->flags & ACPI_WMI_EXPENSIVE) && ACPI_SUCCESS(wc_status)) {
 356		status = acpi_execute_simple_method(handle, wc_method, 0);
 357	}
 358
 359	return status;
 360}
 361
 362/**
 363 * wmi_query_block - Return contents of a WMI block (deprecated)
 364 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
 365 * @instance: Instance index
 366 * &out: Empty buffer to return the contents of the data block to
 367 *
 368 * Return the contents of an ACPI-WMI data block to a buffer
 369 */
 370acpi_status wmi_query_block(const char *guid_string, u8 instance,
 371			    struct acpi_buffer *out)
 372{
 373	struct wmi_block *wblock;
 374
 375	if (!guid_string)
 376		return AE_BAD_PARAMETER;
 377
 378	if (!find_guid(guid_string, &wblock))
 379		return AE_ERROR;
 380
 381	return __query_block(wblock, instance, out);
 382}
 383EXPORT_SYMBOL_GPL(wmi_query_block);
 384
 385union acpi_object *wmidev_block_query(struct wmi_device *wdev, u8 instance)
 386{
 387	struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 388	struct wmi_block *wblock = container_of(wdev, struct wmi_block, dev);
 389
 390	if (ACPI_FAILURE(__query_block(wblock, instance, &out)))
 391		return NULL;
 392
 393	return (union acpi_object *)out.pointer;
 394}
 395EXPORT_SYMBOL_GPL(wmidev_block_query);
 396
 397/**
 398 * wmi_set_block - Write to a WMI block
 399 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
 400 * @instance: Instance index
 401 * &in: Buffer containing new values for the data block
 402 *
 403 * Write the contents of the input buffer to an ACPI-WMI data block
 404 */
 405acpi_status wmi_set_block(const char *guid_string, u8 instance,
 406			  const struct acpi_buffer *in)
 407{
 408	struct guid_block *block = NULL;
 409	struct wmi_block *wblock = NULL;
 410	acpi_handle handle;
 411	struct acpi_object_list input;
 412	union acpi_object params[2];
 413	char method[5] = "WS";
 414
 415	if (!guid_string || !in)
 416		return AE_BAD_DATA;
 417
 418	if (!find_guid(guid_string, &wblock))
 419		return AE_ERROR;
 420
 421	block = &wblock->gblock;
 422	handle = wblock->acpi_device->handle;
 423
 424	if (block->instance_count <= instance)
 425		return AE_BAD_PARAMETER;
 426
 427	/* Check GUID is a data block */
 428	if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD))
 429		return AE_ERROR;
 430
 431	input.count = 2;
 432	input.pointer = params;
 433	params[0].type = ACPI_TYPE_INTEGER;
 434	params[0].integer.value = instance;
 435
 436	if (block->flags & ACPI_WMI_STRING) {
 437		params[1].type = ACPI_TYPE_STRING;
 438	} else {
 439		params[1].type = ACPI_TYPE_BUFFER;
 440	}
 441	params[1].buffer.length = in->length;
 442	params[1].buffer.pointer = in->pointer;
 443
 444	strncat(method, block->object_id, 2);
 445
 446	return acpi_evaluate_object(handle, method, &input, NULL);
 447}
 448EXPORT_SYMBOL_GPL(wmi_set_block);
 449
 450static void wmi_dump_wdg(const struct guid_block *g)
 451{
 452	pr_info("%pUL:\n", g->guid);
 453	if (g->flags & ACPI_WMI_EVENT)
 454		pr_info("\tnotify_id: 0x%02X\n", g->notify_id);
 455	else
 456		pr_info("\tobject_id: %2pE\n", g->object_id);
 457	pr_info("\tinstance_count: %d\n", g->instance_count);
 458	pr_info("\tflags: %#x", g->flags);
 459	if (g->flags) {
 460		if (g->flags & ACPI_WMI_EXPENSIVE)
 461			pr_cont(" ACPI_WMI_EXPENSIVE");
 462		if (g->flags & ACPI_WMI_METHOD)
 463			pr_cont(" ACPI_WMI_METHOD");
 464		if (g->flags & ACPI_WMI_STRING)
 465			pr_cont(" ACPI_WMI_STRING");
 466		if (g->flags & ACPI_WMI_EVENT)
 467			pr_cont(" ACPI_WMI_EVENT");
 468	}
 469	pr_cont("\n");
 470
 471}
 472
 473static void wmi_notify_debug(u32 value, void *context)
 474{
 475	struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 476	union acpi_object *obj;
 477	acpi_status status;
 478
 479	status = wmi_get_event_data(value, &response);
 480	if (status != AE_OK) {
 481		pr_info("bad event status 0x%x\n", status);
 482		return;
 483	}
 484
 485	obj = (union acpi_object *)response.pointer;
 486
 487	if (!obj)
 488		return;
 489
 490	pr_info("DEBUG Event ");
 491	switch(obj->type) {
 492	case ACPI_TYPE_BUFFER:
 493		pr_cont("BUFFER_TYPE - length %d\n", obj->buffer.length);
 494		break;
 495	case ACPI_TYPE_STRING:
 496		pr_cont("STRING_TYPE - %s\n", obj->string.pointer);
 497		break;
 498	case ACPI_TYPE_INTEGER:
 499		pr_cont("INTEGER_TYPE - %llu\n", obj->integer.value);
 500		break;
 501	case ACPI_TYPE_PACKAGE:
 502		pr_cont("PACKAGE_TYPE - %d elements\n", obj->package.count);
 503		break;
 504	default:
 505		pr_cont("object type 0x%X\n", obj->type);
 506	}
 507	kfree(obj);
 508}
 509
 510/**
 511 * wmi_install_notify_handler - Register handler for WMI events
 
 512 * @handler: Function to handle notifications
 513 * @data: Data to be returned to handler when event is fired
 514 *
 515 * Register a handler for events sent to the ACPI-WMI mapper device.
 516 */
 517acpi_status wmi_install_notify_handler(const char *guid,
 518wmi_notify_handler handler, void *data)
 519{
 520	struct wmi_block *block;
 521	acpi_status status = AE_NOT_EXIST;
 522	uuid_le guid_input;
 523
 524	if (!guid || !handler)
 525		return AE_BAD_PARAMETER;
 526
 527	if (uuid_le_to_bin(guid, &guid_input))
 528		return AE_BAD_PARAMETER;
 529
 530	list_for_each_entry(block, &wmi_block_list, list) {
 531		acpi_status wmi_status;
 532
 533		if (memcmp(block->gblock.guid, &guid_input, 16) == 0) {
 534			if (block->handler &&
 535			    block->handler != wmi_notify_debug)
 536				return AE_ALREADY_ACQUIRED;
 537
 538			block->handler = handler;
 539			block->handler_data = data;
 540
 541			wmi_status = wmi_method_enable(block, 1);
 542			if ((wmi_status != AE_OK) ||
 543			    ((wmi_status == AE_OK) && (status == AE_NOT_EXIST)))
 544				status = wmi_status;
 545		}
 546	}
 547
 548	return status;
 549}
 550EXPORT_SYMBOL_GPL(wmi_install_notify_handler);
 551
 552/**
 553 * wmi_uninstall_notify_handler - Unregister handler for WMI events
 
 554 *
 555 * Unregister handler for events sent to the ACPI-WMI mapper device.
 556 */
 557acpi_status wmi_remove_notify_handler(const char *guid)
 558{
 559	struct wmi_block *block;
 560	acpi_status status = AE_NOT_EXIST;
 561	uuid_le guid_input;
 562
 563	if (!guid)
 564		return AE_BAD_PARAMETER;
 565
 566	if (uuid_le_to_bin(guid, &guid_input))
 567		return AE_BAD_PARAMETER;
 568
 569	list_for_each_entry(block, &wmi_block_list, list) {
 570		acpi_status wmi_status;
 571
 572		if (memcmp(block->gblock.guid, &guid_input, 16) == 0) {
 573			if (!block->handler ||
 574			    block->handler == wmi_notify_debug)
 575				return AE_NULL_ENTRY;
 576
 577			if (debug_event) {
 578				block->handler = wmi_notify_debug;
 579				status = AE_OK;
 580			} else {
 581				wmi_status = wmi_method_enable(block, 0);
 582				block->handler = NULL;
 583				block->handler_data = NULL;
 584				if ((wmi_status != AE_OK) ||
 585				    ((wmi_status == AE_OK) &&
 586				     (status == AE_NOT_EXIST)))
 587					status = wmi_status;
 588			}
 589		}
 590	}
 591
 592	return status;
 593}
 594EXPORT_SYMBOL_GPL(wmi_remove_notify_handler);
 595
 596/**
 597 * wmi_get_event_data - Get WMI data associated with an event
 598 *
 599 * @event: Event to find
 600 * @out: Buffer to hold event data. out->pointer should be freed with kfree()
 601 *
 602 * Returns extra data associated with an event in WMI.
 603 */
 604acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out)
 605{
 606	struct acpi_object_list input;
 607	union acpi_object params[1];
 608	struct guid_block *gblock;
 609	struct wmi_block *wblock;
 610
 611	input.count = 1;
 612	input.pointer = params;
 613	params[0].type = ACPI_TYPE_INTEGER;
 614	params[0].integer.value = event;
 615
 616	list_for_each_entry(wblock, &wmi_block_list, list) {
 617		gblock = &wblock->gblock;
 618
 619		if ((gblock->flags & ACPI_WMI_EVENT) &&
 620			(gblock->notify_id == event))
 621			return acpi_evaluate_object(wblock->acpi_device->handle,
 622				"_WED", &input, out);
 623	}
 624
 625	return AE_NOT_FOUND;
 626}
 627EXPORT_SYMBOL_GPL(wmi_get_event_data);
 628
 629/**
 630 * wmi_has_guid - Check if a GUID is available
 631 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
 632 *
 633 * Check if a given GUID is defined by _WDG
 634 */
 635bool wmi_has_guid(const char *guid_string)
 636{
 637	return find_guid(guid_string, NULL);
 638}
 639EXPORT_SYMBOL_GPL(wmi_has_guid);
 640
 641/**
 642 * wmi_get_acpi_device_uid() - Get _UID name of ACPI device that defines GUID
 643 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
 644 *
 645 * Find the _UID of ACPI device associated with this WMI GUID.
 646 *
 647 * Return: The ACPI _UID field value or NULL if the WMI GUID was not found
 648 */
 649char *wmi_get_acpi_device_uid(const char *guid_string)
 650{
 651	struct wmi_block *wblock = NULL;
 652
 653	if (!find_guid(guid_string, &wblock))
 654		return NULL;
 655
 656	return acpi_device_uid(wblock->acpi_device);
 657}
 658EXPORT_SYMBOL_GPL(wmi_get_acpi_device_uid);
 659
 660static struct wmi_block *dev_to_wblock(struct device *dev)
 661{
 662	return container_of(dev, struct wmi_block, dev.dev);
 663}
 664
 665static struct wmi_device *dev_to_wdev(struct device *dev)
 666{
 667	return container_of(dev, struct wmi_device, dev);
 668}
 669
 670/*
 671 * sysfs interface
 672 */
 673static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 674			     char *buf)
 675{
 676	struct wmi_block *wblock = dev_to_wblock(dev);
 677
 678	return sprintf(buf, "wmi:%pUL\n", wblock->gblock.guid);
 679}
 680static DEVICE_ATTR_RO(modalias);
 681
 682static ssize_t guid_show(struct device *dev, struct device_attribute *attr,
 683			 char *buf)
 684{
 685	struct wmi_block *wblock = dev_to_wblock(dev);
 686
 687	return sprintf(buf, "%pUL\n", wblock->gblock.guid);
 688}
 689static DEVICE_ATTR_RO(guid);
 690
 691static ssize_t instance_count_show(struct device *dev,
 692				   struct device_attribute *attr, char *buf)
 693{
 694	struct wmi_block *wblock = dev_to_wblock(dev);
 695
 696	return sprintf(buf, "%d\n", (int)wblock->gblock.instance_count);
 697}
 698static DEVICE_ATTR_RO(instance_count);
 699
 700static ssize_t expensive_show(struct device *dev,
 701			      struct device_attribute *attr, char *buf)
 702{
 703	struct wmi_block *wblock = dev_to_wblock(dev);
 704
 705	return sprintf(buf, "%d\n",
 706		       (wblock->gblock.flags & ACPI_WMI_EXPENSIVE) != 0);
 707}
 708static DEVICE_ATTR_RO(expensive);
 709
 710static struct attribute *wmi_attrs[] = {
 711	&dev_attr_modalias.attr,
 712	&dev_attr_guid.attr,
 713	&dev_attr_instance_count.attr,
 714	&dev_attr_expensive.attr,
 715	NULL,
 716};
 717ATTRIBUTE_GROUPS(wmi);
 718
 719static ssize_t notify_id_show(struct device *dev, struct device_attribute *attr,
 720			      char *buf)
 721{
 722	struct wmi_block *wblock = dev_to_wblock(dev);
 723
 724	return sprintf(buf, "%02X\n", (unsigned int)wblock->gblock.notify_id);
 725}
 726static DEVICE_ATTR_RO(notify_id);
 727
 728static struct attribute *wmi_event_attrs[] = {
 729	&dev_attr_notify_id.attr,
 730	NULL,
 731};
 732ATTRIBUTE_GROUPS(wmi_event);
 733
 734static ssize_t object_id_show(struct device *dev, struct device_attribute *attr,
 735			      char *buf)
 736{
 737	struct wmi_block *wblock = dev_to_wblock(dev);
 738
 739	return sprintf(buf, "%c%c\n", wblock->gblock.object_id[0],
 740		       wblock->gblock.object_id[1]);
 741}
 742static DEVICE_ATTR_RO(object_id);
 743
 744static ssize_t setable_show(struct device *dev, struct device_attribute *attr,
 745			    char *buf)
 746{
 747	struct wmi_device *wdev = dev_to_wdev(dev);
 748
 749	return sprintf(buf, "%d\n", (int)wdev->setable);
 750}
 751static DEVICE_ATTR_RO(setable);
 752
 753static struct attribute *wmi_data_attrs[] = {
 754	&dev_attr_object_id.attr,
 755	&dev_attr_setable.attr,
 756	NULL,
 757};
 758ATTRIBUTE_GROUPS(wmi_data);
 759
 760static struct attribute *wmi_method_attrs[] = {
 761	&dev_attr_object_id.attr,
 762	NULL,
 763};
 764ATTRIBUTE_GROUPS(wmi_method);
 765
 766static int wmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 767{
 768	struct wmi_block *wblock = dev_to_wblock(dev);
 769
 770	if (add_uevent_var(env, "MODALIAS=wmi:%pUL", wblock->gblock.guid))
 771		return -ENOMEM;
 772
 773	if (add_uevent_var(env, "WMI_GUID=%pUL", wblock->gblock.guid))
 774		return -ENOMEM;
 775
 776	return 0;
 777}
 778
 779static void wmi_dev_release(struct device *dev)
 780{
 781	struct wmi_block *wblock = dev_to_wblock(dev);
 782
 783	kfree(wblock);
 784}
 785
 786static int wmi_dev_match(struct device *dev, struct device_driver *driver)
 787{
 788	struct wmi_driver *wmi_driver =
 789		container_of(driver, struct wmi_driver, driver);
 790	struct wmi_block *wblock = dev_to_wblock(dev);
 791	const struct wmi_device_id *id = wmi_driver->id_table;
 792
 793	if (id == NULL)
 794		return 0;
 795
 796	while (*id->guid_string) {
 797		uuid_le driver_guid;
 798
 799		if (WARN_ON(uuid_le_to_bin(id->guid_string, &driver_guid)))
 800			continue;
 801		if (!memcmp(&driver_guid, wblock->gblock.guid, 16))
 802			return 1;
 803
 804		id++;
 805	}
 806
 807	return 0;
 808}
 809static int wmi_char_open(struct inode *inode, struct file *filp)
 810{
 811	const char *driver_name = filp->f_path.dentry->d_iname;
 812	struct wmi_block *wblock = NULL;
 813	struct wmi_block *next = NULL;
 814
 815	list_for_each_entry_safe(wblock, next, &wmi_block_list, list) {
 816		if (!wblock->dev.dev.driver)
 817			continue;
 818		if (strcmp(driver_name, wblock->dev.dev.driver->name) == 0) {
 819			filp->private_data = wblock;
 820			break;
 821		}
 822	}
 823
 824	if (!filp->private_data)
 825		return -ENODEV;
 826
 827	return nonseekable_open(inode, filp);
 828}
 829
 830static ssize_t wmi_char_read(struct file *filp, char __user *buffer,
 831	size_t length, loff_t *offset)
 832{
 833	struct wmi_block *wblock = filp->private_data;
 834
 835	return simple_read_from_buffer(buffer, length, offset,
 836				       &wblock->req_buf_size,
 837				       sizeof(wblock->req_buf_size));
 838}
 839
 840static long wmi_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 841{
 842	struct wmi_ioctl_buffer __user *input =
 843		(struct wmi_ioctl_buffer __user *) arg;
 844	struct wmi_block *wblock = filp->private_data;
 845	struct wmi_ioctl_buffer *buf = NULL;
 846	struct wmi_driver *wdriver = NULL;
 847	int ret;
 848
 849	if (_IOC_TYPE(cmd) != WMI_IOC)
 850		return -ENOTTY;
 851
 852	/* make sure we're not calling a higher instance than exists*/
 853	if (_IOC_NR(cmd) >= wblock->gblock.instance_count)
 854		return -EINVAL;
 855
 856	mutex_lock(&wblock->char_mutex);
 857	buf = wblock->handler_data;
 858	if (get_user(buf->length, &input->length)) {
 859		dev_dbg(&wblock->dev.dev, "Read length from user failed\n");
 860		ret = -EFAULT;
 861		goto out_ioctl;
 862	}
 863	/* if it's too small, abort */
 864	if (buf->length < wblock->req_buf_size) {
 865		dev_err(&wblock->dev.dev,
 866			"Buffer %lld too small, need at least %lld\n",
 867			buf->length, wblock->req_buf_size);
 868		ret = -EINVAL;
 869		goto out_ioctl;
 870	}
 871	/* if it's too big, warn, driver will only use what is needed */
 872	if (buf->length > wblock->req_buf_size)
 873		dev_warn(&wblock->dev.dev,
 874			"Buffer %lld is bigger than required %lld\n",
 875			buf->length, wblock->req_buf_size);
 876
 877	/* copy the structure from userspace */
 878	if (copy_from_user(buf, input, wblock->req_buf_size)) {
 879		dev_dbg(&wblock->dev.dev, "Copy %llu from user failed\n",
 880			wblock->req_buf_size);
 881		ret = -EFAULT;
 882		goto out_ioctl;
 883	}
 884
 885	/* let the driver do any filtering and do the call */
 886	wdriver = container_of(wblock->dev.dev.driver,
 887			       struct wmi_driver, driver);
 888	if (!try_module_get(wdriver->driver.owner)) {
 889		ret = -EBUSY;
 890		goto out_ioctl;
 891	}
 892	ret = wdriver->filter_callback(&wblock->dev, cmd, buf);
 893	module_put(wdriver->driver.owner);
 894	if (ret)
 895		goto out_ioctl;
 896
 897	/* return the result (only up to our internal buffer size) */
 898	if (copy_to_user(input, buf, wblock->req_buf_size)) {
 899		dev_dbg(&wblock->dev.dev, "Copy %llu to user failed\n",
 900			wblock->req_buf_size);
 901		ret = -EFAULT;
 902	}
 903
 904out_ioctl:
 905	mutex_unlock(&wblock->char_mutex);
 906	return ret;
 907}
 908
 909static const struct file_operations wmi_fops = {
 910	.owner		= THIS_MODULE,
 911	.read		= wmi_char_read,
 912	.open		= wmi_char_open,
 913	.unlocked_ioctl	= wmi_ioctl,
 914	.compat_ioctl	= wmi_ioctl,
 915};
 916
 917static int wmi_dev_probe(struct device *dev)
 918{
 919	struct wmi_block *wblock = dev_to_wblock(dev);
 920	struct wmi_driver *wdriver =
 921		container_of(dev->driver, struct wmi_driver, driver);
 922	int ret = 0;
 923	char *buf;
 924
 925	if (ACPI_FAILURE(wmi_method_enable(wblock, 1)))
 926		dev_warn(dev, "failed to enable device -- probing anyway\n");
 927
 928	if (wdriver->probe) {
 929		ret = wdriver->probe(dev_to_wdev(dev),
 930				find_guid_context(wblock, wdriver));
 931		if (ret != 0)
 932			goto probe_failure;
 933	}
 934
 935	/* driver wants a character device made */
 936	if (wdriver->filter_callback) {
 937		/* check that required buffer size declared by driver or MOF */
 938		if (!wblock->req_buf_size) {
 939			dev_err(&wblock->dev.dev,
 940				"Required buffer size not set\n");
 941			ret = -EINVAL;
 942			goto probe_failure;
 943		}
 944
 945		wblock->handler_data = kmalloc(wblock->req_buf_size,
 946					       GFP_KERNEL);
 947		if (!wblock->handler_data) {
 948			ret = -ENOMEM;
 949			goto probe_failure;
 950		}
 951
 952		buf = kasprintf(GFP_KERNEL, "wmi/%s", wdriver->driver.name);
 953		if (!buf) {
 954			ret = -ENOMEM;
 955			goto probe_string_failure;
 956		}
 957		wblock->char_dev.minor = MISC_DYNAMIC_MINOR;
 958		wblock->char_dev.name = buf;
 959		wblock->char_dev.fops = &wmi_fops;
 960		wblock->char_dev.mode = 0444;
 961		ret = misc_register(&wblock->char_dev);
 962		if (ret) {
 963			dev_warn(dev, "failed to register char dev: %d\n", ret);
 964			ret = -ENOMEM;
 965			goto probe_misc_failure;
 966		}
 967	}
 968
 969	return 0;
 970
 971probe_misc_failure:
 972	kfree(buf);
 973probe_string_failure:
 974	kfree(wblock->handler_data);
 975probe_failure:
 976	if (ACPI_FAILURE(wmi_method_enable(wblock, 0)))
 977		dev_warn(dev, "failed to disable device\n");
 978	return ret;
 979}
 980
 981static int wmi_dev_remove(struct device *dev)
 982{
 983	struct wmi_block *wblock = dev_to_wblock(dev);
 984	struct wmi_driver *wdriver =
 985		container_of(dev->driver, struct wmi_driver, driver);
 986	int ret = 0;
 987
 988	if (wdriver->filter_callback) {
 989		misc_deregister(&wblock->char_dev);
 990		kfree(wblock->char_dev.name);
 991		kfree(wblock->handler_data);
 992	}
 993
 994	if (wdriver->remove)
 995		ret = wdriver->remove(dev_to_wdev(dev));
 996
 997	if (ACPI_FAILURE(wmi_method_enable(wblock, 0)))
 998		dev_warn(dev, "failed to disable device\n");
 999
1000	return ret;
1001}
1002
1003static struct class wmi_bus_class = {
1004	.name = "wmi_bus",
1005};
1006
1007static struct bus_type wmi_bus_type = {
1008	.name = "wmi",
1009	.dev_groups = wmi_groups,
1010	.match = wmi_dev_match,
1011	.uevent = wmi_dev_uevent,
1012	.probe = wmi_dev_probe,
1013	.remove = wmi_dev_remove,
1014};
1015
1016static const struct device_type wmi_type_event = {
1017	.name = "event",
1018	.groups = wmi_event_groups,
1019	.release = wmi_dev_release,
1020};
1021
1022static const struct device_type wmi_type_method = {
1023	.name = "method",
1024	.groups = wmi_method_groups,
1025	.release = wmi_dev_release,
1026};
1027
1028static const struct device_type wmi_type_data = {
1029	.name = "data",
1030	.groups = wmi_data_groups,
1031	.release = wmi_dev_release,
1032};
1033
1034static int wmi_create_device(struct device *wmi_bus_dev,
1035			     const struct guid_block *gblock,
1036			     struct wmi_block *wblock,
1037			     struct acpi_device *device)
1038{
1039	struct acpi_device_info *info;
1040	char method[5];
1041	int result;
1042
1043	if (gblock->flags & ACPI_WMI_EVENT) {
1044		wblock->dev.dev.type = &wmi_type_event;
1045		goto out_init;
1046	}
1047
1048	if (gblock->flags & ACPI_WMI_METHOD) {
1049		wblock->dev.dev.type = &wmi_type_method;
1050		mutex_init(&wblock->char_mutex);
1051		goto out_init;
1052	}
1053
1054	/*
1055	 * Data Block Query Control Method (WQxx by convention) is
1056	 * required per the WMI documentation. If it is not present,
1057	 * we ignore this data block.
1058	 */
1059	strcpy(method, "WQ");
1060	strncat(method, wblock->gblock.object_id, 2);
1061	result = get_subobj_info(device->handle, method, &info);
1062
1063	if (result) {
1064		dev_warn(wmi_bus_dev,
1065			 "%s data block query control method not found\n",
1066			 method);
1067		return result;
1068	}
1069
1070	wblock->dev.dev.type = &wmi_type_data;
1071
1072	/*
1073	 * The Microsoft documentation specifically states:
1074	 *
1075	 *   Data blocks registered with only a single instance
1076	 *   can ignore the parameter.
1077	 *
1078	 * ACPICA will get mad at us if we call the method with the wrong number
1079	 * of arguments, so check what our method expects.  (On some Dell
1080	 * laptops, WQxx may not be a method at all.)
1081	 */
1082	if (info->type != ACPI_TYPE_METHOD || info->param_count == 0)
1083		wblock->read_takes_no_args = true;
1084
1085	kfree(info);
1086
1087	strcpy(method, "WS");
1088	strncat(method, wblock->gblock.object_id, 2);
1089	result = get_subobj_info(device->handle, method, NULL);
1090
1091	if (result == 0)
1092		wblock->dev.setable = true;
1093
1094 out_init:
1095	wblock->dev.dev.bus = &wmi_bus_type;
1096	wblock->dev.dev.parent = wmi_bus_dev;
1097
1098	dev_set_name(&wblock->dev.dev, "%pUL", gblock->guid);
1099
1100	device_initialize(&wblock->dev.dev);
1101
1102	return 0;
1103}
1104
1105static void wmi_free_devices(struct acpi_device *device)
1106{
1107	struct wmi_block *wblock, *next;
1108
1109	/* Delete devices for all the GUIDs */
1110	list_for_each_entry_safe(wblock, next, &wmi_block_list, list) {
1111		if (wblock->acpi_device == device) {
1112			list_del(&wblock->list);
1113			device_unregister(&wblock->dev.dev);
1114		}
1115	}
1116}
1117
1118static bool guid_already_parsed(struct acpi_device *device,
1119				const u8 *guid)
1120{
1121	struct wmi_block *wblock;
1122
1123	list_for_each_entry(wblock, &wmi_block_list, list) {
1124		if (memcmp(wblock->gblock.guid, guid, 16) == 0) {
1125			/*
1126			 * Because we historically didn't track the relationship
1127			 * between GUIDs and ACPI nodes, we don't know whether
1128			 * we need to suppress GUIDs that are unique on a
1129			 * given node but duplicated across nodes.
1130			 */
1131			dev_warn(&device->dev, "duplicate WMI GUID %pUL (first instance was on %s)\n",
1132				 guid, dev_name(&wblock->acpi_device->dev));
1133			return true;
1134		}
1135	}
1136
1137	return false;
1138}
1139
1140/*
1141 * Parse the _WDG method for the GUID data blocks
1142 */
1143static int parse_wdg(struct device *wmi_bus_dev, struct acpi_device *device)
1144{
1145	struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
1146	const struct guid_block *gblock;
1147	struct wmi_block *wblock, *next;
1148	union acpi_object *obj;
1149	acpi_status status;
1150	int retval = 0;
1151	u32 i, total;
1152
1153	status = acpi_evaluate_object(device->handle, "_WDG", NULL, &out);
1154	if (ACPI_FAILURE(status))
1155		return -ENXIO;
1156
1157	obj = (union acpi_object *) out.pointer;
1158	if (!obj)
1159		return -ENXIO;
1160
1161	if (obj->type != ACPI_TYPE_BUFFER) {
1162		retval = -ENXIO;
1163		goto out_free_pointer;
1164	}
1165
1166	gblock = (const struct guid_block *)obj->buffer.pointer;
1167	total = obj->buffer.length / sizeof(struct guid_block);
1168
1169	for (i = 0; i < total; i++) {
1170		if (debug_dump_wdg)
1171			wmi_dump_wdg(&gblock[i]);
1172
1173		/*
1174		 * Some WMI devices, like those for nVidia hooks, have a
1175		 * duplicate GUID. It's not clear what we should do in this
1176		 * case yet, so for now, we'll just ignore the duplicate
1177		 * for device creation.
1178		 */
1179		if (guid_already_parsed(device, gblock[i].guid))
1180			continue;
1181
1182		wblock = kzalloc(sizeof(struct wmi_block), GFP_KERNEL);
1183		if (!wblock) {
1184			retval = -ENOMEM;
1185			break;
1186		}
1187
1188		wblock->acpi_device = device;
1189		wblock->gblock = gblock[i];
1190
1191		retval = wmi_create_device(wmi_bus_dev, &gblock[i], wblock, device);
1192		if (retval) {
1193			kfree(wblock);
1194			continue;
1195		}
1196
1197		list_add_tail(&wblock->list, &wmi_block_list);
1198
1199		if (debug_event) {
1200			wblock->handler = wmi_notify_debug;
1201			wmi_method_enable(wblock, 1);
1202		}
1203	}
1204
1205	/*
1206	 * Now that all of the devices are created, add them to the
1207	 * device tree and probe subdrivers.
1208	 */
1209	list_for_each_entry_safe(wblock, next, &wmi_block_list, list) {
1210		if (wblock->acpi_device != device)
1211			continue;
1212
1213		retval = device_add(&wblock->dev.dev);
1214		if (retval) {
1215			dev_err(wmi_bus_dev, "failed to register %pUL\n",
1216				wblock->gblock.guid);
1217			if (debug_event)
1218				wmi_method_enable(wblock, 0);
1219			list_del(&wblock->list);
1220			put_device(&wblock->dev.dev);
1221		}
1222	}
1223
1224out_free_pointer:
1225	kfree(out.pointer);
1226	return retval;
1227}
1228
1229/*
1230 * WMI can have EmbeddedControl access regions. In which case, we just want to
1231 * hand these off to the EC driver.
1232 */
1233static acpi_status
1234acpi_wmi_ec_space_handler(u32 function, acpi_physical_address address,
1235		      u32 bits, u64 *value,
1236		      void *handler_context, void *region_context)
1237{
1238	int result = 0, i = 0;
1239	u8 temp = 0;
1240
1241	if ((address > 0xFF) || !value)
1242		return AE_BAD_PARAMETER;
1243
1244	if (function != ACPI_READ && function != ACPI_WRITE)
1245		return AE_BAD_PARAMETER;
1246
1247	if (bits != 8)
1248		return AE_BAD_PARAMETER;
1249
1250	if (function == ACPI_READ) {
1251		result = ec_read(address, &temp);
1252		(*value) |= ((u64)temp) << i;
1253	} else {
1254		temp = 0xff & ((*value) >> i);
1255		result = ec_write(address, temp);
1256	}
1257
1258	switch (result) {
1259	case -EINVAL:
1260		return AE_BAD_PARAMETER;
1261		break;
1262	case -ENODEV:
1263		return AE_NOT_FOUND;
1264		break;
1265	case -ETIME:
1266		return AE_TIME;
1267		break;
1268	default:
1269		return AE_OK;
1270	}
1271}
1272
1273static void acpi_wmi_notify_handler(acpi_handle handle, u32 event,
1274				    void *context)
1275{
1276	struct guid_block *block;
1277	struct wmi_block *wblock;
1278	bool found_it = false;
1279
1280	list_for_each_entry(wblock, &wmi_block_list, list) {
1281		block = &wblock->gblock;
1282
1283		if (wblock->acpi_device->handle == handle &&
1284		    (block->flags & ACPI_WMI_EVENT) &&
1285		    (block->notify_id == event))
1286		{
1287			found_it = true;
1288			break;
1289		}
1290	}
1291
1292	if (!found_it)
1293		return;
1294
1295	/* If a driver is bound, then notify the driver. */
1296	if (wblock->dev.dev.driver) {
1297		struct wmi_driver *driver;
1298		struct acpi_object_list input;
1299		union acpi_object params[1];
1300		struct acpi_buffer evdata = { ACPI_ALLOCATE_BUFFER, NULL };
1301		acpi_status status;
1302
1303		driver = container_of(wblock->dev.dev.driver,
1304				      struct wmi_driver, driver);
1305
1306		input.count = 1;
1307		input.pointer = params;
1308		params[0].type = ACPI_TYPE_INTEGER;
1309		params[0].integer.value = event;
1310
1311		status = acpi_evaluate_object(wblock->acpi_device->handle,
1312					      "_WED", &input, &evdata);
1313		if (ACPI_FAILURE(status)) {
1314			dev_warn(&wblock->dev.dev,
1315				 "failed to get event data\n");
1316			return;
1317		}
1318
1319		if (driver->notify)
1320			driver->notify(&wblock->dev,
1321				       (union acpi_object *)evdata.pointer);
1322
1323		kfree(evdata.pointer);
1324	} else if (wblock->handler) {
1325		/* Legacy handler */
1326		wblock->handler(event, wblock->handler_data);
1327	}
1328
1329	if (debug_event) {
1330		pr_info("DEBUG Event GUID: %pUL\n",
1331			wblock->gblock.guid);
1332	}
1333
1334	acpi_bus_generate_netlink_event(
1335		wblock->acpi_device->pnp.device_class,
1336		dev_name(&wblock->dev.dev),
1337		event, 0);
1338
1339}
1340
1341static int acpi_wmi_remove(struct platform_device *device)
1342{
1343	struct acpi_device *acpi_device = ACPI_COMPANION(&device->dev);
1344
1345	acpi_remove_notify_handler(acpi_device->handle, ACPI_DEVICE_NOTIFY,
1346				   acpi_wmi_notify_handler);
1347	acpi_remove_address_space_handler(acpi_device->handle,
1348				ACPI_ADR_SPACE_EC, &acpi_wmi_ec_space_handler);
1349	wmi_free_devices(acpi_device);
1350	device_destroy(&wmi_bus_class, MKDEV(0, 0));
1351
1352	return 0;
1353}
1354
1355static int acpi_wmi_probe(struct platform_device *device)
1356{
1357	struct acpi_device *acpi_device;
1358	struct device *wmi_bus_dev;
1359	acpi_status status;
1360	int error;
1361
1362	acpi_device = ACPI_COMPANION(&device->dev);
1363	if (!acpi_device) {
1364		dev_err(&device->dev, "ACPI companion is missing\n");
1365		return -ENODEV;
1366	}
1367
1368	status = acpi_install_address_space_handler(acpi_device->handle,
1369						    ACPI_ADR_SPACE_EC,
1370						    &acpi_wmi_ec_space_handler,
1371						    NULL, NULL);
1372	if (ACPI_FAILURE(status)) {
1373		dev_err(&device->dev, "Error installing EC region handler\n");
1374		return -ENODEV;
1375	}
1376
1377	status = acpi_install_notify_handler(acpi_device->handle,
1378					     ACPI_DEVICE_NOTIFY,
1379					     acpi_wmi_notify_handler,
1380					     NULL);
1381	if (ACPI_FAILURE(status)) {
1382		dev_err(&device->dev, "Error installing notify handler\n");
1383		error = -ENODEV;
1384		goto err_remove_ec_handler;
1385	}
1386
1387	wmi_bus_dev = device_create(&wmi_bus_class, &device->dev, MKDEV(0, 0),
1388				    NULL, "wmi_bus-%s", dev_name(&device->dev));
1389	if (IS_ERR(wmi_bus_dev)) {
1390		error = PTR_ERR(wmi_bus_dev);
1391		goto err_remove_notify_handler;
1392	}
1393	dev_set_drvdata(&device->dev, wmi_bus_dev);
1394
1395	error = parse_wdg(wmi_bus_dev, acpi_device);
1396	if (error) {
1397		pr_err("Failed to parse WDG method\n");
1398		goto err_remove_busdev;
1399	}
1400
1401	return 0;
1402
1403err_remove_busdev:
1404	device_destroy(&wmi_bus_class, MKDEV(0, 0));
1405
1406err_remove_notify_handler:
1407	acpi_remove_notify_handler(acpi_device->handle, ACPI_DEVICE_NOTIFY,
1408				   acpi_wmi_notify_handler);
1409
1410err_remove_ec_handler:
1411	acpi_remove_address_space_handler(acpi_device->handle,
1412					  ACPI_ADR_SPACE_EC,
1413					  &acpi_wmi_ec_space_handler);
1414
1415	return error;
1416}
1417
1418int __must_check __wmi_driver_register(struct wmi_driver *driver,
1419				       struct module *owner)
1420{
1421	driver->driver.owner = owner;
1422	driver->driver.bus = &wmi_bus_type;
1423
1424	return driver_register(&driver->driver);
1425}
1426EXPORT_SYMBOL(__wmi_driver_register);
1427
1428void wmi_driver_unregister(struct wmi_driver *driver)
1429{
1430	driver_unregister(&driver->driver);
1431}
1432EXPORT_SYMBOL(wmi_driver_unregister);
1433
1434static int __init acpi_wmi_init(void)
1435{
1436	int error;
1437
1438	if (acpi_disabled)
1439		return -ENODEV;
1440
1441	error = class_register(&wmi_bus_class);
1442	if (error)
1443		return error;
1444
1445	error = bus_register(&wmi_bus_type);
1446	if (error)
1447		goto err_unreg_class;
1448
1449	error = platform_driver_register(&acpi_wmi_driver);
1450	if (error) {
1451		pr_err("Error loading mapper\n");
1452		goto err_unreg_bus;
1453	}
1454
1455	return 0;
1456
1457err_unreg_bus:
1458	bus_unregister(&wmi_bus_type);
1459
1460err_unreg_class:
1461	class_unregister(&wmi_bus_class);
1462
1463	return error;
1464}
1465
1466static void __exit acpi_wmi_exit(void)
1467{
1468	platform_driver_unregister(&acpi_wmi_driver);
1469	bus_unregister(&wmi_bus_type);
1470	class_unregister(&wmi_bus_class);
1471}
1472
1473subsys_initcall_sync(acpi_wmi_init);
1474module_exit(acpi_wmi_exit);