blob: 171fd914f43533f46bf417dd4d4a7b6936fc6e50 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * acpi_button.c - ACPI Button Driver ($Revision: 30 $)
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>
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -040029#include <linux/types.h>
30#include <linux/proc_fs.h>
31#include <linux/seq_file.h>
Dmitry Torokhovc0968f02006-11-09 00:40:13 -050032#include <linux/input.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <acpi/acpi_bus.h>
34#include <acpi/acpi_drivers.h>
35
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#define ACPI_BUTTON_CLASS "button"
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -040037#define ACPI_BUTTON_FILE_INFO "info"
38#define ACPI_BUTTON_FILE_STATE "state"
39#define ACPI_BUTTON_TYPE_UNKNOWN 0x00
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#define ACPI_BUTTON_NOTIFY_STATUS 0x80
41
42#define ACPI_BUTTON_SUBCLASS_POWER "power"
Len Brown4be44fc2005-08-05 00:44:28 -040043#define ACPI_BUTTON_HID_POWER "PNP0C0C"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#define ACPI_BUTTON_DEVICE_NAME_POWER "Power Button (CM)"
45#define ACPI_BUTTON_DEVICE_NAME_POWERF "Power Button (FF)"
46#define ACPI_BUTTON_TYPE_POWER 0x01
47#define ACPI_BUTTON_TYPE_POWERF 0x02
48
49#define ACPI_BUTTON_SUBCLASS_SLEEP "sleep"
50#define ACPI_BUTTON_HID_SLEEP "PNP0C0E"
51#define ACPI_BUTTON_DEVICE_NAME_SLEEP "Sleep Button (CM)"
52#define ACPI_BUTTON_DEVICE_NAME_SLEEPF "Sleep Button (FF)"
53#define ACPI_BUTTON_TYPE_SLEEP 0x03
54#define ACPI_BUTTON_TYPE_SLEEPF 0x04
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
Len Brownf52fd662007-02-12 22:42:12 -050062ACPI_MODULE_NAME("button");
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Dmitry Torokhovc0968f02006-11-09 00:40:13 -050064MODULE_AUTHOR("Paul Diefenbaugh");
Len Brown7cda93e2007-02-12 23:50:02 -050065MODULE_DESCRIPTION("ACPI Button Driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070066MODULE_LICENSE("GPL");
67
Thomas Renninger1ba90e32007-07-23 14:44:41 +020068static 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};
76MODULE_DEVICE_TABLE(acpi, button_device_ids);
77
Len Brown4be44fc2005-08-05 00:44:28 -040078static int acpi_button_add(struct acpi_device *device);
79static int acpi_button_remove(struct acpi_device *device, int type);
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +040080static int acpi_button_resume(struct acpi_device *device);
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -040081static int acpi_button_info_open_fs(struct inode *inode, struct file *file);
82static int acpi_button_state_open_fs(struct inode *inode, struct file *file);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84static struct acpi_driver acpi_button_driver = {
Len Brownc2b67052007-02-12 23:33:40 -050085 .name = "button",
Len Brown4be44fc2005-08-05 00:44:28 -040086 .class = ACPI_BUTTON_CLASS,
Thomas Renninger1ba90e32007-07-23 14:44:41 +020087 .ids = button_device_ids,
Len Brown4be44fc2005-08-05 00:44:28 -040088 .ops = {
89 .add = acpi_button_add,
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +040090 .resume = acpi_button_resume,
Len Brown4be44fc2005-08-05 00:44:28 -040091 .remove = acpi_button_remove,
Dmitry Torokhovc0968f02006-11-09 00:40:13 -050092 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070093};
94
95struct acpi_button {
Len Brown4be44fc2005-08-05 00:44:28 -040096 struct acpi_device *device; /* Fixed button kludge */
Dmitry Torokhovc0968f02006-11-09 00:40:13 -050097 unsigned int type;
98 struct input_dev *input;
99 char phys[32]; /* for input device */
Len Brown4be44fc2005-08-05 00:44:28 -0400100 unsigned long pushed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101};
102
Arjan van de Vend7508032006-07-04 13:06:00 -0400103static const struct file_operations acpi_button_info_fops = {
Denis V. Lunevcf7acfa2008-04-29 01:02:27 -0700104 .owner = THIS_MODULE,
Len Brown4be44fc2005-08-05 00:44:28 -0400105 .open = acpi_button_info_open_fs,
106 .read = seq_read,
107 .llseek = seq_lseek,
108 .release = single_release,
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400109};
110
Arjan van de Vend7508032006-07-04 13:06:00 -0400111static const struct file_operations acpi_button_state_fops = {
Denis V. Lunevcf7acfa2008-04-29 01:02:27 -0700112 .owner = THIS_MODULE,
Len Brown4be44fc2005-08-05 00:44:28 -0400113 .open = acpi_button_state_open_fs,
114 .read = seq_read,
115 .llseek = seq_lseek,
116 .release = single_release,
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400117};
Len Brown4be44fc2005-08-05 00:44:28 -0400118
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400119/* --------------------------------------------------------------------------
120 FS Interface (/proc)
121 -------------------------------------------------------------------------- */
122
Len Brown4be44fc2005-08-05 00:44:28 -0400123static struct proc_dir_entry *acpi_button_dir;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400124
125static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
126{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500127 struct acpi_button *button = seq->private;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400128
129 if (!button || !button->device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400130 return 0;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400131
Len Brown4be44fc2005-08-05 00:44:28 -0400132 seq_printf(seq, "type: %s\n",
133 acpi_device_name(button->device));
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400134
Patrick Mocheld550d982006-06-27 00:41:40 -0400135 return 0;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400136}
137
138static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
139{
140 return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);
141}
Len Brown4be44fc2005-08-05 00:44:28 -0400142
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400143static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
144{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500145 struct acpi_button *button = seq->private;
Len Brown4be44fc2005-08-05 00:44:28 -0400146 acpi_status status;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400147 unsigned long long state;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400148
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400149 if (!button || !button->device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400150 return 0;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400151
Patrick Mochel27b1d3e2006-05-19 16:54:42 -0400152 status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500153 seq_printf(seq, "state: %s\n",
154 ACPI_FAILURE(status) ? "unsupported" :
155 (state ? "open" : "closed"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400156 return 0;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400157}
158
159static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
160{
161 return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);
162}
163
164static struct proc_dir_entry *acpi_power_dir;
165static struct proc_dir_entry *acpi_sleep_dir;
166static struct proc_dir_entry *acpi_lid_dir;
167
Len Brown4be44fc2005-08-05 00:44:28 -0400168static int acpi_button_add_fs(struct acpi_device *device)
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400169{
Len Brown4be44fc2005-08-05 00:44:28 -0400170 struct proc_dir_entry *entry = NULL;
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500171 struct acpi_button *button;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400172
173 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400174 return -EINVAL;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400175
176 button = acpi_driver_data(device);
177
178 switch (button->type) {
179 case ACPI_BUTTON_TYPE_POWER:
180 case ACPI_BUTTON_TYPE_POWERF:
181 if (!acpi_power_dir)
Len Brown4be44fc2005-08-05 00:44:28 -0400182 acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,
183 acpi_button_dir);
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400184 entry = acpi_power_dir;
185 break;
186 case ACPI_BUTTON_TYPE_SLEEP:
187 case ACPI_BUTTON_TYPE_SLEEPF:
188 if (!acpi_sleep_dir)
Len Brown4be44fc2005-08-05 00:44:28 -0400189 acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,
190 acpi_button_dir);
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400191 entry = acpi_sleep_dir;
192 break;
193 case ACPI_BUTTON_TYPE_LID:
194 if (!acpi_lid_dir)
Len Brown4be44fc2005-08-05 00:44:28 -0400195 acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID,
196 acpi_button_dir);
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400197 entry = acpi_lid_dir;
198 break;
199 }
200
201 if (!entry)
Patrick Mocheld550d982006-06-27 00:41:40 -0400202 return -ENODEV;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400203 entry->owner = THIS_MODULE;
204
205 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
206 if (!acpi_device_dir(device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400207 return -ENODEV;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400208 acpi_device_dir(device)->owner = THIS_MODULE;
209
210 /* 'info' [R] */
Denis V. Lunevcf7acfa2008-04-29 01:02:27 -0700211 entry = proc_create_data(ACPI_BUTTON_FILE_INFO,
212 S_IRUGO, acpi_device_dir(device),
213 &acpi_button_info_fops,
214 acpi_driver_data(device));
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400215 if (!entry)
Patrick Mocheld550d982006-06-27 00:41:40 -0400216 return -ENODEV;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400217
218 /* show lid state [R] */
219 if (button->type == ACPI_BUTTON_TYPE_LID) {
Denis V. Lunevcf7acfa2008-04-29 01:02:27 -0700220 entry = proc_create_data(ACPI_BUTTON_FILE_STATE,
221 S_IRUGO, acpi_device_dir(device),
222 &acpi_button_state_fops,
223 acpi_driver_data(device));
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400224 if (!entry)
Thomas Renningera6fc6722006-06-26 23:58:43 -0400225 return -ENODEV;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400226 }
227
Patrick Mocheld550d982006-06-27 00:41:40 -0400228 return 0;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400229}
230
Len Brown4be44fc2005-08-05 00:44:28 -0400231static int acpi_button_remove_fs(struct acpi_device *device)
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400232{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500233 struct acpi_button *button = acpi_driver_data(device);
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400234
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400235 if (acpi_device_dir(device)) {
236 if (button->type == ACPI_BUTTON_TYPE_LID)
237 remove_proc_entry(ACPI_BUTTON_FILE_STATE,
Len Brown4be44fc2005-08-05 00:44:28 -0400238 acpi_device_dir(device));
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400239 remove_proc_entry(ACPI_BUTTON_FILE_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400240 acpi_device_dir(device));
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400241
242 remove_proc_entry(acpi_device_bid(device),
Len Brown4be44fc2005-08-05 00:44:28 -0400243 acpi_device_dir(device)->parent);
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400244 acpi_device_dir(device) = NULL;
245 }
246
Patrick Mocheld550d982006-06-27 00:41:40 -0400247 return 0;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400248}
249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250/* --------------------------------------------------------------------------
251 Driver Interface
252 -------------------------------------------------------------------------- */
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +0400253static int acpi_lid_send_state(struct acpi_button *button)
254{
Matthew Wilcox27663c52008-10-10 02:22:59 -0400255 unsigned long long state;
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +0400256 acpi_status status;
257
258 status = acpi_evaluate_integer(button->device->handle, "_LID", NULL,
259 &state);
260 if (ACPI_FAILURE(status))
261 return -ENODEV;
262 /* input layer checks if event is redundant */
263 input_report_switch(button->input, SW_LID, !state);
Guillem Joverdf316e92008-10-24 00:28:33 +0300264 input_sync(button->input);
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +0400265 return 0;
266}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Len Brown4be44fc2005-08-05 00:44:28 -0400268static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500270 struct acpi_button *button = data;
271 struct input_dev *input;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273 if (!button || !button->device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400274 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 switch (event) {
277 case ACPI_BUTTON_NOTIFY_STATUS:
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500278 input = button->input;
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500279 if (button->type == ACPI_BUTTON_TYPE_LID) {
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +0400280 acpi_lid_send_state(button);
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500281 } else {
282 int keycode = test_bit(KEY_SLEEP, input->keybit) ?
283 KEY_SLEEP : KEY_POWER;
284
285 input_report_key(input, keycode, 1);
286 input_sync(input);
287 input_report_key(input, keycode, 0);
Guillem Joverdf316e92008-10-24 00:28:33 +0300288 input_sync(input);
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500289 }
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500290
Len Brown14e04fb2007-08-23 15:20:26 -0400291 acpi_bus_generate_proc_event(button->device, event,
Len Brown4be44fc2005-08-05 00:44:28 -0400292 ++button->pushed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 break;
294 default:
295 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400296 "Unsupported event [0x%x]\n", event));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 break;
298 }
299
Patrick Mocheld550d982006-06-27 00:41:40 -0400300 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301}
302
Len Brown4be44fc2005-08-05 00:44:28 -0400303static acpi_status acpi_button_notify_fixed(void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500305 struct acpi_button *button = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400307 if (!button)
Patrick Mocheld550d982006-06-27 00:41:40 -0400308 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
Patrick Mochel27b1d3e2006-05-19 16:54:42 -0400310 acpi_button_notify(button->device->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
Patrick Mocheld550d982006-06-27 00:41:40 -0400312 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500315static int acpi_button_install_notify_handlers(struct acpi_button *button)
316{
317 acpi_status status;
318
319 switch (button->type) {
320 case ACPI_BUTTON_TYPE_POWERF:
321 status =
322 acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
323 acpi_button_notify_fixed,
324 button);
325 break;
326 case ACPI_BUTTON_TYPE_SLEEPF:
327 status =
328 acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
329 acpi_button_notify_fixed,
330 button);
331 break;
332 default:
333 status = acpi_install_notify_handler(button->device->handle,
334 ACPI_DEVICE_NOTIFY,
335 acpi_button_notify,
336 button);
337 break;
338 }
339
340 return ACPI_FAILURE(status) ? -ENODEV : 0;
341}
342
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +0400343static int acpi_button_resume(struct acpi_device *device)
344{
345 struct acpi_button *button;
346 if (!device)
347 return -EINVAL;
348 button = acpi_driver_data(device);
349 if (button && button->type == ACPI_BUTTON_TYPE_LID)
350 return acpi_lid_send_state(button);
351 return 0;
352}
353
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500354static void acpi_button_remove_notify_handlers(struct acpi_button *button)
355{
356 switch (button->type) {
357 case ACPI_BUTTON_TYPE_POWERF:
358 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
359 acpi_button_notify_fixed);
360 break;
361 case ACPI_BUTTON_TYPE_SLEEPF:
362 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
363 acpi_button_notify_fixed);
364 break;
365 default:
366 acpi_remove_notify_handler(button->device->handle,
367 ACPI_DEVICE_NOTIFY,
368 acpi_button_notify);
369 break;
370 }
371}
372
Len Brown4be44fc2005-08-05 00:44:28 -0400373static int acpi_button_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500375 int error;
376 struct acpi_button *button;
377 struct input_dev *input;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
379 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400380 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500382 button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (!button)
Patrick Mocheld550d982006-06-27 00:41:40 -0400384 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
386 button->device = device;
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700387 device->driver_data = button;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500389 button->input = input = input_allocate_device();
390 if (!input) {
391 error = -ENOMEM;
392 goto err_free_button;
393 }
394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 /*
396 * Determine the button type (via hid), as fixed-feature buttons
397 * need to be handled a bit differently than generic-space.
398 */
399 if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWER)) {
400 button->type = ACPI_BUTTON_TYPE_POWER;
Len Brown4be44fc2005-08-05 00:44:28 -0400401 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_POWER);
402 sprintf(acpi_device_class(device), "%s/%s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
Len Brown4be44fc2005-08-05 00:44:28 -0400404 } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWERF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 button->type = ACPI_BUTTON_TYPE_POWERF;
406 strcpy(acpi_device_name(device),
Len Brown4be44fc2005-08-05 00:44:28 -0400407 ACPI_BUTTON_DEVICE_NAME_POWERF);
408 sprintf(acpi_device_class(device), "%s/%s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
Len Brown4be44fc2005-08-05 00:44:28 -0400410 } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 button->type = ACPI_BUTTON_TYPE_SLEEP;
Len Brown4be44fc2005-08-05 00:44:28 -0400412 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_SLEEP);
413 sprintf(acpi_device_class(device), "%s/%s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
Len Brown4be44fc2005-08-05 00:44:28 -0400415 } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEPF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 button->type = ACPI_BUTTON_TYPE_SLEEPF;
417 strcpy(acpi_device_name(device),
Len Brown4be44fc2005-08-05 00:44:28 -0400418 ACPI_BUTTON_DEVICE_NAME_SLEEPF);
419 sprintf(acpi_device_class(device), "%s/%s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
Len Brown4be44fc2005-08-05 00:44:28 -0400421 } else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_LID)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 button->type = ACPI_BUTTON_TYPE_LID;
Len Brown4be44fc2005-08-05 00:44:28 -0400423 strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_LID);
424 sprintf(acpi_device_class(device), "%s/%s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
Len Brown4be44fc2005-08-05 00:44:28 -0400426 } else {
Len Brown64684632006-06-26 23:41:38 -0400427 printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",
428 acpi_device_hid(device));
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500429 error = -ENODEV;
430 goto err_free_input;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 }
432
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500433 error = acpi_button_add_fs(device);
434 if (error)
435 goto err_free_input;
436
437 error = acpi_button_install_notify_handlers(button);
438 if (error)
439 goto err_remove_fs;
440
441 snprintf(button->phys, sizeof(button->phys),
442 "%s/button/input0", acpi_device_hid(device));
443
444 input->name = acpi_device_name(device);
445 input->phys = button->phys;
446 input->id.bustype = BUS_HOST;
447 input->id.product = button->type;
Andrey Borzenkov3b34e522008-03-04 15:06:35 -0800448 input->dev.parent = &device->dev;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 switch (button->type) {
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500451 case ACPI_BUTTON_TYPE_POWER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 case ACPI_BUTTON_TYPE_POWERF:
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700453 input->evbit[0] = BIT_MASK(EV_KEY);
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500454 set_bit(KEY_POWER, input->keybit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 break;
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500456
457 case ACPI_BUTTON_TYPE_SLEEP:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 case ACPI_BUTTON_TYPE_SLEEPF:
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700459 input->evbit[0] = BIT_MASK(EV_KEY);
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500460 set_bit(KEY_SLEEP, input->keybit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 break;
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500462
463 case ACPI_BUTTON_TYPE_LID:
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700464 input->evbit[0] = BIT_MASK(EV_SW);
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500465 set_bit(SW_LID, input->swbit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 break;
467 }
468
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500469 error = input_register_device(input);
470 if (error)
471 goto err_remove_handlers;
Alexey Starikovskiy23de5d92007-10-22 14:18:18 +0400472 if (button->type == ACPI_BUTTON_TYPE_LID)
473 acpi_lid_send_state(button);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
475 if (device->wakeup.flags.valid) {
476 /* Button's GPE is run-wake GPE */
Len Brown4be44fc2005-08-05 00:44:28 -0400477 acpi_set_gpe_type(device->wakeup.gpe_device,
478 device->wakeup.gpe_number,
479 ACPI_GPE_TYPE_WAKE_RUN);
480 acpi_enable_gpe(device->wakeup.gpe_device,
Alexey Starikovskiy0b7084a2008-10-25 21:48:46 +0400481 device->wakeup.gpe_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 device->wakeup.state.enabled = 1;
483 }
484
Len Brown4be44fc2005-08-05 00:44:28 -0400485 printk(KERN_INFO PREFIX "%s [%s]\n",
486 acpi_device_name(device), acpi_device_bid(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500488 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500490 err_remove_handlers:
491 acpi_button_remove_notify_handlers(button);
492 err_remove_fs:
493 acpi_button_remove_fs(device);
494 err_free_input:
495 input_free_device(input);
496 err_free_button:
497 kfree(button);
498 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
500
Len Brown4be44fc2005-08-05 00:44:28 -0400501static int acpi_button_remove(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500503 struct acpi_button *button;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400506 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
508 button = acpi_driver_data(device);
509
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500510 acpi_button_remove_notify_handlers(button);
Len Brown4be44fc2005-08-05 00:44:28 -0400511 acpi_button_remove_fs(device);
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500512 input_unregister_device(button->input);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 kfree(button);
514
Patrick Mocheld550d982006-06-27 00:41:40 -0400515 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516}
517
Len Brown4be44fc2005-08-05 00:44:28 -0400518static int __init acpi_button_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
Dmitry Torokhovc0968f02006-11-09 00:40:13 -0500520 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400522 acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
523 if (!acpi_button_dir)
Patrick Mocheld550d982006-06-27 00:41:40 -0400524 return -ENODEV;
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400525 acpi_button_dir->owner = THIS_MODULE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 result = acpi_bus_register_driver(&acpi_button_driver);
527 if (result < 0) {
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400528 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
Patrick Mocheld550d982006-06-27 00:41:40 -0400529 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 }
531
Patrick Mocheld550d982006-06-27 00:41:40 -0400532 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533}
534
Len Brown4be44fc2005-08-05 00:44:28 -0400535static void __exit acpi_button_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 acpi_bus_unregister_driver(&acpi_button_driver);
538
Len Brown4be44fc2005-08-05 00:44:28 -0400539 if (acpi_power_dir)
Alexey Starikovskiyb34a8032005-08-03 17:55:21 -0400540 remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, acpi_button_dir);
541 if (acpi_sleep_dir)
542 remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_button_dir);
543 if (acpi_lid_dir)
544 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
545 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548module_init(acpi_button_init);
549module_exit(acpi_button_exit);