button.c 17.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds's avatar
Linus Torvalds committed
2
/*
3
 *  button.c - ACPI Button Driver
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 */

9
#define pr_fmt(fmt) "ACPI: button: " fmt
10

11
#include <linux/compiler.h>
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
15 16 17
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
18
#include <linux/input.h>
19
#include <linux/slab.h>
20
#include <linux/acpi.h>
21
#include <linux/dmi.h>
22
#include <acpi/button.h>
Linus Torvalds's avatar
Linus Torvalds committed
23

24 25
#define PREFIX "ACPI: "

Linus Torvalds's avatar
Linus Torvalds committed
26
#define ACPI_BUTTON_CLASS		"button"
27 28 29
#define ACPI_BUTTON_FILE_INFO		"info"
#define ACPI_BUTTON_FILE_STATE		"state"
#define ACPI_BUTTON_TYPE_UNKNOWN	0x00
Linus Torvalds's avatar
Linus Torvalds committed
30 31 32
#define ACPI_BUTTON_NOTIFY_STATUS	0x80

#define ACPI_BUTTON_SUBCLASS_POWER	"power"
Len Brown's avatar
Len Brown committed
33
#define ACPI_BUTTON_HID_POWER		"PNP0C0C"
34
#define ACPI_BUTTON_DEVICE_NAME_POWER	"Power Button"
Linus Torvalds's avatar
Linus Torvalds committed
35 36 37 38
#define ACPI_BUTTON_TYPE_POWER		0x01

#define ACPI_BUTTON_SUBCLASS_SLEEP	"sleep"
#define ACPI_BUTTON_HID_SLEEP		"PNP0C0E"
39
#define ACPI_BUTTON_DEVICE_NAME_SLEEP	"Sleep Button"
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46
#define ACPI_BUTTON_TYPE_SLEEP		0x03

#define ACPI_BUTTON_SUBCLASS_LID	"lid"
#define ACPI_BUTTON_HID_LID		"PNP0C0D"
#define ACPI_BUTTON_DEVICE_NAME_LID	"Lid Switch"
#define ACPI_BUTTON_TYPE_LID		0x05

47 48
#define ACPI_BUTTON_LID_INIT_IGNORE	0x00
#define ACPI_BUTTON_LID_INIT_OPEN	0x01
49
#define ACPI_BUTTON_LID_INIT_METHOD	0x02
50

Linus Torvalds's avatar
Linus Torvalds committed
51
#define _COMPONENT		ACPI_BUTTON_COMPONENT
52
ACPI_MODULE_NAME("button");
Linus Torvalds's avatar
Linus Torvalds committed
53

54
MODULE_AUTHOR("Paul Diefenbaugh");
55
MODULE_DESCRIPTION("ACPI Button Driver");
Linus Torvalds's avatar
Linus Torvalds committed
56 57
MODULE_LICENSE("GPL");

58 59 60 61 62 63 64 65 66 67
static const struct acpi_device_id button_device_ids[] = {
	{ACPI_BUTTON_HID_LID,    0},
	{ACPI_BUTTON_HID_SLEEP,  0},
	{ACPI_BUTTON_HID_SLEEPF, 0},
	{ACPI_BUTTON_HID_POWER,  0},
	{ACPI_BUTTON_HID_POWERF, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, button_device_ids);

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
/*
 * Some devices which don't even have a lid in anyway have a broken _LID
 * method (e.g. pointing to a floating gpio pin) causing spurious LID events.
 */
static const struct dmi_system_id lid_blacklst[] = {
	{
		/* GP-electronic T701 */
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),
			DMI_MATCH(DMI_PRODUCT_NAME, "T701"),
			DMI_MATCH(DMI_BIOS_VERSION, "BYT70A.YNCHENG.WIN.007"),
		},
	},
	{}
};

Len Brown's avatar
Len Brown committed
84
static int acpi_button_add(struct acpi_device *device);
85
static int acpi_button_remove(struct acpi_device *device);
86
static void acpi_button_notify(struct acpi_device *device, u32 event);
Linus Torvalds's avatar
Linus Torvalds committed
87

88
#ifdef CONFIG_PM_SLEEP
89
static int acpi_button_suspend(struct device *dev);
90
static int acpi_button_resume(struct device *dev);
91
#else
92
#define acpi_button_suspend NULL
93
#define acpi_button_resume NULL
94
#endif
95
static SIMPLE_DEV_PM_OPS(acpi_button_pm, acpi_button_suspend, acpi_button_resume);
96

Linus Torvalds's avatar
Linus Torvalds committed
97
static struct acpi_driver acpi_button_driver = {
Len Brown's avatar
Len Brown committed
98
	.name = "button",
Len Brown's avatar
Len Brown committed
99
	.class = ACPI_BUTTON_CLASS,
100
	.ids = button_device_ids,
Len Brown's avatar
Len Brown committed
101 102 103
	.ops = {
		.add = acpi_button_add,
		.remove = acpi_button_remove,
104
		.notify = acpi_button_notify,
105
	},
106
	.drv.pm = &acpi_button_pm,
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109
};

struct acpi_button {
110 111 112
	unsigned int type;
	struct input_dev *input;
	char phys[32];			/* for input device */
Len Brown's avatar
Len Brown committed
113
	unsigned long pushed;
114 115
	int last_state;
	ktime_t last_time;
116
	bool suspended;
Linus Torvalds's avatar
Linus Torvalds committed
117 118
};

119 120
static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier);
static struct acpi_device *lid_device;
121
static u8 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD;
122

123 124 125 126
static unsigned long lid_report_interval __read_mostly = 500;
module_param(lid_report_interval, ulong, 0644);
MODULE_PARM_DESC(lid_report_interval, "Interval (ms) between lid key events");

127 128 129 130
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

Len Brown's avatar
Len Brown committed
131
static struct proc_dir_entry *acpi_button_dir;
132
static struct proc_dir_entry *acpi_lid_dir;
Len Brown's avatar
Len Brown committed
133

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
static int acpi_lid_evaluate_state(struct acpi_device *device)
{
	unsigned long long lid_state;
	acpi_status status;

	status = acpi_evaluate_integer(device->handle, "_LID", NULL, &lid_state);
	if (ACPI_FAILURE(status))
		return -ENODEV;

	return lid_state ? 1 : 0;
}

static int acpi_lid_notify_state(struct acpi_device *device, int state)
{
	struct acpi_button *button = acpi_driver_data(device);
	int ret;
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
	ktime_t next_report;
	bool do_update;

	/*
	 * In lid_init_state=ignore mode, if user opens/closes lid
	 * frequently with "open" missing, and "last_time" is also updated
	 * frequently, "close" cannot be delivered to the userspace.
	 * So "last_time" is only updated after a timeout or an actual
	 * switch.
	 */
	if (lid_init_state != ACPI_BUTTON_LID_INIT_IGNORE ||
	    button->last_state != !!state)
		do_update = true;
	else
		do_update = false;

	next_report = ktime_add(button->last_time,
				ms_to_ktime(lid_report_interval));
	if (button->last_state == !!state &&
	    ktime_after(ktime_get(), next_report)) {
		/* Complain the buggy firmware */
		pr_warn_once("The lid device is not compliant to SW_LID.\n");
172

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
		/*
		 * Send the unreliable complement switch event:
		 *
		 * On most platforms, the lid device is reliable. However
		 * there are exceptions:
		 * 1. Platforms returning initial lid state as "close" by
		 *    default after booting/resuming:
		 *     https://bugzilla.kernel.org/show_bug.cgi?id=89211
		 *     https://bugzilla.kernel.org/show_bug.cgi?id=106151
		 * 2. Platforms never reporting "open" events:
		 *     https://bugzilla.kernel.org/show_bug.cgi?id=106941
		 * On these buggy platforms, the usage model of the ACPI
		 * lid device actually is:
		 * 1. The initial returning value of _LID may not be
		 *    reliable.
		 * 2. The open event may not be reliable.
		 * 3. The close event is reliable.
		 *
		 * But SW_LID is typed as input switch event, the input
		 * layer checks if the event is redundant. Hence if the
		 * state is not switched, the userspace cannot see this
		 * platform triggered reliable event. By inserting a
		 * complement switch event, it then is guaranteed that the
		 * platform triggered reliable one can always be seen by
		 * the userspace.
		 */
		if (lid_init_state == ACPI_BUTTON_LID_INIT_IGNORE) {
			do_update = true;
			/*
			 * Do generate complement switch event for "close"
			 * as "close" is reliable and wrong "open" won't
			 * trigger unexpected behaviors.
			 * Do not generate complement switch event for
			 * "open" as "open" is not reliable and wrong
			 * "close" will trigger unexpected behaviors.
			 */
			if (!state) {
				input_report_switch(button->input,
						    SW_LID, state);
				input_sync(button->input);
			}
		}
	}
	/* Send the platform triggered reliable event */
	if (do_update) {
218 219
		acpi_handle_debug(device->handle, "ACPI LID %s\n",
				  state ? "open" : "closed");
220 221 222 223 224
		input_report_switch(button->input, SW_LID, !state);
		input_sync(button->input);
		button->last_state = !!state;
		button->last_time = ktime_get();
	}
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239

	ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
	if (ret == NOTIFY_DONE)
		ret = blocking_notifier_call_chain(&acpi_lid_notifier, state,
						   device);
	if (ret == NOTIFY_DONE || ret == NOTIFY_OK) {
		/*
		 * It is also regarded as success if the notifier_chain
		 * returns NOTIFY_OK or NOTIFY_DONE.
		 */
		ret = 0;
	}
	return ret;
}

240 241
static int __maybe_unused acpi_button_state_seq_show(struct seq_file *seq,
						     void *offset)
242
{
243
	struct acpi_device *device = seq->private;
244
	int state;
245

246
	state = acpi_lid_evaluate_state(device);
247
	seq_printf(seq, "state:      %s\n",
248
		   state < 0 ? "unsupported" : (state ? "open" : "closed"));
249
	return 0;
250 251
}

Len Brown's avatar
Len Brown committed
252
static int acpi_button_add_fs(struct acpi_device *device)
253
{
254
	struct acpi_button *button = acpi_driver_data(device);
Len Brown's avatar
Len Brown committed
255
	struct proc_dir_entry *entry = NULL;
256
	int ret = 0;
257

258 259 260 261 262 263 264
	/* procfs I/F for ACPI lid device only */
	if (button->type != ACPI_BUTTON_TYPE_LID)
		return 0;

	if (acpi_button_dir || acpi_lid_dir) {
		printk(KERN_ERR PREFIX "More than one Lid device found!\n");
		return -EEXIST;
265 266
	}

267 268 269
	/* create /proc/acpi/button */
	acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
	if (!acpi_button_dir)
270
		return -ENODEV;
271

272 273 274 275 276 277
	/* create /proc/acpi/button/lid */
	acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
	if (!acpi_lid_dir) {
		ret = -ENODEV;
		goto remove_button_dir;
	}
278

279 280 281 282 283 284
	/* create /proc/acpi/button/lid/LID/ */
	acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), acpi_lid_dir);
	if (!acpi_device_dir(device)) {
		ret = -ENODEV;
		goto remove_lid_dir;
	}
285

286
	/* create /proc/acpi/button/lid/LID/state */
287 288 289
	entry = proc_create_single_data(ACPI_BUTTON_FILE_STATE, S_IRUGO,
			acpi_device_dir(device), acpi_button_state_seq_show,
			device);
290 291 292
	if (!entry) {
		ret = -ENODEV;
		goto remove_dev_dir;
293 294
	}

295 296 297 298 299 300 301 302 303
done:
	return ret;

remove_dev_dir:
	remove_proc_entry(acpi_device_bid(device),
			  acpi_lid_dir);
	acpi_device_dir(device) = NULL;
remove_lid_dir:
	remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
304
	acpi_lid_dir = NULL;
305 306
remove_button_dir:
	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
307
	acpi_button_dir = NULL;
308
	goto done;
309 310
}

Len Brown's avatar
Len Brown committed
311
static int acpi_button_remove_fs(struct acpi_device *device)
312
{
313
	struct acpi_button *button = acpi_driver_data(device);
314

315 316
	if (button->type != ACPI_BUTTON_TYPE_LID)
		return 0;
317

318 319 320 321 322 323
	remove_proc_entry(ACPI_BUTTON_FILE_STATE,
			  acpi_device_dir(device));
	remove_proc_entry(acpi_device_bid(device),
			  acpi_lid_dir);
	acpi_device_dir(device) = NULL;
	remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
324
	acpi_lid_dir = NULL;
325
	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
326
	acpi_button_dir = NULL;
327

328
	return 0;
329 330
}

Linus Torvalds's avatar
Linus Torvalds committed
331 332 333
/* --------------------------------------------------------------------------
                                Driver Interface
   -------------------------------------------------------------------------- */
334 335 336 337 338 339 340 341 342 343 344 345 346 347
int acpi_lid_notifier_register(struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&acpi_lid_notifier, nb);
}
EXPORT_SYMBOL(acpi_lid_notifier_register);

int acpi_lid_notifier_unregister(struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&acpi_lid_notifier, nb);
}
EXPORT_SYMBOL(acpi_lid_notifier_unregister);

int acpi_lid_open(void)
{
348 349 350
	if (!lid_device)
		return -ENODEV;

351
	return acpi_lid_evaluate_state(lid_device);
352 353 354
}
EXPORT_SYMBOL(acpi_lid_open);

355 356
static int acpi_lid_update_state(struct acpi_device *device,
				 bool signal_wakeup)
357
{
358
	int state;
359

360 361 362
	state = acpi_lid_evaluate_state(device);
	if (state < 0)
		return state;
363

364 365 366
	if (state && signal_wakeup)
		acpi_pm_wakeup_event(&device->dev);

367
	return acpi_lid_notify_state(device, state);
368
}
Linus Torvalds's avatar
Linus Torvalds committed
369

370 371 372 373 374 375
static void acpi_lid_initialize_state(struct acpi_device *device)
{
	switch (lid_init_state) {
	case ACPI_BUTTON_LID_INIT_OPEN:
		(void)acpi_lid_notify_state(device, 1);
		break;
376
	case ACPI_BUTTON_LID_INIT_METHOD:
377
		(void)acpi_lid_update_state(device, false);
378
		break;
379 380 381 382 383 384
	case ACPI_BUTTON_LID_INIT_IGNORE:
	default:
		break;
	}
}

385
static void acpi_button_notify(struct acpi_device *device, u32 event)
Linus Torvalds's avatar
Linus Torvalds committed
386
{
387
	struct acpi_button *button = acpi_driver_data(device);
388
	struct input_dev *input;
389
	int users;
Linus Torvalds's avatar
Linus Torvalds committed
390 391

	switch (event) {
392 393 394
	case ACPI_FIXED_HARDWARE_EVENT:
		event = ACPI_BUTTON_NOTIFY_STATUS;
		/* fall through */
Linus Torvalds's avatar
Linus Torvalds committed
395
	case ACPI_BUTTON_NOTIFY_STATUS:
396 397
		input = button->input;
		if (button->type == ACPI_BUTTON_TYPE_LID) {
398 399 400 401
			mutex_lock(&button->input->mutex);
			users = button->input->users;
			mutex_unlock(&button->input->mutex);
			if (users)
402
				acpi_lid_update_state(device, true);
403
		} else {
404 405
			int keycode;

406
			acpi_pm_wakeup_event(&device->dev);
407 408
			if (button->suspended)
				break;
409

410 411
			keycode = test_bit(KEY_SLEEP, input->keybit) ?
						KEY_SLEEP : KEY_POWER;
412 413 414
			input_report_key(input, keycode, 1);
			input_sync(input);
			input_report_key(input, keycode, 0);
415
			input_sync(input);
416

417 418 419 420
			acpi_bus_generate_netlink_event(
					device->pnp.device_class,
					dev_name(&device->dev),
					event, ++button->pushed);
421
		}
Linus Torvalds's avatar
Linus Torvalds committed
422 423 424
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown's avatar
Len Brown committed
425
				  "Unsupported event [0x%x]\n", event));
Linus Torvalds's avatar
Linus Torvalds committed
426 427 428 429
		break;
	}
}

430
#ifdef CONFIG_PM_SLEEP
431 432 433 434 435 436 437 438 439
static int acpi_button_suspend(struct device *dev)
{
	struct acpi_device *device = to_acpi_device(dev);
	struct acpi_button *button = acpi_driver_data(device);

	button->suspended = true;
	return 0;
}

440
static int acpi_button_resume(struct device *dev)
441
{
442
	struct acpi_device *device = to_acpi_device(dev);
443
	struct acpi_button *button = acpi_driver_data(device);
444

445
	button->suspended = false;
446 447 448
	if (button->type == ACPI_BUTTON_TYPE_LID && button->input->users) {
		button->last_state = !!acpi_lid_evaluate_state(device);
		button->last_time = ktime_get();
449
		acpi_lid_initialize_state(device);
450
	}
451 452
	return 0;
}
453
#endif
454

455 456 457 458 459 460 461 462 463 464 465 466
static int acpi_lid_input_open(struct input_dev *input)
{
	struct acpi_device *device = input_get_drvdata(input);
	struct acpi_button *button = acpi_driver_data(device);

	button->last_state = !!acpi_lid_evaluate_state(device);
	button->last_time = ktime_get();
	acpi_lid_initialize_state(device);

	return 0;
}

467 468 469 470
static int acpi_button_add(struct acpi_device *device)
{
	struct acpi_button *button;
	struct input_dev *input;
471 472
	const char *hid = acpi_device_hid(device);
	char *name, *class;
473
	int error;
Linus Torvalds's avatar
Linus Torvalds committed
474

475 476 477
	if (!strcmp(hid, ACPI_BUTTON_HID_LID) && dmi_check_system(lid_blacklst))
		return -ENODEV;

478
	button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
479
	if (!button)
480
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
481

482
	device->driver_data = button;
Linus Torvalds's avatar
Linus Torvalds committed
483

484 485 486 487 488 489
	button->input = input = input_allocate_device();
	if (!input) {
		error = -ENOMEM;
		goto err_free_button;
	}

490 491 492
	name = acpi_device_name(device);
	class = acpi_device_class(device);

493 494
	if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
	    !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
Linus Torvalds's avatar
Linus Torvalds committed
495
		button->type = ACPI_BUTTON_TYPE_POWER;
496 497
		strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
		sprintf(class, "%s/%s",
Linus Torvalds's avatar
Linus Torvalds committed
498
			ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
499 500
	} else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
		   !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
Linus Torvalds's avatar
Linus Torvalds committed
501
		button->type = ACPI_BUTTON_TYPE_SLEEP;
502 503
		strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
		sprintf(class, "%s/%s",
Linus Torvalds's avatar
Linus Torvalds committed
504
			ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
505
	} else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
Linus Torvalds's avatar
Linus Torvalds committed
506
		button->type = ACPI_BUTTON_TYPE_LID;
507 508
		strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
		sprintf(class, "%s/%s",
Linus Torvalds's avatar
Linus Torvalds committed
509
			ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
510
		input->open = acpi_lid_input_open;
Len Brown's avatar
Len Brown committed
511
	} else {
512
		printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
513 514
		error = -ENODEV;
		goto err_free_input;
Linus Torvalds's avatar
Linus Torvalds committed
515 516
	}

517 518 519 520
	error = acpi_button_add_fs(device);
	if (error)
		goto err_free_input;

521
	snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
522

523
	input->name = name;
524 525 526
	input->phys = button->phys;
	input->id.bustype = BUS_HOST;
	input->id.product = button->type;
527
	input->dev.parent = &device->dev;
528

Linus Torvalds's avatar
Linus Torvalds committed
529
	switch (button->type) {
530
	case ACPI_BUTTON_TYPE_POWER:
531
		input_set_capability(input, EV_KEY, KEY_POWER);
Linus Torvalds's avatar
Linus Torvalds committed
532
		break;
533 534

	case ACPI_BUTTON_TYPE_SLEEP:
535
		input_set_capability(input, EV_KEY, KEY_SLEEP);
Linus Torvalds's avatar
Linus Torvalds committed
536
		break;
537 538

	case ACPI_BUTTON_TYPE_LID:
539
		input_set_capability(input, EV_SW, SW_LID);
Linus Torvalds's avatar
Linus Torvalds committed
540 541 542
		break;
	}

543
	input_set_drvdata(input, device);
544 545
	error = input_register_device(input);
	if (error)
546
		goto err_remove_fs;
547 548 549 550 551 552 553
	if (button->type == ACPI_BUTTON_TYPE_LID) {
		/*
		 * This assumes there's only one lid device, or if there are
		 * more we only care about the last one...
		 */
		lid_device = device;
	}
Linus Torvalds's avatar
Linus Torvalds committed
554

555
	device_init_wakeup(&device->dev, true);
556
	printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
557
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
558

559 560 561 562 563 564 565
 err_remove_fs:
	acpi_button_remove_fs(device);
 err_free_input:
	input_free_device(input);
 err_free_button:
	kfree(button);
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
566 567
}

568
static int acpi_button_remove(struct acpi_device *device)
Linus Torvalds's avatar
Linus Torvalds committed
569
{
570
	struct acpi_button *button = acpi_driver_data(device);
Linus Torvalds's avatar
Linus Torvalds committed
571

Len Brown's avatar
Len Brown committed
572
	acpi_button_remove_fs(device);
573
	input_unregister_device(button->input);
Linus Torvalds's avatar
Linus Torvalds committed
574
	kfree(button);
575
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
576 577
}

578 579
static int param_set_lid_init_state(const char *val,
				    const struct kernel_param *kp)
580 581 582 583 584 585
{
	int result = 0;

	if (!strncmp(val, "open", sizeof("open") - 1)) {
		lid_init_state = ACPI_BUTTON_LID_INIT_OPEN;
		pr_info("Notify initial lid state as open\n");
586 587 588
	} else if (!strncmp(val, "method", sizeof("method") - 1)) {
		lid_init_state = ACPI_BUTTON_LID_INIT_METHOD;
		pr_info("Notify initial lid state with _LID return value\n");
589 590 591 592 593 594 595 596
	} else if (!strncmp(val, "ignore", sizeof("ignore") - 1)) {
		lid_init_state = ACPI_BUTTON_LID_INIT_IGNORE;
		pr_info("Do not notify initial lid state\n");
	} else
		result = -EINVAL;
	return result;
}

597 598
static int param_get_lid_init_state(char *buffer,
				    const struct kernel_param *kp)
599 600 601 602
{
	switch (lid_init_state) {
	case ACPI_BUTTON_LID_INIT_OPEN:
		return sprintf(buffer, "open");
603 604
	case ACPI_BUTTON_LID_INIT_METHOD:
		return sprintf(buffer, "method");
605 606 607 608 609 610 611 612 613 614 615 616 617
	case ACPI_BUTTON_LID_INIT_IGNORE:
		return sprintf(buffer, "ignore");
	default:
		return sprintf(buffer, "invalid");
	}
	return 0;
}

module_param_call(lid_init_state,
		  param_set_lid_init_state, param_get_lid_init_state,
		  NULL, 0644);
MODULE_PARM_DESC(lid_init_state, "Behavior for reporting LID initial state");

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
static int acpi_button_register_driver(struct acpi_driver *driver)
{
	/*
	 * Modules such as nouveau.ko and i915.ko have a link time dependency
	 * on acpi_lid_open(), and would therefore not be loadable on ACPI
	 * capable kernels booted in non-ACPI mode if the return value of
	 * acpi_bus_register_driver() is returned from here with ACPI disabled
	 * when this driver is built as a module.
	 */
	if (acpi_disabled)
		return 0;

	return acpi_bus_register_driver(driver);
}

static void acpi_button_unregister_driver(struct acpi_driver *driver)
{
	if (!acpi_disabled)
		acpi_bus_unregister_driver(driver);
}

module_driver(acpi_button_driver, acpi_button_register_driver,
	       acpi_button_unregister_driver);