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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/types.h>
29 #include <acpi/acpi_bus.h>
30 #include <acpi/acpi_drivers.h>
31 #include <linux/rfkill.h>
32 #include <linux/platform_device.h>
33 #include <linux/input.h>
34 #include <linux/input/sparse-keymap.h>
35 #include <linux/backlight.h>
37 #include <linux/debugfs.h>
38 #include <linux/seq_file.h>
39 #include <linux/i8042.h>
41 #define IDEAPAD_RFKILL_DEV_NUM (3)
43 #define CFG_BT_BIT (16)
44 #define CFG_3G_BIT (17)
45 #define CFG_WIFI_BIT (18)
46 #define CFG_CAMERA_BIT (19)
66 VPCCMD_R_ODD
, /* 0x21 */
69 VPCCMD_R_SPECIAL_BUTTONS
= 0x31,
70 VPCCMD_W_BL_POWER
= 0x33,
73 struct ideapad_private
{
74 struct rfkill
*rfk
[IDEAPAD_RFKILL_DEV_NUM
];
75 struct platform_device
*platform_device
;
76 struct input_dev
*inputdev
;
77 struct backlight_device
*blightdev
;
82 static acpi_handle ideapad_handle
;
83 static struct ideapad_private
*ideapad_priv
;
84 static bool no_bt_rfkill
;
85 module_param(no_bt_rfkill
, bool, 0444);
86 MODULE_PARM_DESC(no_bt_rfkill
, "No rfkill for bluetooth.");
91 #define IDEAPAD_EC_TIMEOUT (100) /* in ms */
93 static int read_method_int(acpi_handle handle
, const char *method
, int *val
)
96 unsigned long long result
;
98 status
= acpi_evaluate_integer(handle
, (char *)method
, NULL
, &result
);
99 if (ACPI_FAILURE(status
)) {
108 static int method_vpcr(acpi_handle handle
, int cmd
, int *ret
)
111 unsigned long long result
;
112 struct acpi_object_list params
;
113 union acpi_object in_obj
;
116 params
.pointer
= &in_obj
;
117 in_obj
.type
= ACPI_TYPE_INTEGER
;
118 in_obj
.integer
.value
= cmd
;
120 status
= acpi_evaluate_integer(handle
, "VPCR", ¶ms
, &result
);
122 if (ACPI_FAILURE(status
)) {
131 static int method_vpcw(acpi_handle handle
, int cmd
, int data
)
133 struct acpi_object_list params
;
134 union acpi_object in_obj
[2];
138 params
.pointer
= in_obj
;
139 in_obj
[0].type
= ACPI_TYPE_INTEGER
;
140 in_obj
[0].integer
.value
= cmd
;
141 in_obj
[1].type
= ACPI_TYPE_INTEGER
;
142 in_obj
[1].integer
.value
= data
;
144 status
= acpi_evaluate_object(handle
, "VPCW", ¶ms
, NULL
);
150 static int read_ec_data(acpi_handle handle
, int cmd
, unsigned long *data
)
153 unsigned long int end_jiffies
;
155 if (method_vpcw(handle
, 1, cmd
))
158 for (end_jiffies
= jiffies
+(HZ
)*IDEAPAD_EC_TIMEOUT
/1000+1;
159 time_before(jiffies
, end_jiffies
);) {
161 if (method_vpcr(handle
, 1, &val
))
164 if (method_vpcr(handle
, 0, &val
))
170 pr_err("timeout in read_ec_cmd\n");
174 static int write_ec_cmd(acpi_handle handle
, int cmd
, unsigned long data
)
177 unsigned long int end_jiffies
;
179 if (method_vpcw(handle
, 0, data
))
181 if (method_vpcw(handle
, 1, cmd
))
184 for (end_jiffies
= jiffies
+(HZ
)*IDEAPAD_EC_TIMEOUT
/1000+1;
185 time_before(jiffies
, end_jiffies
);) {
187 if (method_vpcr(handle
, 1, &val
))
192 pr_err("timeout in write_ec_cmd\n");
199 static int debugfs_status_show(struct seq_file
*s
, void *data
)
203 if (!read_ec_data(ideapad_handle
, VPCCMD_R_BL_MAX
, &value
))
204 seq_printf(s
, "Backlight max:\t%lu\n", value
);
205 if (!read_ec_data(ideapad_handle
, VPCCMD_R_BL
, &value
))
206 seq_printf(s
, "Backlight now:\t%lu\n", value
);
207 if (!read_ec_data(ideapad_handle
, VPCCMD_R_BL_POWER
, &value
))
208 seq_printf(s
, "BL power value:\t%s\n", value
? "On" : "Off");
209 seq_printf(s
, "=====================\n");
211 if (!read_ec_data(ideapad_handle
, VPCCMD_R_RF
, &value
))
212 seq_printf(s
, "Radio status:\t%s(%lu)\n",
213 value
? "On" : "Off", value
);
214 if (!read_ec_data(ideapad_handle
, VPCCMD_R_WIFI
, &value
))
215 seq_printf(s
, "Wifi status:\t%s(%lu)\n",
216 value
? "On" : "Off", value
);
217 if (!read_ec_data(ideapad_handle
, VPCCMD_R_BT
, &value
))
218 seq_printf(s
, "BT status:\t%s(%lu)\n",
219 value
? "On" : "Off", value
);
220 if (!read_ec_data(ideapad_handle
, VPCCMD_R_3G
, &value
))
221 seq_printf(s
, "3G status:\t%s(%lu)\n",
222 value
? "On" : "Off", value
);
223 seq_printf(s
, "=====================\n");
225 if (!read_ec_data(ideapad_handle
, VPCCMD_R_TOUCHPAD
, &value
))
226 seq_printf(s
, "Touchpad status:%s(%lu)\n",
227 value
? "On" : "Off", value
);
228 if (!read_ec_data(ideapad_handle
, VPCCMD_R_CAMERA
, &value
))
229 seq_printf(s
, "Camera status:\t%s(%lu)\n",
230 value
? "On" : "Off", value
);
235 static int debugfs_status_open(struct inode
*inode
, struct file
*file
)
237 return single_open(file
, debugfs_status_show
, NULL
);
240 static const struct file_operations debugfs_status_fops
= {
241 .owner
= THIS_MODULE
,
242 .open
= debugfs_status_open
,
245 .release
= single_release
,
248 static int debugfs_cfg_show(struct seq_file
*s
, void *data
)
251 seq_printf(s
, "cfg: N/A\n");
253 seq_printf(s
, "cfg: 0x%.8lX\n\nCapability: ",
255 if (test_bit(CFG_BT_BIT
, &ideapad_priv
->cfg
))
256 seq_printf(s
, "Bluetooth ");
257 if (test_bit(CFG_3G_BIT
, &ideapad_priv
->cfg
))
258 seq_printf(s
, "3G ");
259 if (test_bit(CFG_WIFI_BIT
, &ideapad_priv
->cfg
))
260 seq_printf(s
, "Wireless ");
261 if (test_bit(CFG_CAMERA_BIT
, &ideapad_priv
->cfg
))
262 seq_printf(s
, "Camera ");
263 seq_printf(s
, "\nGraphic: ");
264 switch ((ideapad_priv
->cfg
)&0x700) {
266 seq_printf(s
, "Intel");
269 seq_printf(s
, "ATI");
272 seq_printf(s
, "Nvidia");
275 seq_printf(s
, "Intel and ATI");
278 seq_printf(s
, "Intel and Nvidia");
286 static int debugfs_cfg_open(struct inode
*inode
, struct file
*file
)
288 return single_open(file
, debugfs_cfg_show
, NULL
);
291 static const struct file_operations debugfs_cfg_fops
= {
292 .owner
= THIS_MODULE
,
293 .open
= debugfs_cfg_open
,
296 .release
= single_release
,
299 static int __devinit
ideapad_debugfs_init(struct ideapad_private
*priv
)
303 priv
->debug
= debugfs_create_dir("ideapad", NULL
);
304 if (priv
->debug
== NULL
) {
305 pr_err("failed to create debugfs directory");
309 node
= debugfs_create_file("cfg", S_IRUGO
, priv
->debug
, NULL
,
312 pr_err("failed to create cfg in debugfs");
316 node
= debugfs_create_file("status", S_IRUGO
, priv
->debug
, NULL
,
317 &debugfs_status_fops
);
319 pr_err("failed to create status in debugfs");
329 static void ideapad_debugfs_exit(struct ideapad_private
*priv
)
331 debugfs_remove_recursive(priv
->debug
);
338 static ssize_t
show_ideapad_cam(struct device
*dev
,
339 struct device_attribute
*attr
,
342 unsigned long result
;
344 if (read_ec_data(ideapad_handle
, VPCCMD_R_CAMERA
, &result
))
345 return sprintf(buf
, "-1\n");
346 return sprintf(buf
, "%lu\n", result
);
349 static ssize_t
store_ideapad_cam(struct device
*dev
,
350 struct device_attribute
*attr
,
351 const char *buf
, size_t count
)
357 if (sscanf(buf
, "%i", &state
) != 1)
359 ret
= write_ec_cmd(ideapad_handle
, VPCCMD_W_CAMERA
, state
);
365 static DEVICE_ATTR(camera_power
, 0644, show_ideapad_cam
, store_ideapad_cam
);
367 static struct attribute
*ideapad_attributes
[] = {
368 &dev_attr_camera_power
.attr
,
372 static umode_t
ideapad_is_visible(struct kobject
*kobj
,
373 struct attribute
*attr
,
376 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
377 struct ideapad_private
*priv
= dev_get_drvdata(dev
);
380 if (attr
== &dev_attr_camera_power
.attr
)
381 supported
= test_bit(CFG_CAMERA_BIT
, &(priv
->cfg
));
385 return supported
? attr
->mode
: 0;
388 static struct attribute_group ideapad_attribute_group
= {
389 .is_visible
= ideapad_is_visible
,
390 .attrs
= ideapad_attributes
396 struct ideapad_rfk_data
{
403 const struct ideapad_rfk_data ideapad_rfk_data
[] = {
404 { "ideapad_wlan", CFG_WIFI_BIT
, VPCCMD_W_WIFI
, RFKILL_TYPE_WLAN
},
405 { "ideapad_bluetooth", CFG_BT_BIT
, VPCCMD_W_BT
, RFKILL_TYPE_BLUETOOTH
},
406 { "ideapad_3g", CFG_3G_BIT
, VPCCMD_W_3G
, RFKILL_TYPE_WWAN
},
409 static int ideapad_rfk_set(void *data
, bool blocked
)
411 unsigned long opcode
= (unsigned long)data
;
413 return write_ec_cmd(ideapad_handle
, opcode
, !blocked
);
416 static struct rfkill_ops ideapad_rfk_ops
= {
417 .set_block
= ideapad_rfk_set
,
420 static void ideapad_sync_rfk_state(struct ideapad_private
*priv
)
422 unsigned long hw_blocked
;
425 if (read_ec_data(ideapad_handle
, VPCCMD_R_RF
, &hw_blocked
))
427 hw_blocked
= !hw_blocked
;
429 for (i
= 0; i
< IDEAPAD_RFKILL_DEV_NUM
; i
++)
431 rfkill_set_hw_state(priv
->rfk
[i
], hw_blocked
);
434 static int __devinit
ideapad_register_rfkill(struct acpi_device
*adevice
,
437 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
439 unsigned long sw_blocked
;
442 (ideapad_rfk_data
[dev
].type
== RFKILL_TYPE_BLUETOOTH
)) {
443 /* Force to enable bluetooth when no_bt_rfkill=1 */
444 write_ec_cmd(ideapad_handle
,
445 ideapad_rfk_data
[dev
].opcode
, 1);
449 priv
->rfk
[dev
] = rfkill_alloc(ideapad_rfk_data
[dev
].name
, &adevice
->dev
,
450 ideapad_rfk_data
[dev
].type
, &ideapad_rfk_ops
,
455 if (read_ec_data(ideapad_handle
, ideapad_rfk_data
[dev
].opcode
-1,
457 rfkill_init_sw_state(priv
->rfk
[dev
], 0);
459 sw_blocked
= !sw_blocked
;
460 rfkill_init_sw_state(priv
->rfk
[dev
], sw_blocked
);
463 ret
= rfkill_register(priv
->rfk
[dev
]);
465 rfkill_destroy(priv
->rfk
[dev
]);
471 static void ideapad_unregister_rfkill(struct acpi_device
*adevice
, int dev
)
473 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
478 rfkill_unregister(priv
->rfk
[dev
]);
479 rfkill_destroy(priv
->rfk
[dev
]);
485 static int __devinit
ideapad_platform_init(struct ideapad_private
*priv
)
489 priv
->platform_device
= platform_device_alloc("ideapad", -1);
490 if (!priv
->platform_device
)
492 platform_set_drvdata(priv
->platform_device
, priv
);
494 result
= platform_device_add(priv
->platform_device
);
496 goto fail_platform_device
;
498 result
= sysfs_create_group(&priv
->platform_device
->dev
.kobj
,
499 &ideapad_attribute_group
);
505 platform_device_del(priv
->platform_device
);
506 fail_platform_device
:
507 platform_device_put(priv
->platform_device
);
511 static void ideapad_platform_exit(struct ideapad_private
*priv
)
513 sysfs_remove_group(&priv
->platform_device
->dev
.kobj
,
514 &ideapad_attribute_group
);
515 platform_device_unregister(priv
->platform_device
);
521 static const struct key_entry ideapad_keymap
[] = {
522 { KE_KEY
, 6, { KEY_SWITCHVIDEOMODE
} },
523 { KE_KEY
, 7, { KEY_CAMERA
} },
524 { KE_KEY
, 11, { KEY_F16
} },
525 { KE_KEY
, 13, { KEY_WLAN
} },
526 { KE_KEY
, 16, { KEY_PROG1
} },
527 { KE_KEY
, 17, { KEY_PROG2
} },
528 { KE_KEY
, 64, { KEY_PROG3
} },
529 { KE_KEY
, 65, { KEY_PROG4
} },
530 { KE_KEY
, 66, { KEY_TOUCHPAD_OFF
} },
531 { KE_KEY
, 67, { KEY_TOUCHPAD_ON
} },
535 static int __devinit
ideapad_input_init(struct ideapad_private
*priv
)
537 struct input_dev
*inputdev
;
540 inputdev
= input_allocate_device();
542 pr_info("Unable to allocate input device\n");
546 inputdev
->name
= "Ideapad extra buttons";
547 inputdev
->phys
= "ideapad/input0";
548 inputdev
->id
.bustype
= BUS_HOST
;
549 inputdev
->dev
.parent
= &priv
->platform_device
->dev
;
551 error
= sparse_keymap_setup(inputdev
, ideapad_keymap
, NULL
);
553 pr_err("Unable to setup input device keymap\n");
557 error
= input_register_device(inputdev
);
559 pr_err("Unable to register input device\n");
560 goto err_free_keymap
;
563 priv
->inputdev
= inputdev
;
567 sparse_keymap_free(inputdev
);
569 input_free_device(inputdev
);
573 static void ideapad_input_exit(struct ideapad_private
*priv
)
575 sparse_keymap_free(priv
->inputdev
);
576 input_unregister_device(priv
->inputdev
);
577 priv
->inputdev
= NULL
;
580 static void ideapad_input_report(struct ideapad_private
*priv
,
581 unsigned long scancode
)
583 sparse_keymap_report_event(priv
->inputdev
, scancode
, 1, true);
586 static void ideapad_input_novokey(struct ideapad_private
*priv
)
588 unsigned long long_pressed
;
590 if (read_ec_data(ideapad_handle
, VPCCMD_R_NOVO
, &long_pressed
))
593 ideapad_input_report(priv
, 17);
595 ideapad_input_report(priv
, 16);
598 static void ideapad_check_special_buttons(struct ideapad_private
*priv
)
600 unsigned long bit
, value
;
602 read_ec_data(ideapad_handle
, VPCCMD_R_SPECIAL_BUTTONS
, &value
);
604 for (bit
= 0; bit
< 16; bit
++) {
605 if (test_bit(bit
, &value
)) {
608 /* Thermal Management button */
609 ideapad_input_report(priv
, 65);
612 /* OneKey Theater button */
613 ideapad_input_report(priv
, 64);
623 static int ideapad_backlight_get_brightness(struct backlight_device
*blightdev
)
627 if (read_ec_data(ideapad_handle
, VPCCMD_R_BL
, &now
))
632 static int ideapad_backlight_update_status(struct backlight_device
*blightdev
)
634 if (write_ec_cmd(ideapad_handle
, VPCCMD_W_BL
,
635 blightdev
->props
.brightness
))
637 if (write_ec_cmd(ideapad_handle
, VPCCMD_W_BL_POWER
,
638 blightdev
->props
.power
== FB_BLANK_POWERDOWN
? 0 : 1))
644 static const struct backlight_ops ideapad_backlight_ops
= {
645 .get_brightness
= ideapad_backlight_get_brightness
,
646 .update_status
= ideapad_backlight_update_status
,
649 static int ideapad_backlight_init(struct ideapad_private
*priv
)
651 struct backlight_device
*blightdev
;
652 struct backlight_properties props
;
653 unsigned long max
, now
, power
;
655 if (read_ec_data(ideapad_handle
, VPCCMD_R_BL_MAX
, &max
))
657 if (read_ec_data(ideapad_handle
, VPCCMD_R_BL
, &now
))
659 if (read_ec_data(ideapad_handle
, VPCCMD_R_BL_POWER
, &power
))
662 memset(&props
, 0, sizeof(struct backlight_properties
));
663 props
.max_brightness
= max
;
664 props
.type
= BACKLIGHT_PLATFORM
;
665 blightdev
= backlight_device_register("ideapad",
666 &priv
->platform_device
->dev
,
668 &ideapad_backlight_ops
,
670 if (IS_ERR(blightdev
)) {
671 pr_err("Could not register backlight device\n");
672 return PTR_ERR(blightdev
);
675 priv
->blightdev
= blightdev
;
676 blightdev
->props
.brightness
= now
;
677 blightdev
->props
.power
= power
? FB_BLANK_UNBLANK
: FB_BLANK_POWERDOWN
;
678 backlight_update_status(blightdev
);
683 static void ideapad_backlight_exit(struct ideapad_private
*priv
)
686 backlight_device_unregister(priv
->blightdev
);
687 priv
->blightdev
= NULL
;
690 static void ideapad_backlight_notify_power(struct ideapad_private
*priv
)
693 struct backlight_device
*blightdev
= priv
->blightdev
;
697 if (read_ec_data(ideapad_handle
, VPCCMD_R_BL_POWER
, &power
))
699 blightdev
->props
.power
= power
? FB_BLANK_UNBLANK
: FB_BLANK_POWERDOWN
;
702 static void ideapad_backlight_notify_brightness(struct ideapad_private
*priv
)
706 /* if we control brightness via acpi video driver */
707 if (priv
->blightdev
== NULL
) {
708 read_ec_data(ideapad_handle
, VPCCMD_R_BL
, &now
);
712 backlight_force_update(priv
->blightdev
, BACKLIGHT_UPDATE_HOTKEY
);
718 static const struct acpi_device_id ideapad_device_ids
[] = {
722 MODULE_DEVICE_TABLE(acpi
, ideapad_device_ids
);
724 static void ideapad_sync_touchpad_state(struct acpi_device
*adevice
)
726 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
729 /* Without reading from EC touchpad LED doesn't switch state */
730 if (!read_ec_data(adevice
->handle
, VPCCMD_R_TOUCHPAD
, &value
)) {
731 /* Some IdeaPads don't really turn off touchpad - they only
732 * switch the LED state. We (de)activate KBC AUX port to turn
733 * touchpad off and on. We send KEY_TOUCHPAD_OFF and
734 * KEY_TOUCHPAD_ON to not to get out of sync with LED */
736 i8042_command(¶m
, value
? I8042_CMD_AUX_ENABLE
:
737 I8042_CMD_AUX_DISABLE
);
738 ideapad_input_report(priv
, value
? 67 : 66);
742 static int __devinit
ideapad_acpi_add(struct acpi_device
*adevice
)
746 struct ideapad_private
*priv
;
748 if (read_method_int(adevice
->handle
, "_CFG", &cfg
))
751 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
754 dev_set_drvdata(&adevice
->dev
, priv
);
756 ideapad_handle
= adevice
->handle
;
759 ret
= ideapad_platform_init(priv
);
761 goto platform_failed
;
763 ret
= ideapad_debugfs_init(priv
);
767 ret
= ideapad_input_init(priv
);
771 for (i
= 0; i
< IDEAPAD_RFKILL_DEV_NUM
; i
++) {
772 if (test_bit(ideapad_rfk_data
[i
].cfgbit
, &priv
->cfg
))
773 ideapad_register_rfkill(adevice
, i
);
777 ideapad_sync_rfk_state(priv
);
778 ideapad_sync_touchpad_state(adevice
);
780 if (!acpi_video_backlight_support()) {
781 ret
= ideapad_backlight_init(priv
);
782 if (ret
&& ret
!= -ENODEV
)
783 goto backlight_failed
;
789 for (i
= 0; i
< IDEAPAD_RFKILL_DEV_NUM
; i
++)
790 ideapad_unregister_rfkill(adevice
, i
);
791 ideapad_input_exit(priv
);
793 ideapad_debugfs_exit(priv
);
795 ideapad_platform_exit(priv
);
801 static int __devexit
ideapad_acpi_remove(struct acpi_device
*adevice
, int type
)
803 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
806 ideapad_backlight_exit(priv
);
807 for (i
= 0; i
< IDEAPAD_RFKILL_DEV_NUM
; i
++)
808 ideapad_unregister_rfkill(adevice
, i
);
809 ideapad_input_exit(priv
);
810 ideapad_debugfs_exit(priv
);
811 ideapad_platform_exit(priv
);
812 dev_set_drvdata(&adevice
->dev
, NULL
);
818 static void ideapad_acpi_notify(struct acpi_device
*adevice
, u32 event
)
820 struct ideapad_private
*priv
= dev_get_drvdata(&adevice
->dev
);
821 acpi_handle handle
= adevice
->handle
;
822 unsigned long vpc1
, vpc2
, vpc_bit
;
824 if (read_ec_data(handle
, VPCCMD_R_VPC1
, &vpc1
))
826 if (read_ec_data(handle
, VPCCMD_R_VPC2
, &vpc2
))
829 vpc1
= (vpc2
<< 8) | vpc1
;
830 for (vpc_bit
= 0; vpc_bit
< 16; vpc_bit
++) {
831 if (test_bit(vpc_bit
, &vpc1
)) {
834 ideapad_sync_rfk_state(priv
);
840 ideapad_input_report(priv
, vpc_bit
);
843 ideapad_sync_touchpad_state(adevice
);
846 ideapad_backlight_notify_brightness(priv
);
849 ideapad_input_novokey(priv
);
852 ideapad_backlight_notify_power(priv
);
855 ideapad_check_special_buttons(priv
);
858 pr_info("Unknown event: %lu\n", vpc_bit
);
864 static int ideapad_acpi_resume(struct device
*device
)
866 ideapad_sync_rfk_state(ideapad_priv
);
867 ideapad_sync_touchpad_state(to_acpi_device(device
));
871 static SIMPLE_DEV_PM_OPS(ideapad_pm
, NULL
, ideapad_acpi_resume
);
873 static struct acpi_driver ideapad_acpi_driver
= {
874 .name
= "ideapad_acpi",
876 .ids
= ideapad_device_ids
,
877 .ops
.add
= ideapad_acpi_add
,
878 .ops
.remove
= ideapad_acpi_remove
,
879 .ops
.notify
= ideapad_acpi_notify
,
880 .drv
.pm
= &ideapad_pm
,
881 .owner
= THIS_MODULE
,
884 static int __init
ideapad_acpi_module_init(void)
886 return acpi_bus_register_driver(&ideapad_acpi_driver
);
889 static void __exit
ideapad_acpi_module_exit(void)
891 acpi_bus_unregister_driver(&ideapad_acpi_driver
);
894 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
895 MODULE_DESCRIPTION("IdeaPad ACPI Extras");
896 MODULE_LICENSE("GPL");
898 module_init(ideapad_acpi_module_init
);
899 module_exit(ideapad_acpi_module_exit
);