Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 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

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_resume(struct device *dev);
 83 #else
 84 #define acpi_button_resume NULL
 85 #endif
 86 static SIMPLE_DEV_PM_OPS(acpi_button_pm, NULL, acpi_button_resume);
 87 
 88 static struct acpi_driver acpi_button_driver = {
 89         .name = "button",
 90         .class = ACPI_BUTTON_CLASS,
 91         .ids = button_device_ids,
 92         .ops = {
 93                 .add = acpi_button_add,
 94                 .remove = acpi_button_remove,
 95                 .notify = acpi_button_notify,
 96         },
 97         .drv.pm = &acpi_button_pm,
 98 };
 99 
100 struct acpi_button {
101         unsigned int type;
102         struct input_dev *input;
103         char phys[32];                  /* for input device */
104         unsigned long pushed;
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                         acpi_bus_generate_netlink_event(
306                                         device->pnp.device_class,
307                                         dev_name(&device->dev),
308                                         event, ++button->pushed);
309                 }
310                 break;
311         default:
312                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
313                                   "Unsupported event [0x%x]\n", event));
314                 break;
315         }
316 }
317 
318 #ifdef CONFIG_PM_SLEEP
319 static int acpi_button_resume(struct device *dev)
320 {
321         struct acpi_device *device = to_acpi_device(dev);
322         struct acpi_button *button = acpi_driver_data(device);
323 
324         if (button->type == ACPI_BUTTON_TYPE_LID)
325                 return acpi_lid_send_state(device);
326         return 0;
327 }
328 #endif
329 
330 static int acpi_button_add(struct acpi_device *device)
331 {
332         struct acpi_button *button;
333         struct input_dev *input;
334         const char *hid = acpi_device_hid(device);
335         char *name, *class;
336         int error;
337 
338         button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
339         if (!button)
340                 return -ENOMEM;
341 
342         device->driver_data = button;
343 
344         button->input = input = input_allocate_device();
345         if (!input) {
346                 error = -ENOMEM;
347                 goto err_free_button;
348         }
349 
350         name = acpi_device_name(device);
351         class = acpi_device_class(device);
352 
353         if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
354             !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
355                 button->type = ACPI_BUTTON_TYPE_POWER;
356                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
357                 sprintf(class, "%s/%s",
358                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
359         } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
360                    !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
361                 button->type = ACPI_BUTTON_TYPE_SLEEP;
362                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
363                 sprintf(class, "%s/%s",
364                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
365         } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
366                 button->type = ACPI_BUTTON_TYPE_LID;
367                 strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
368                 sprintf(class, "%s/%s",
369                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
370         } else {
371                 printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
372                 error = -ENODEV;
373                 goto err_free_input;
374         }
375 
376         error = acpi_button_add_fs(device);
377         if (error)
378                 goto err_free_input;
379 
380         snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
381 
382         input->name = name;
383         input->phys = button->phys;
384         input->id.bustype = BUS_HOST;
385         input->id.product = button->type;
386         input->dev.parent = &device->dev;
387 
388         switch (button->type) {
389         case ACPI_BUTTON_TYPE_POWER:
390                 input_set_capability(input, EV_KEY, KEY_POWER);
391                 break;
392 
393         case ACPI_BUTTON_TYPE_SLEEP:
394                 input_set_capability(input, EV_KEY, KEY_SLEEP);
395                 break;
396 
397         case ACPI_BUTTON_TYPE_LID:
398                 input_set_capability(input, EV_SW, SW_LID);
399                 break;
400         }
401 
402         error = input_register_device(input);
403         if (error)
404                 goto err_remove_fs;
405         if (button->type == ACPI_BUTTON_TYPE_LID) {
406                 acpi_lid_send_state(device);
407                 /*
408                  * This assumes there's only one lid device, or if there are
409                  * more we only care about the last one...
410                  */
411                 lid_device = device;
412         }
413 
414         printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
415         return 0;
416 
417  err_remove_fs:
418         acpi_button_remove_fs(device);
419  err_free_input:
420         input_free_device(input);
421  err_free_button:
422         kfree(button);
423         return error;
424 }
425 
426 static int acpi_button_remove(struct acpi_device *device)
427 {
428         struct acpi_button *button = acpi_driver_data(device);
429 
430         acpi_button_remove_fs(device);
431         input_unregister_device(button->input);
432         kfree(button);
433         return 0;
434 }
435 
436 module_acpi_driver(acpi_button_driver);
437 

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