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