1/*
2 *  button.c - ACPI Button Driver
3 *
4 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 *
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 *
9 *  This program is free software; you can redistribute it and/or modify
10 *  it under the terms of the GNU General Public License as published by
11 *  the Free Software Foundation; either version 2 of the License, or (at
12 *  your option) any later version.
13 *
14 *  This program is distributed in the hope that it will be useful, but
15 *  WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 *  General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License along
20 *  with this program; if not, write to the Free Software Foundation, Inc.,
21 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22 *
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 */
25
26#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/init.h>
29#include <linux/types.h>
30#include <linux/proc_fs.h>
31#include <linux/seq_file.h>
32#include <linux/input.h>
33#include <linux/slab.h>
34#include <linux/acpi.h>
35#include <acpi/button.h>
36
37#define PREFIX "ACPI: "
38
39#define ACPI_BUTTON_CLASS		"button"
40#define ACPI_BUTTON_FILE_INFO		"info"
41#define ACPI_BUTTON_FILE_STATE		"state"
42#define ACPI_BUTTON_TYPE_UNKNOWN	0x00
43#define ACPI_BUTTON_NOTIFY_STATUS	0x80
44
45#define ACPI_BUTTON_SUBCLASS_POWER	"power"
46#define ACPI_BUTTON_HID_POWER		"PNP0C0C"
47#define ACPI_BUTTON_DEVICE_NAME_POWER	"Power Button"
48#define ACPI_BUTTON_TYPE_POWER		0x01
49
50#define ACPI_BUTTON_SUBCLASS_SLEEP	"sleep"
51#define ACPI_BUTTON_HID_SLEEP		"PNP0C0E"
52#define ACPI_BUTTON_DEVICE_NAME_SLEEP	"Sleep Button"
53#define ACPI_BUTTON_TYPE_SLEEP		0x03
54
55#define ACPI_BUTTON_SUBCLASS_LID	"lid"
56#define ACPI_BUTTON_HID_LID		"PNP0C0D"
57#define ACPI_BUTTON_DEVICE_NAME_LID	"Lid Switch"
58#define ACPI_BUTTON_TYPE_LID		0x05
59
60#define _COMPONENT		ACPI_BUTTON_COMPONENT
61ACPI_MODULE_NAME("button");
62
63MODULE_AUTHOR("Paul Diefenbaugh");
64MODULE_DESCRIPTION("ACPI Button Driver");
65MODULE_LICENSE("GPL");
66
67static const struct acpi_device_id button_device_ids[] = {
68	{ACPI_BUTTON_HID_LID,    0},
69	{ACPI_BUTTON_HID_SLEEP,  0},
70	{ACPI_BUTTON_HID_SLEEPF, 0},
71	{ACPI_BUTTON_HID_POWER,  0},
72	{ACPI_BUTTON_HID_POWERF, 0},
73	{"", 0},
74};
75MODULE_DEVICE_TABLE(acpi, button_device_ids);
76
77static int acpi_button_add(struct acpi_device *device);
78static int acpi_button_remove(struct acpi_device *device);
79static void acpi_button_notify(struct acpi_device *device, u32 event);
80
81#ifdef CONFIG_PM_SLEEP
82static int acpi_button_suspend(struct device *dev);
83static int acpi_button_resume(struct device *dev);
84#else
85#define acpi_button_suspend NULL
86#define acpi_button_resume NULL
87#endif
88static SIMPLE_DEV_PM_OPS(acpi_button_pm, acpi_button_suspend, acpi_button_resume);
89
90static struct acpi_driver acpi_button_driver = {
91	.name = "button",
92	.class = ACPI_BUTTON_CLASS,
93	.ids = button_device_ids,
94	.ops = {
95		.add = acpi_button_add,
96		.remove = acpi_button_remove,
97		.notify = acpi_button_notify,
98	},
99	.drv.pm = &acpi_button_pm,
100};
101
102struct acpi_button {
103	unsigned int type;
104	struct input_dev *input;
105	char phys[32];			/* for input device */
106	unsigned long pushed;
107	bool suspended;
108};
109
110static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier);
111static struct acpi_device *lid_device;
112
113/* --------------------------------------------------------------------------
114                              FS Interface (/proc)
115   -------------------------------------------------------------------------- */
116
117static struct proc_dir_entry *acpi_button_dir;
118static struct proc_dir_entry *acpi_lid_dir;
119
120static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
121{
122	struct acpi_device *device = seq->private;
123	acpi_status status;
124	unsigned long long state;
125
126	status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
127	seq_printf(seq, "state:      %s\n",
128		   ACPI_FAILURE(status) ? "unsupported" :
129			(state ? "open" : "closed"));
130	return 0;
131}
132
133static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
134{
135	return single_open(file, acpi_button_state_seq_show, PDE_DATA(inode));
136}
137
138static const struct file_operations acpi_button_state_fops = {
139	.owner = THIS_MODULE,
140	.open = acpi_button_state_open_fs,
141	.read = seq_read,
142	.llseek = seq_lseek,
143	.release = single_release,
144};
145
146static int acpi_button_add_fs(struct acpi_device *device)
147{
148	struct acpi_button *button = acpi_driver_data(device);
149	struct proc_dir_entry *entry = NULL;
150	int ret = 0;
151
152	/* procfs I/F for ACPI lid device only */
153	if (button->type != ACPI_BUTTON_TYPE_LID)
154		return 0;
155
156	if (acpi_button_dir || acpi_lid_dir) {
157		printk(KERN_ERR PREFIX "More than one Lid device found!\n");
158		return -EEXIST;
159	}
160
161	/* create /proc/acpi/button */
162	acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
163	if (!acpi_button_dir)
164		return -ENODEV;
165
166	/* create /proc/acpi/button/lid */
167	acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
168	if (!acpi_lid_dir) {
169		ret = -ENODEV;
170		goto remove_button_dir;
171	}
172
173	/* create /proc/acpi/button/lid/LID/ */
174	acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), acpi_lid_dir);
175	if (!acpi_device_dir(device)) {
176		ret = -ENODEV;
177		goto remove_lid_dir;
178	}
179
180	/* create /proc/acpi/button/lid/LID/state */
181	entry = proc_create_data(ACPI_BUTTON_FILE_STATE,
182				 S_IRUGO, acpi_device_dir(device),
183				 &acpi_button_state_fops, device);
184	if (!entry) {
185		ret = -ENODEV;
186		goto remove_dev_dir;
187	}
188
189done:
190	return ret;
191
192remove_dev_dir:
193	remove_proc_entry(acpi_device_bid(device),
194			  acpi_lid_dir);
195	acpi_device_dir(device) = NULL;
196remove_lid_dir:
197	remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
198remove_button_dir:
199	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
200	goto done;
201}
202
203static int acpi_button_remove_fs(struct acpi_device *device)
204{
205	struct acpi_button *button = acpi_driver_data(device);
206
207	if (button->type != ACPI_BUTTON_TYPE_LID)
208		return 0;
209
210	remove_proc_entry(ACPI_BUTTON_FILE_STATE,
211			  acpi_device_dir(device));
212	remove_proc_entry(acpi_device_bid(device),
213			  acpi_lid_dir);
214	acpi_device_dir(device) = NULL;
215	remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
216	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
217
218	return 0;
219}
220
221/* --------------------------------------------------------------------------
222                                Driver Interface
223   -------------------------------------------------------------------------- */
224int acpi_lid_notifier_register(struct notifier_block *nb)
225{
226	return blocking_notifier_chain_register(&acpi_lid_notifier, nb);
227}
228EXPORT_SYMBOL(acpi_lid_notifier_register);
229
230int acpi_lid_notifier_unregister(struct notifier_block *nb)
231{
232	return blocking_notifier_chain_unregister(&acpi_lid_notifier, nb);
233}
234EXPORT_SYMBOL(acpi_lid_notifier_unregister);
235
236int acpi_lid_open(void)
237{
238	acpi_status status;
239	unsigned long long state;
240
241	if (!lid_device)
242		return -ENODEV;
243
244	status = acpi_evaluate_integer(lid_device->handle, "_LID", NULL,
245				       &state);
246	if (ACPI_FAILURE(status))
247		return -ENODEV;
248
249	return !!state;
250}
251EXPORT_SYMBOL(acpi_lid_open);
252
253static int acpi_lid_send_state(struct acpi_device *device)
254{
255	struct acpi_button *button = acpi_driver_data(device);
256	unsigned long long state;
257	acpi_status status;
258	int ret;
259
260	status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
261	if (ACPI_FAILURE(status))
262		return -ENODEV;
263
264	/* input layer checks if event is redundant */
265	input_report_switch(button->input, SW_LID, !state);
266	input_sync(button->input);
267
268	if (state)
269		pm_wakeup_event(&device->dev, 0);
270
271	ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
272	if (ret == NOTIFY_DONE)
273		ret = blocking_notifier_call_chain(&acpi_lid_notifier, state,
274						   device);
275	if (ret == NOTIFY_DONE || ret == NOTIFY_OK) {
276		/*
277		 * It is also regarded as success if the notifier_chain
278		 * returns NOTIFY_OK or NOTIFY_DONE.
279		 */
280		ret = 0;
281	}
282	return ret;
283}
284
285static void acpi_button_notify(struct acpi_device *device, u32 event)
286{
287	struct acpi_button *button = acpi_driver_data(device);
288	struct input_dev *input;
289
290	switch (event) {
291	case ACPI_FIXED_HARDWARE_EVENT:
292		event = ACPI_BUTTON_NOTIFY_STATUS;
293		/* fall through */
294	case ACPI_BUTTON_NOTIFY_STATUS:
295		input = button->input;
296		if (button->type == ACPI_BUTTON_TYPE_LID) {
297			acpi_lid_send_state(device);
298		} else {
299			int keycode;
300
301			pm_wakeup_event(&device->dev, 0);
302			if (button->suspended)
303				break;
304
305			keycode = test_bit(KEY_SLEEP, input->keybit) ?
306						KEY_SLEEP : KEY_POWER;
307			input_report_key(input, keycode, 1);
308			input_sync(input);
309			input_report_key(input, keycode, 0);
310			input_sync(input);
311
312			acpi_bus_generate_netlink_event(
313					device->pnp.device_class,
314					dev_name(&device->dev),
315					event, ++button->pushed);
316		}
317		break;
318	default:
319		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
320				  "Unsupported event [0x%x]\n", event));
321		break;
322	}
323}
324
325#ifdef CONFIG_PM_SLEEP
326static int acpi_button_suspend(struct device *dev)
327{
328	struct acpi_device *device = to_acpi_device(dev);
329	struct acpi_button *button = acpi_driver_data(device);
330
331	button->suspended = true;
332	return 0;
333}
334
335static int acpi_button_resume(struct device *dev)
336{
337	struct acpi_device *device = to_acpi_device(dev);
338	struct acpi_button *button = acpi_driver_data(device);
339
340	button->suspended = false;
341	if (button->type == ACPI_BUTTON_TYPE_LID)
342		return acpi_lid_send_state(device);
343	return 0;
344}
345#endif
346
347static int acpi_button_add(struct acpi_device *device)
348{
349	struct acpi_button *button;
350	struct input_dev *input;
351	const char *hid = acpi_device_hid(device);
352	char *name, *class;
353	int error;
354
355	button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
356	if (!button)
357		return -ENOMEM;
358
359	device->driver_data = button;
360
361	button->input = input = input_allocate_device();
362	if (!input) {
363		error = -ENOMEM;
364		goto err_free_button;
365	}
366
367	name = acpi_device_name(device);
368	class = acpi_device_class(device);
369
370	if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
371	    !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
372		button->type = ACPI_BUTTON_TYPE_POWER;
373		strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
374		sprintf(class, "%s/%s",
375			ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
376	} else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
377		   !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
378		button->type = ACPI_BUTTON_TYPE_SLEEP;
379		strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
380		sprintf(class, "%s/%s",
381			ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
382	} else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
383		button->type = ACPI_BUTTON_TYPE_LID;
384		strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
385		sprintf(class, "%s/%s",
386			ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
387	} else {
388		printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
389		error = -ENODEV;
390		goto err_free_input;
391	}
392
393	error = acpi_button_add_fs(device);
394	if (error)
395		goto err_free_input;
396
397	snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
398
399	input->name = name;
400	input->phys = button->phys;
401	input->id.bustype = BUS_HOST;
402	input->id.product = button->type;
403	input->dev.parent = &device->dev;
404
405	switch (button->type) {
406	case ACPI_BUTTON_TYPE_POWER:
407		input_set_capability(input, EV_KEY, KEY_POWER);
408		break;
409
410	case ACPI_BUTTON_TYPE_SLEEP:
411		input_set_capability(input, EV_KEY, KEY_SLEEP);
412		break;
413
414	case ACPI_BUTTON_TYPE_LID:
415		input_set_capability(input, EV_SW, SW_LID);
416		break;
417	}
418
419	error = input_register_device(input);
420	if (error)
421		goto err_remove_fs;
422	if (button->type == ACPI_BUTTON_TYPE_LID) {
423		acpi_lid_send_state(device);
424		/*
425		 * This assumes there's only one lid device, or if there are
426		 * more we only care about the last one...
427		 */
428		lid_device = device;
429	}
430
431	printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
432	return 0;
433
434 err_remove_fs:
435	acpi_button_remove_fs(device);
436 err_free_input:
437	input_free_device(input);
438 err_free_button:
439	kfree(button);
440	return error;
441}
442
443static int acpi_button_remove(struct acpi_device *device)
444{
445	struct acpi_button *button = acpi_driver_data(device);
446
447	acpi_button_remove_fs(device);
448	input_unregister_device(button->input);
449	kfree(button);
450	return 0;
451}
452
453module_acpi_driver(acpi_button_driver);
454