Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us