Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-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         if (ret == NOTIFY_DONE || ret == NOTIFY_OK) {
286                 /*
287                  * It is also regarded as success if the notifier_chain
288                  * returns NOTIFY_OK or NOTIFY_DONE.
289                  */
290                 ret = 0;
291         }
292         return ret;
293 }
294
295 static void acpi_button_notify(struct acpi_device *device, u32 event)
296 {
297         struct acpi_button *button = acpi_driver_data(device);
298         struct input_dev *input;
299
300         switch (event) {
301         case ACPI_FIXED_HARDWARE_EVENT:
302                 event = ACPI_BUTTON_NOTIFY_STATUS;
303                 /* fall through */
304         case ACPI_BUTTON_NOTIFY_STATUS:
305                 input = button->input;
306                 if (button->type == ACPI_BUTTON_TYPE_LID) {
307                         acpi_lid_send_state(device);
308                 } else {
309                         int keycode = test_bit(KEY_SLEEP, input->keybit) ?
310                                                 KEY_SLEEP : KEY_POWER;
311
312                         input_report_key(input, keycode, 1);
313                         input_sync(input);
314                         input_report_key(input, keycode, 0);
315                         input_sync(input);
316                 }
317
318                 acpi_bus_generate_proc_event(device, event, ++button->pushed);
319                 break;
320         default:
321                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
322                                   "Unsupported event [0x%x]\n", event));
323                 break;
324         }
325 }
326
327 static int acpi_button_resume(struct acpi_device *device)
328 {
329         struct acpi_button *button = acpi_driver_data(device);
330
331         if (button->type == ACPI_BUTTON_TYPE_LID)
332                 return acpi_lid_send_state(device);
333         return 0;
334 }
335
336 static int acpi_button_add(struct acpi_device *device)
337 {
338         struct acpi_button *button;
339         struct input_dev *input;
340         char *hid, *name, *class;
341         int error;
342
343         button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
344         if (!button)
345                 return -ENOMEM;
346
347         device->driver_data = button;
348
349         button->input = input = input_allocate_device();
350         if (!input) {
351                 error = -ENOMEM;
352                 goto err_free_button;
353         }
354
355         hid = acpi_device_hid(device);
356         name = acpi_device_name(device);
357         class = acpi_device_class(device);
358
359         if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
360             !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
361                 button->type = ACPI_BUTTON_TYPE_POWER;
362                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
363                 sprintf(class, "%s/%s",
364                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
365         } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
366                    !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
367                 button->type = ACPI_BUTTON_TYPE_SLEEP;
368                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
369                 sprintf(class, "%s/%s",
370                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
371         } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
372                 button->type = ACPI_BUTTON_TYPE_LID;
373                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
374                 sprintf(class, "%s/%s",
375                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
376         } else {
377                 printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
378                 error = -ENODEV;
379                 goto err_free_input;
380         }
381
382         error = acpi_button_add_fs(device);
383         if (error)
384                 goto err_free_input;
385
386         snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
387
388         input->name = name;
389         input->phys = button->phys;
390         input->id.bustype = BUS_HOST;
391         input->id.product = button->type;
392         input->dev.parent = &device->dev;
393
394         switch (button->type) {
395         case ACPI_BUTTON_TYPE_POWER:
396                 input->evbit[0] = BIT_MASK(EV_KEY);
397                 set_bit(KEY_POWER, input->keybit);
398                 break;
399
400         case ACPI_BUTTON_TYPE_SLEEP:
401                 input->evbit[0] = BIT_MASK(EV_KEY);
402                 set_bit(KEY_SLEEP, input->keybit);
403                 break;
404
405         case ACPI_BUTTON_TYPE_LID:
406                 input->evbit[0] = BIT_MASK(EV_SW);
407                 set_bit(SW_LID, input->swbit);
408                 break;
409         }
410
411         error = input_register_device(input);
412         if (error)
413                 goto err_remove_fs;
414         if (button->type == ACPI_BUTTON_TYPE_LID) {
415                 acpi_lid_send_state(device);
416                 /*
417                  * This assumes there's only one lid device, or if there are
418                  * more we only care about the last one...
419                  */
420                 lid_device = device;
421         }
422
423         if (device->wakeup.flags.valid) {
424                 /* Button's GPE is run-wake GPE */
425                 acpi_enable_gpe(device->wakeup.gpe_device,
426                                 device->wakeup.gpe_number,
427                                 ACPI_GPE_TYPE_WAKE_RUN);
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                                 ACPI_GPE_TYPE_WAKE_RUN);
452                 device->wakeup.run_wake_count--;
453                 device->wakeup.state.enabled = 0;
454         }
455
456         acpi_button_remove_fs(device);
457         input_unregister_device(button->input);
458         kfree(button);
459         return 0;
460 }
461
462 static int __init acpi_button_init(void)
463 {
464         int result;
465
466         acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
467         if (!acpi_button_dir)
468                 return -ENODEV;
469
470         result = acpi_bus_register_driver(&acpi_button_driver);
471         if (result < 0) {
472                 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
473                 return -ENODEV;
474         }
475
476         return 0;
477 }
478
479 static void __exit acpi_button_exit(void)
480 {
481         acpi_bus_unregister_driver(&acpi_button_driver);
482
483         if (acpi_power_dir)
484                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);
485         if (acpi_sleep_dir)
486                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);
487         if (acpi_lid_dir)
488                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
489         remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
490 }
491
492 module_init(acpi_button_init);
493 module_exit(acpi_button_exit);