Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kaber/nf-next-2.6
[linux-2.6.git] / drivers / acpi / button.c
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 <acpi/acpi_bus.h>
34 #include <acpi/acpi_drivers.h>
35
36 #define PREFIX "ACPI: "
37
38 #define ACPI_BUTTON_CLASS               "button"
39 #define ACPI_BUTTON_FILE_INFO           "info"
40 #define ACPI_BUTTON_FILE_STATE          "state"
41 #define ACPI_BUTTON_TYPE_UNKNOWN        0x00
42 #define ACPI_BUTTON_NOTIFY_STATUS       0x80
43
44 #define ACPI_BUTTON_SUBCLASS_POWER      "power"
45 #define ACPI_BUTTON_HID_POWER           "PNP0C0C"
46 #define ACPI_BUTTON_DEVICE_NAME_POWER   "Power Button"
47 #define ACPI_BUTTON_TYPE_POWER          0x01
48
49 #define ACPI_BUTTON_SUBCLASS_SLEEP      "sleep"
50 #define ACPI_BUTTON_HID_SLEEP           "PNP0C0E"
51 #define ACPI_BUTTON_DEVICE_NAME_SLEEP   "Sleep Button"
52 #define ACPI_BUTTON_TYPE_SLEEP          0x03
53
54 #define ACPI_BUTTON_SUBCLASS_LID        "lid"
55 #define ACPI_BUTTON_HID_LID             "PNP0C0D"
56 #define ACPI_BUTTON_DEVICE_NAME_LID     "Lid Switch"
57 #define ACPI_BUTTON_TYPE_LID            0x05
58
59 #define _COMPONENT              ACPI_BUTTON_COMPONENT
60 ACPI_MODULE_NAME("button");
61
62 MODULE_AUTHOR("Paul Diefenbaugh");
63 MODULE_DESCRIPTION("ACPI Button Driver");
64 MODULE_LICENSE("GPL");
65
66 static const struct acpi_device_id button_device_ids[] = {
67         {ACPI_BUTTON_HID_LID,    0},
68         {ACPI_BUTTON_HID_SLEEP,  0},
69         {ACPI_BUTTON_HID_SLEEPF, 0},
70         {ACPI_BUTTON_HID_POWER,  0},
71         {ACPI_BUTTON_HID_POWERF, 0},
72         {"", 0},
73 };
74 MODULE_DEVICE_TABLE(acpi, button_device_ids);
75
76 static int acpi_button_add(struct acpi_device *device);
77 static int acpi_button_remove(struct acpi_device *device, int type);
78 static int acpi_button_resume(struct acpi_device *device);
79 static void acpi_button_notify(struct acpi_device *device, u32 event);
80 static int acpi_button_info_open_fs(struct inode *inode, struct file *file);
81 static int acpi_button_state_open_fs(struct inode *inode, struct file *file);
82
83 static struct acpi_driver acpi_button_driver = {
84         .name = "button",
85         .class = ACPI_BUTTON_CLASS,
86         .ids = button_device_ids,
87         .ops = {
88                 .add = acpi_button_add,
89                 .resume = acpi_button_resume,
90                 .remove = acpi_button_remove,
91                 .notify = acpi_button_notify,
92         },
93 };
94
95 struct acpi_button {
96         unsigned int type;
97         struct input_dev *input;
98         char phys[32];                  /* for input device */
99         unsigned long pushed;
100 };
101
102 static const struct file_operations acpi_button_info_fops = {
103         .owner = THIS_MODULE,
104         .open = acpi_button_info_open_fs,
105         .read = seq_read,
106         .llseek = seq_lseek,
107         .release = single_release,
108 };
109
110 static const struct file_operations acpi_button_state_fops = {
111         .owner = THIS_MODULE,
112         .open = acpi_button_state_open_fs,
113         .read = seq_read,
114         .llseek = seq_lseek,
115         .release = single_release,
116 };
117
118 static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier);
119 static struct acpi_device *lid_device;
120
121 /* --------------------------------------------------------------------------
122                               FS Interface (/proc)
123    -------------------------------------------------------------------------- */
124
125 static struct proc_dir_entry *acpi_button_dir;
126
127 static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
128 {
129         struct acpi_device *device = seq->private;
130
131         seq_printf(seq, "type:                    %s\n",
132                    acpi_device_name(device));
133         return 0;
134 }
135
136 static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
137 {
138         return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);
139 }
140
141 static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
142 {
143         struct acpi_device *device = seq->private;
144         acpi_status status;
145         unsigned long long state;
146
147         status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
148         seq_printf(seq, "state:      %s\n",
149                    ACPI_FAILURE(status) ? "unsupported" :
150                         (state ? "open" : "closed"));
151         return 0;
152 }
153
154 static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
155 {
156         return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);
157 }
158
159 static struct proc_dir_entry *acpi_power_dir;
160 static struct proc_dir_entry *acpi_sleep_dir;
161 static struct proc_dir_entry *acpi_lid_dir;
162
163 static int acpi_button_add_fs(struct acpi_device *device)
164 {
165         struct acpi_button *button = acpi_driver_data(device);
166         struct proc_dir_entry *entry = NULL;
167
168         switch (button->type) {
169         case ACPI_BUTTON_TYPE_POWER:
170                 if (!acpi_power_dir)
171                         acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,
172                                                     acpi_button_dir);
173                 entry = acpi_power_dir;
174                 break;
175         case ACPI_BUTTON_TYPE_SLEEP:
176                 if (!acpi_sleep_dir)
177                         acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,
178                                                     acpi_button_dir);
179                 entry = acpi_sleep_dir;
180                 break;
181         case ACPI_BUTTON_TYPE_LID:
182                 if (!acpi_lid_dir)
183                         acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID,
184                                                   acpi_button_dir);
185                 entry = acpi_lid_dir;
186                 break;
187         }
188
189         if (!entry)
190                 return -ENODEV;
191
192         acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
193         if (!acpi_device_dir(device))
194                 return -ENODEV;
195
196         /* 'info' [R] */
197         entry = proc_create_data(ACPI_BUTTON_FILE_INFO,
198                                  S_IRUGO, acpi_device_dir(device),
199                                  &acpi_button_info_fops, device);
200         if (!entry)
201                 return -ENODEV;
202
203         /* show lid state [R] */
204         if (button->type == ACPI_BUTTON_TYPE_LID) {
205                 entry = proc_create_data(ACPI_BUTTON_FILE_STATE,
206                                          S_IRUGO, acpi_device_dir(device),
207                                          &acpi_button_state_fops, device);
208                 if (!entry)
209                         return -ENODEV;
210         }
211
212         return 0;
213 }
214
215 static int acpi_button_remove_fs(struct acpi_device *device)
216 {
217         struct acpi_button *button = acpi_driver_data(device);
218
219         if (acpi_device_dir(device)) {
220                 if (button->type == ACPI_BUTTON_TYPE_LID)
221                         remove_proc_entry(ACPI_BUTTON_FILE_STATE,
222                                           acpi_device_dir(device));
223                 remove_proc_entry(ACPI_BUTTON_FILE_INFO,
224                                   acpi_device_dir(device));
225
226                 remove_proc_entry(acpi_device_bid(device),
227                                   acpi_device_dir(device)->parent);
228                 acpi_device_dir(device) = NULL;
229         }
230
231         return 0;
232 }
233
234 /* --------------------------------------------------------------------------
235                                 Driver Interface
236    -------------------------------------------------------------------------- */
237 int acpi_lid_notifier_register(struct notifier_block *nb)
238 {
239         return blocking_notifier_chain_register(&acpi_lid_notifier, nb);
240 }
241 EXPORT_SYMBOL(acpi_lid_notifier_register);
242
243 int acpi_lid_notifier_unregister(struct notifier_block *nb)
244 {
245         return blocking_notifier_chain_unregister(&acpi_lid_notifier, nb);
246 }
247 EXPORT_SYMBOL(acpi_lid_notifier_unregister);
248
249 int acpi_lid_open(void)
250 {
251         acpi_status status;
252         unsigned long long state;
253
254         if (!lid_device)
255                 return -ENODEV;
256
257         status = acpi_evaluate_integer(lid_device->handle, "_LID", NULL,
258                                        &state);
259         if (ACPI_FAILURE(status))
260                 return -ENODEV;
261
262         return !!state;
263 }
264 EXPORT_SYMBOL(acpi_lid_open);
265
266 static int acpi_lid_send_state(struct acpi_device *device)
267 {
268         struct acpi_button *button = acpi_driver_data(device);
269         unsigned long long state;
270         acpi_status status;
271         int ret;
272
273         status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
274         if (ACPI_FAILURE(status))
275                 return -ENODEV;
276
277         /* input layer checks if event is redundant */
278         input_report_switch(button->input, SW_LID, !state);
279         input_sync(button->input);
280
281         ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
282         if (ret == NOTIFY_DONE)
283                 ret = blocking_notifier_call_chain(&acpi_lid_notifier, state,
284                                                    device);
285         return ret;
286 }
287
288 static void acpi_button_notify(struct acpi_device *device, u32 event)
289 {
290         struct acpi_button *button = acpi_driver_data(device);
291         struct input_dev *input;
292
293         switch (event) {
294         case ACPI_FIXED_HARDWARE_EVENT:
295                 event = ACPI_BUTTON_NOTIFY_STATUS;
296                 /* fall through */
297         case ACPI_BUTTON_NOTIFY_STATUS:
298                 input = button->input;
299                 if (button->type == ACPI_BUTTON_TYPE_LID) {
300                         acpi_lid_send_state(device);
301                 } else {
302                         int keycode = test_bit(KEY_SLEEP, input->keybit) ?
303                                                 KEY_SLEEP : KEY_POWER;
304
305                         input_report_key(input, keycode, 1);
306                         input_sync(input);
307                         input_report_key(input, keycode, 0);
308                         input_sync(input);
309                 }
310
311                 acpi_bus_generate_proc_event(device, event, ++button->pushed);
312                 break;
313         default:
314                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
315                                   "Unsupported event [0x%x]\n", event));
316                 break;
317         }
318 }
319
320 static int acpi_button_resume(struct acpi_device *device)
321 {
322         struct acpi_button *button = acpi_driver_data(device);
323
324         if (button->type == ACPI_BUTTON_TYPE_LID)
325                 return acpi_lid_send_state(device);
326         return 0;
327 }
328
329 static int acpi_button_add(struct acpi_device *device)
330 {
331         struct acpi_button *button;
332         struct input_dev *input;
333         char *hid, *name, *class;
334         int error;
335
336         button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
337         if (!button)
338                 return -ENOMEM;
339
340         device->driver_data = button;
341
342         button->input = input = input_allocate_device();
343         if (!input) {
344                 error = -ENOMEM;
345                 goto err_free_button;
346         }
347
348         hid = acpi_device_hid(device);
349         name = acpi_device_name(device);
350         class = acpi_device_class(device);
351
352         if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
353             !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
354                 button->type = ACPI_BUTTON_TYPE_POWER;
355                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
356                 sprintf(class, "%s/%s",
357                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
358         } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
359                    !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
360                 button->type = ACPI_BUTTON_TYPE_SLEEP;
361                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
362                 sprintf(class, "%s/%s",
363                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
364         } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
365                 button->type = ACPI_BUTTON_TYPE_LID;
366                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
367                 sprintf(class, "%s/%s",
368                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
369         } else {
370                 printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
371                 error = -ENODEV;
372                 goto err_free_input;
373         }
374
375         error = acpi_button_add_fs(device);
376         if (error)
377                 goto err_free_input;
378
379         snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
380
381         input->name = name;
382         input->phys = button->phys;
383         input->id.bustype = BUS_HOST;
384         input->id.product = button->type;
385         input->dev.parent = &device->dev;
386
387         switch (button->type) {
388         case ACPI_BUTTON_TYPE_POWER:
389                 input->evbit[0] = BIT_MASK(EV_KEY);
390                 set_bit(KEY_POWER, input->keybit);
391                 break;
392
393         case ACPI_BUTTON_TYPE_SLEEP:
394                 input->evbit[0] = BIT_MASK(EV_KEY);
395                 set_bit(KEY_SLEEP, input->keybit);
396                 break;
397
398         case ACPI_BUTTON_TYPE_LID:
399                 input->evbit[0] = BIT_MASK(EV_SW);
400                 set_bit(SW_LID, input->swbit);
401                 break;
402         }
403
404         error = input_register_device(input);
405         if (error)
406                 goto err_remove_fs;
407         if (button->type == ACPI_BUTTON_TYPE_LID) {
408                 acpi_lid_send_state(device);
409                 /*
410                  * This assumes there's only one lid device, or if there are
411                  * more we only care about the last one...
412                  */
413                 lid_device = device;
414         }
415
416         if (device->wakeup.flags.valid) {
417                 /* Button's GPE is run-wake GPE */
418                 acpi_set_gpe_type(device->wakeup.gpe_device,
419                                   device->wakeup.gpe_number,
420                                   ACPI_GPE_TYPE_WAKE_RUN);
421                 acpi_enable_gpe(device->wakeup.gpe_device,
422                                 device->wakeup.gpe_number);
423                 device->wakeup.state.enabled = 1;
424         }
425
426         printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
427         return 0;
428
429  err_remove_fs:
430         acpi_button_remove_fs(device);
431  err_free_input:
432         input_free_device(input);
433  err_free_button:
434         kfree(button);
435         return error;
436 }
437
438 static int acpi_button_remove(struct acpi_device *device, int type)
439 {
440         struct acpi_button *button = acpi_driver_data(device);
441
442         acpi_button_remove_fs(device);
443         input_unregister_device(button->input);
444         kfree(button);
445         return 0;
446 }
447
448 static int __init acpi_button_init(void)
449 {
450         int result;
451
452         acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
453         if (!acpi_button_dir)
454                 return -ENODEV;
455
456         result = acpi_bus_register_driver(&acpi_button_driver);
457         if (result < 0) {
458                 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
459                 return -ENODEV;
460         }
461
462         return 0;
463 }
464
465 static void __exit acpi_button_exit(void)
466 {
467         acpi_bus_unregister_driver(&acpi_button_driver);
468
469         if (acpi_power_dir)
470                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);
471         if (acpi_sleep_dir)
472                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);
473         if (acpi_lid_dir)
474                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
475         remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
476 }
477
478 module_init(acpi_button_init);
479 module_exit(acpi_button_exit);