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