Pull dock-bay into release branch
[linux-3.10.git] / drivers / acpi / button.c
1 /*
2  *  acpi_button.c - ACPI Button Driver ($Revision: 30 $)
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 ACPI_BUTTON_COMPONENT           0x00080000
37 #define ACPI_BUTTON_CLASS               "button"
38 #define ACPI_BUTTON_FILE_INFO           "info"
39 #define ACPI_BUTTON_FILE_STATE          "state"
40 #define ACPI_BUTTON_TYPE_UNKNOWN        0x00
41 #define ACPI_BUTTON_NOTIFY_STATUS       0x80
42
43 #define ACPI_BUTTON_SUBCLASS_POWER      "power"
44 #define ACPI_BUTTON_HID_POWER           "PNP0C0C"
45 #define ACPI_BUTTON_DEVICE_NAME_POWER   "Power Button (CM)"
46 #define ACPI_BUTTON_DEVICE_NAME_POWERF  "Power Button (FF)"
47 #define ACPI_BUTTON_TYPE_POWER          0x01
48 #define ACPI_BUTTON_TYPE_POWERF         0x02
49
50 #define ACPI_BUTTON_SUBCLASS_SLEEP      "sleep"
51 #define ACPI_BUTTON_HID_SLEEP           "PNP0C0E"
52 #define ACPI_BUTTON_DEVICE_NAME_SLEEP   "Sleep Button (CM)"
53 #define ACPI_BUTTON_DEVICE_NAME_SLEEPF  "Sleep Button (FF)"
54 #define ACPI_BUTTON_TYPE_SLEEP          0x03
55 #define ACPI_BUTTON_TYPE_SLEEPF         0x04
56
57 #define ACPI_BUTTON_SUBCLASS_LID        "lid"
58 #define ACPI_BUTTON_HID_LID             "PNP0C0D"
59 #define ACPI_BUTTON_DEVICE_NAME_LID     "Lid Switch"
60 #define ACPI_BUTTON_TYPE_LID            0x05
61
62 #define _COMPONENT              ACPI_BUTTON_COMPONENT
63 ACPI_MODULE_NAME("button");
64
65 MODULE_AUTHOR("Paul Diefenbaugh");
66 MODULE_DESCRIPTION("ACPI Button Driver");
67 MODULE_LICENSE("GPL");
68
69 static const struct acpi_device_id button_device_ids[] = {
70         {ACPI_BUTTON_HID_LID,    0},
71         {ACPI_BUTTON_HID_SLEEP,  0},
72         {ACPI_BUTTON_HID_SLEEPF, 0},
73         {ACPI_BUTTON_HID_POWER,  0},
74         {ACPI_BUTTON_HID_POWERF, 0},
75         {"", 0},
76 };
77 MODULE_DEVICE_TABLE(acpi, button_device_ids);
78
79 static int acpi_button_add(struct acpi_device *device);
80 static int acpi_button_remove(struct acpi_device *device, int type);
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                 .remove = acpi_button_remove,
91         },
92 };
93
94 struct acpi_button {
95         struct acpi_device *device;     /* Fixed button kludge */
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         .open = acpi_button_info_open_fs,
104         .read = seq_read,
105         .llseek = seq_lseek,
106         .release = single_release,
107 };
108
109 static const struct file_operations acpi_button_state_fops = {
110         .open = acpi_button_state_open_fs,
111         .read = seq_read,
112         .llseek = seq_lseek,
113         .release = single_release,
114 };
115
116 /* --------------------------------------------------------------------------
117                               FS Interface (/proc)
118    -------------------------------------------------------------------------- */
119
120 static struct proc_dir_entry *acpi_button_dir;
121
122 static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
123 {
124         struct acpi_button *button = seq->private;
125
126         if (!button || !button->device)
127                 return 0;
128
129         seq_printf(seq, "type:                    %s\n",
130                    acpi_device_name(button->device));
131
132         return 0;
133 }
134
135 static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
136 {
137         return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);
138 }
139
140 static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
141 {
142         struct acpi_button *button = seq->private;
143         acpi_status status;
144         unsigned long state;
145
146         if (!button || !button->device)
147                 return 0;
148
149         status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);
150         seq_printf(seq, "state:      %s\n",
151                    ACPI_FAILURE(status) ? "unsupported" :
152                         (state ? "open" : "closed"));
153         return 0;
154 }
155
156 static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
157 {
158         return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);
159 }
160
161 static struct proc_dir_entry *acpi_power_dir;
162 static struct proc_dir_entry *acpi_sleep_dir;
163 static struct proc_dir_entry *acpi_lid_dir;
164
165 static int acpi_button_add_fs(struct acpi_device *device)
166 {
167         struct proc_dir_entry *entry = NULL;
168         struct acpi_button *button;
169
170         if (!device || !acpi_driver_data(device))
171                 return -EINVAL;
172
173         button = acpi_driver_data(device);
174
175         switch (button->type) {
176         case ACPI_BUTTON_TYPE_POWER:
177         case ACPI_BUTTON_TYPE_POWERF:
178                 if (!acpi_power_dir)
179                         acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,
180                                                     acpi_button_dir);
181                 entry = acpi_power_dir;
182                 break;
183         case ACPI_BUTTON_TYPE_SLEEP:
184         case ACPI_BUTTON_TYPE_SLEEPF:
185                 if (!acpi_sleep_dir)
186                         acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,
187                                                     acpi_button_dir);
188                 entry = acpi_sleep_dir;
189                 break;
190         case ACPI_BUTTON_TYPE_LID:
191                 if (!acpi_lid_dir)
192                         acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID,
193                                                   acpi_button_dir);
194                 entry = acpi_lid_dir;
195                 break;
196         }
197
198         if (!entry)
199                 return -ENODEV;
200         entry->owner = THIS_MODULE;
201
202         acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
203         if (!acpi_device_dir(device))
204                 return -ENODEV;
205         acpi_device_dir(device)->owner = THIS_MODULE;
206
207         /* 'info' [R] */
208         entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
209                                   S_IRUGO, acpi_device_dir(device));
210         if (!entry)
211                 return -ENODEV;
212         else {
213                 entry->proc_fops = &acpi_button_info_fops;
214                 entry->data = acpi_driver_data(device);
215                 entry->owner = THIS_MODULE;
216         }
217
218         /* show lid state [R] */
219         if (button->type == ACPI_BUTTON_TYPE_LID) {
220                 entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,
221                                           S_IRUGO, acpi_device_dir(device));
222                 if (!entry)
223                         return -ENODEV;
224                 else {
225                         entry->proc_fops = &acpi_button_state_fops;
226                         entry->data = acpi_driver_data(device);
227                         entry->owner = THIS_MODULE;
228                 }
229         }
230
231         return 0;
232 }
233
234 static int acpi_button_remove_fs(struct acpi_device *device)
235 {
236         struct acpi_button *button = acpi_driver_data(device);
237
238         if (acpi_device_dir(device)) {
239                 if (button->type == ACPI_BUTTON_TYPE_LID)
240                         remove_proc_entry(ACPI_BUTTON_FILE_STATE,
241                                           acpi_device_dir(device));
242                 remove_proc_entry(ACPI_BUTTON_FILE_INFO,
243                                   acpi_device_dir(device));
244
245                 remove_proc_entry(acpi_device_bid(device),
246                                   acpi_device_dir(device)->parent);
247                 acpi_device_dir(device) = NULL;
248         }
249
250         return 0;
251 }
252
253 /* --------------------------------------------------------------------------
254                                 Driver Interface
255    -------------------------------------------------------------------------- */
256
257 static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
258 {
259         struct acpi_button *button = data;
260         struct input_dev *input;
261
262         if (!button || !button->device)
263                 return;
264
265         switch (event) {
266         case ACPI_BUTTON_NOTIFY_STATUS:
267                 input = button->input;
268
269                 if (button->type == ACPI_BUTTON_TYPE_LID) {
270                         struct acpi_handle *handle = button->device->handle;
271                         unsigned long state;
272
273                         if (!ACPI_FAILURE(acpi_evaluate_integer(handle, "_LID",
274                                                                 NULL, &state)))
275                                 input_report_switch(input, SW_LID, !state);
276
277                 } else {
278                         int keycode = test_bit(KEY_SLEEP, input->keybit) ?
279                                                 KEY_SLEEP : KEY_POWER;
280
281                         input_report_key(input, keycode, 1);
282                         input_sync(input);
283                         input_report_key(input, keycode, 0);
284                 }
285                 input_sync(input);
286
287                 acpi_bus_generate_event(button->device, event,
288                                         ++button->pushed);
289                 break;
290         default:
291                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
292                                   "Unsupported event [0x%x]\n", event));
293                 break;
294         }
295
296         return;
297 }
298
299 static acpi_status acpi_button_notify_fixed(void *data)
300 {
301         struct acpi_button *button = data;
302
303         if (!button)
304                 return AE_BAD_PARAMETER;
305
306         acpi_button_notify(button->device->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
307
308         return AE_OK;
309 }
310
311 static int acpi_button_install_notify_handlers(struct acpi_button *button)
312 {
313         acpi_status status;
314
315         switch (button->type) {
316         case ACPI_BUTTON_TYPE_POWERF:
317                 status =
318                     acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
319                                                      acpi_button_notify_fixed,
320                                                      button);
321                 break;
322         case ACPI_BUTTON_TYPE_SLEEPF:
323                 status =
324                     acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
325                                                      acpi_button_notify_fixed,
326                                                      button);
327                 break;
328         default:
329                 status = acpi_install_notify_handler(button->device->handle,
330                                                      ACPI_DEVICE_NOTIFY,
331                                                      acpi_button_notify,
332                                                      button);
333                 break;
334         }
335
336         return ACPI_FAILURE(status) ? -ENODEV : 0;
337 }
338
339 static void acpi_button_remove_notify_handlers(struct acpi_button *button)
340 {
341         switch (button->type) {
342         case ACPI_BUTTON_TYPE_POWERF:
343                 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
344                                                 acpi_button_notify_fixed);
345                 break;
346         case ACPI_BUTTON_TYPE_SLEEPF:
347                 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
348                                                 acpi_button_notify_fixed);
349                 break;
350         default:
351                 acpi_remove_notify_handler(button->device->handle,
352                                            ACPI_DEVICE_NOTIFY,
353                                            acpi_button_notify);
354                 break;
355         }
356 }
357
358 static int acpi_button_add(struct acpi_device *device)
359 {
360         int error;
361         struct acpi_button *button;
362         struct input_dev *input;
363
364         if (!device)
365                 return -EINVAL;
366
367         button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
368         if (!button)
369                 return -ENOMEM;
370
371         button->device = device;
372         acpi_driver_data(device) = button;
373
374         button->input = input = input_allocate_device();
375         if (!input) {
376                 error = -ENOMEM;
377                 goto err_free_button;
378         }
379
380         /*
381          * Determine the button type (via hid), as fixed-feature buttons
382          * need to be handled a bit differently than generic-space.
383          */
384         if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWER)) {
385                 button->type = ACPI_BUTTON_TYPE_POWER;
386                 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_POWER);
387                 sprintf(acpi_device_class(device), "%s/%s",
388                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
389         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWERF)) {
390                 button->type = ACPI_BUTTON_TYPE_POWERF;
391                 strcpy(acpi_device_name(device),
392                        ACPI_BUTTON_DEVICE_NAME_POWERF);
393                 sprintf(acpi_device_class(device), "%s/%s",
394                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
395         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEP)) {
396                 button->type = ACPI_BUTTON_TYPE_SLEEP;
397                 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_SLEEP);
398                 sprintf(acpi_device_class(device), "%s/%s",
399                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
400         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEPF)) {
401                 button->type = ACPI_BUTTON_TYPE_SLEEPF;
402                 strcpy(acpi_device_name(device),
403                        ACPI_BUTTON_DEVICE_NAME_SLEEPF);
404                 sprintf(acpi_device_class(device), "%s/%s",
405                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
406         } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_LID)) {
407                 button->type = ACPI_BUTTON_TYPE_LID;
408                 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_LID);
409                 sprintf(acpi_device_class(device), "%s/%s",
410                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
411         } else {
412                 printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",
413                             acpi_device_hid(device));
414                 error = -ENODEV;
415                 goto err_free_input;
416         }
417
418         error = acpi_button_add_fs(device);
419         if (error)
420                 goto err_free_input;
421
422         error = acpi_button_install_notify_handlers(button);
423         if (error)
424                 goto err_remove_fs;
425
426         snprintf(button->phys, sizeof(button->phys),
427                  "%s/button/input0", acpi_device_hid(device));
428
429         input->name = acpi_device_name(device);
430         input->phys = button->phys;
431         input->id.bustype = BUS_HOST;
432         input->id.product = button->type;
433
434         switch (button->type) {
435         case ACPI_BUTTON_TYPE_POWER:
436         case ACPI_BUTTON_TYPE_POWERF:
437                 input->evbit[0] = BIT(EV_KEY);
438                 set_bit(KEY_POWER, input->keybit);
439                 break;
440
441         case ACPI_BUTTON_TYPE_SLEEP:
442         case ACPI_BUTTON_TYPE_SLEEPF:
443                 input->evbit[0] = BIT(EV_KEY);
444                 set_bit(KEY_SLEEP, input->keybit);
445                 break;
446
447         case ACPI_BUTTON_TYPE_LID:
448                 input->evbit[0] = BIT(EV_SW);
449                 set_bit(SW_LID, input->swbit);
450                 break;
451         }
452
453         error = input_register_device(input);
454         if (error)
455                 goto err_remove_handlers;
456
457         if (device->wakeup.flags.valid) {
458                 /* Button's GPE is run-wake GPE */
459                 acpi_set_gpe_type(device->wakeup.gpe_device,
460                                   device->wakeup.gpe_number,
461                                   ACPI_GPE_TYPE_WAKE_RUN);
462                 acpi_enable_gpe(device->wakeup.gpe_device,
463                                 device->wakeup.gpe_number, ACPI_NOT_ISR);
464                 device->wakeup.state.enabled = 1;
465         }
466
467         printk(KERN_INFO PREFIX "%s [%s]\n",
468                acpi_device_name(device), acpi_device_bid(device));
469
470         return 0;
471
472  err_remove_handlers:
473         acpi_button_remove_notify_handlers(button);
474  err_remove_fs:
475         acpi_button_remove_fs(device);
476  err_free_input:
477         input_free_device(input);
478  err_free_button:
479         kfree(button);
480         return error;
481 }
482
483 static int acpi_button_remove(struct acpi_device *device, int type)
484 {
485         struct acpi_button *button;
486
487         if (!device || !acpi_driver_data(device))
488                 return -EINVAL;
489
490         button = acpi_driver_data(device);
491
492         acpi_button_remove_notify_handlers(button);
493         acpi_button_remove_fs(device);
494         input_unregister_device(button->input);
495         kfree(button);
496
497         return 0;
498 }
499
500 static int __init acpi_button_init(void)
501 {
502         int result;
503
504         acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
505         if (!acpi_button_dir)
506                 return -ENODEV;
507         acpi_button_dir->owner = THIS_MODULE;
508         result = acpi_bus_register_driver(&acpi_button_driver);
509         if (result < 0) {
510                 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
511                 return -ENODEV;
512         }
513
514         return 0;
515 }
516
517 static void __exit acpi_button_exit(void)
518 {
519         acpi_bus_unregister_driver(&acpi_button_driver);
520
521         if (acpi_power_dir)
522                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);
523         if (acpi_sleep_dir)
524                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);
525         if (acpi_lid_dir)
526                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
527         remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
528 }
529
530 module_init(acpi_button_init);
531 module_exit(acpi_button_exit);