2 * ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
4 * Copyright © 2010 Intel Corporation
5 * Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/types.h>
27 #include <acpi/acpi_bus.h>
28 #include <acpi/acpi_drivers.h>
29 #include <linux/rfkill.h>
30 #include <linux/platform_device.h>
31 #include <linux/input.h>
32 #include <linux/input/sparse-keymap.h>
34 #define IDEAPAD_DEV_CAMERA 0
35 #define IDEAPAD_DEV_WLAN 1
36 #define IDEAPAD_DEV_BLUETOOTH 2
37 #define IDEAPAD_DEV_3G 3
38 #define IDEAPAD_DEV_KILLSW 4
40 struct ideapad_private
{
42 struct rfkill
*rfk
[5];
43 struct platform_device
*platform_device
;
44 struct input_dev
*inputdev
;
52 } ideapad_rfk_data
[] = {
53 { "ideapad_camera", 19, 0x1E, NUM_RFKILL_TYPES
},
54 { "ideapad_wlan", 18, 0x15, RFKILL_TYPE_WLAN
},
55 { "ideapad_bluetooth", 16, 0x17, RFKILL_TYPE_BLUETOOTH
},
56 { "ideapad_3g", 17, 0x20, RFKILL_TYPE_WWAN
},
57 { "ideapad_killsw", 0, 0, RFKILL_TYPE_WLAN
}
60 static bool no_bt_rfkill
;
61 module_param(no_bt_rfkill
, bool, 0444);
62 MODULE_PARM_DESC(no_bt_rfkill
, "No rfkill for bluetooth.");
67 #define IDEAPAD_EC_TIMEOUT (100) /* in ms */
69 static int read_method_int(acpi_handle handle
, const char *method
, int *val
)
72 unsigned long long result
;
74 status
= acpi_evaluate_integer(handle
, (char *)method
, NULL
, &result
);
75 if (ACPI_FAILURE(status
)) {
84 static int method_vpcr(acpi_handle handle
, int cmd
, int *ret
)
87 unsigned long long result
;
88 struct acpi_object_list params
;
89 union acpi_object in_obj
;
92 params
.pointer
= &in_obj
;
93 in_obj
.type
= ACPI_TYPE_INTEGER
;
94 in_obj
.integer
.value
= cmd
;
96 status
= acpi_evaluate_integer(handle
, "VPCR", ¶ms
, &result
);
98 if (ACPI_FAILURE(status
)) {
107 static int method_vpcw(acpi_handle handle
, int cmd
, int data
)
109 struct acpi_object_list params
;
110 union acpi_object in_obj
[2];
114 params
.pointer
= in_obj
;
115 in_obj
[0].type
= ACPI_TYPE_INTEGER
;
116 in_obj
[0].integer
.value
= cmd
;
117 in_obj
[1].type
= ACPI_TYPE_INTEGER
;
118 in_obj
[1].integer
.value
= data
;
120 status
= acpi_evaluate_object(handle
, "VPCW", ¶ms
, NULL
);
126 static int read_ec_data(acpi_handle handle
, int cmd
, unsigned long *data
)
129 unsigned long int end_jiffies
;
131 if (method_vpcw(handle
, 1, cmd
))
134 for (end_jiffies
= jiffies
+(HZ
)*IDEAPAD_EC_TIMEOUT
/1000+1;
135 time_before(jiffies
, end_jiffies
);) {
137 if (method_vpcr(handle
, 1, &val
))
140 if (method_vpcr(handle
, 0, &val
))
146 pr_err("timeout in read_ec_cmd\n");
150 static int write_ec_cmd(acpi_handle handle
, int cmd
, unsigned long data
)
153 unsigned long int end_jiffies
;
155 if (method_vpcw(handle
, 0, data
))
157 if (method_vpcw(handle
, 1, cmd
))
160 for (end_jiffies
= jiffies
+(HZ
)*IDEAPAD_EC_TIMEOUT
/1000+1;
161 time_before(jiffies
, end_jiffies
);) {
163 if (method_vpcr(handle
, 1, &val
))
168 pr_err("timeout in write_ec_cmd\n");
175 static ssize_t
show_ideapad_cam(struct device
*dev
,
176 struct device_attribute
*attr
,
179 struct ideapad_private
*priv
= dev_get_drvdata(dev
);
180 acpi_handle handle
= priv
->handle
;
181 unsigned long result
;
183 if (read_ec_data(handle
, 0x1D, &result
))
184 return sprintf(buf
, "-1\n");
185 return sprintf(buf
, "%lu\n", result
);
188 static ssize_t
store_ideapad_cam(struct device
*dev
,
189 struct device_attribute
*attr
,
190 const char *buf
, size_t count
)
192 struct ideapad_private
*priv
= dev_get_drvdata(dev
);
193 acpi_handle handle
= priv
->handle
;
198 if (sscanf(buf
, "%i", &state
) != 1)
200 ret
= write_ec_cmd(handle
, 0x1E, state
);
206 static DEVICE_ATTR(camera_power
, 0644, show_ideapad_cam
, store_ideapad_cam
);
211 static int ideapad_rfk_set(void *data
, bool blocked
)
213 int device
= (unsigned long)data
;
215 if (device
== IDEAPAD_DEV_KILLSW
)
218 return write_ec_cmd(ideapad_priv
->handle
,
219 ideapad_rfk_data
[device
].opcode
,
223 static struct rfkill_ops ideapad_rfk_ops
= {
224 .set_block
= ideapad_rfk_set
,
227 static void ideapad_sync_rfk_state(struct acpi_device
*adevice
)
229 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
230 acpi_handle handle
= priv
->handle
;
231 unsigned long hw_blocked
;
234 if (read_ec_data(handle
, 0x23, &hw_blocked
))
236 hw_blocked
= !hw_blocked
;
238 for (i
= IDEAPAD_DEV_WLAN
; i
<= IDEAPAD_DEV_KILLSW
; i
++)
240 rfkill_set_hw_state(priv
->rfk
[i
], hw_blocked
);
243 static int __devinit
ideapad_register_rfkill(struct acpi_device
*adevice
,
246 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
248 unsigned long sw_blocked
;
251 (ideapad_rfk_data
[dev
].type
== RFKILL_TYPE_BLUETOOTH
)) {
252 /* Force to enable bluetooth when no_bt_rfkill=1 */
253 write_ec_cmd(ideapad_priv
->handle
,
254 ideapad_rfk_data
[dev
].opcode
, 1);
258 priv
->rfk
[dev
] = rfkill_alloc(ideapad_rfk_data
[dev
].name
, &adevice
->dev
,
259 ideapad_rfk_data
[dev
].type
, &ideapad_rfk_ops
,
264 if (read_ec_data(ideapad_priv
->handle
, ideapad_rfk_data
[dev
].opcode
-1,
266 rfkill_init_sw_state(priv
->rfk
[dev
], 0);
268 sw_blocked
= !sw_blocked
;
269 rfkill_init_sw_state(priv
->rfk
[dev
], sw_blocked
);
272 ret
= rfkill_register(priv
->rfk
[dev
]);
274 rfkill_destroy(priv
->rfk
[dev
]);
280 static void __devexit
ideapad_unregister_rfkill(struct acpi_device
*adevice
,
283 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
288 rfkill_unregister(priv
->rfk
[dev
]);
289 rfkill_destroy(priv
->rfk
[dev
]);
295 static struct attribute
*ideapad_attributes
[] = {
296 &dev_attr_camera_power
.attr
,
300 static struct attribute_group ideapad_attribute_group
= {
301 .attrs
= ideapad_attributes
304 static int __devinit
ideapad_platform_init(struct ideapad_private
*priv
)
308 priv
->platform_device
= platform_device_alloc("ideapad", -1);
309 if (!priv
->platform_device
)
311 platform_set_drvdata(priv
->platform_device
, priv
);
313 result
= platform_device_add(priv
->platform_device
);
315 goto fail_platform_device
;
317 result
= sysfs_create_group(&priv
->platform_device
->dev
.kobj
,
318 &ideapad_attribute_group
);
324 platform_device_del(priv
->platform_device
);
325 fail_platform_device
:
326 platform_device_put(priv
->platform_device
);
330 static void ideapad_platform_exit(struct ideapad_private
*priv
)
332 sysfs_remove_group(&priv
->platform_device
->dev
.kobj
,
333 &ideapad_attribute_group
);
334 platform_device_unregister(priv
->platform_device
);
340 static const struct key_entry ideapad_keymap
[] = {
341 { KE_KEY
, 0x06, { KEY_SWITCHVIDEOMODE
} },
342 { KE_KEY
, 0x0D, { KEY_WLAN
} },
346 static int __devinit
ideapad_input_init(struct ideapad_private
*priv
)
348 struct input_dev
*inputdev
;
351 inputdev
= input_allocate_device();
353 pr_info("Unable to allocate input device\n");
357 inputdev
->name
= "Ideapad extra buttons";
358 inputdev
->phys
= "ideapad/input0";
359 inputdev
->id
.bustype
= BUS_HOST
;
360 inputdev
->dev
.parent
= &priv
->platform_device
->dev
;
362 error
= sparse_keymap_setup(inputdev
, ideapad_keymap
, NULL
);
364 pr_err("Unable to setup input device keymap\n");
368 error
= input_register_device(inputdev
);
370 pr_err("Unable to register input device\n");
371 goto err_free_keymap
;
374 priv
->inputdev
= inputdev
;
378 sparse_keymap_free(inputdev
);
380 input_free_device(inputdev
);
384 static void __devexit
ideapad_input_exit(struct ideapad_private
*priv
)
386 sparse_keymap_free(priv
->inputdev
);
387 input_unregister_device(priv
->inputdev
);
388 priv
->inputdev
= NULL
;
391 static void ideapad_input_report(struct ideapad_private
*priv
,
392 unsigned long scancode
)
394 sparse_keymap_report_event(priv
->inputdev
, scancode
, 1, true);
400 static const struct acpi_device_id ideapad_device_ids
[] = {
404 MODULE_DEVICE_TABLE(acpi
, ideapad_device_ids
);
406 static int __devinit
ideapad_acpi_add(struct acpi_device
*adevice
)
409 struct ideapad_private
*priv
;
411 if (read_method_int(adevice
->handle
, "_CFG", &cfg
))
414 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
418 priv
->handle
= adevice
->handle
;
419 dev_set_drvdata(&adevice
->dev
, priv
);
421 ret
= ideapad_platform_init(priv
);
423 goto platform_failed
;
425 ret
= ideapad_input_init(priv
);
429 for (i
= IDEAPAD_DEV_WLAN
; i
< IDEAPAD_DEV_KILLSW
; i
++) {
430 if (test_bit(ideapad_rfk_data
[i
].cfgbit
, (unsigned long *)&cfg
))
431 ideapad_register_rfkill(adevice
, i
);
433 ideapad_sync_rfk_state(adevice
);
438 ideapad_platform_exit(priv
);
444 static int __devexit
ideapad_acpi_remove(struct acpi_device
*adevice
, int type
)
446 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
449 for (i
= IDEAPAD_DEV_WLAN
; i
< IDEAPAD_DEV_KILLSW
; i
++)
450 ideapad_unregister_rfkill(adevice
, i
);
451 ideapad_input_exit(priv
);
452 ideapad_platform_exit(priv
);
453 dev_set_drvdata(&adevice
->dev
, NULL
);
459 static void ideapad_acpi_notify(struct acpi_device
*adevice
, u32 event
)
461 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
462 acpi_handle handle
= adevice
->handle
;
463 unsigned long vpc1
, vpc2
, vpc_bit
;
465 if (read_ec_data(handle
, 0x10, &vpc1
))
467 if (read_ec_data(handle
, 0x1A, &vpc2
))
470 vpc1
= (vpc2
<< 8) | vpc1
;
471 for (vpc_bit
= 0; vpc_bit
< 16; vpc_bit
++) {
472 if (test_bit(vpc_bit
, &vpc1
)) {
474 ideapad_sync_rfk_state(adevice
);
476 ideapad_input_report(priv
, vpc_bit
);
481 static struct acpi_driver ideapad_acpi_driver
= {
482 .name
= "ideapad_acpi",
484 .ids
= ideapad_device_ids
,
485 .ops
.add
= ideapad_acpi_add
,
486 .ops
.remove
= ideapad_acpi_remove
,
487 .ops
.notify
= ideapad_acpi_notify
,
488 .owner
= THIS_MODULE
,
491 static int __init
ideapad_acpi_module_init(void)
493 return acpi_bus_register_driver(&ideapad_acpi_driver
);
496 static void __exit
ideapad_acpi_module_exit(void)
498 acpi_bus_unregister_driver(&ideapad_acpi_driver
);
501 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
502 MODULE_DESCRIPTION("IdeaPad ACPI Extras");
503 MODULE_LICENSE("GPL");
505 module_init(ideapad_acpi_module_init
);
506 module_exit(ideapad_acpi_module_exit
);