1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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];
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
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
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
162 acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
163 if (!acpi_button_dir)
164 return -ENODEV;
165
166
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
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
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
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
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
278
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
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
426
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
