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