Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

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

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