ideapad: fix software rfkill setting
[pandora-kernel.git] / drivers / platform / x86 / ideapad-laptop.c
1 /*
2  *  ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
3  *
4  *  Copyright © 2010 Intel Corporation
5  *  Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
6  *
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.
11  *
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.
16  *
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
20  *  02110-1301, USA.
21  */
22
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
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>
36 #include <linux/fb.h>
37 #include <linux/debugfs.h>
38 #include <linux/seq_file.h>
39
40 #define IDEAPAD_RFKILL_DEV_NUM  (3)
41
42 #define CFG_BT_BIT      (16)
43 #define CFG_3G_BIT      (17)
44 #define CFG_WIFI_BIT    (18)
45 #define CFG_CAMERA_BIT  (19)
46
47 enum {
48         VPCCMD_R_VPC1 = 0x10,
49         VPCCMD_R_BL_MAX,
50         VPCCMD_R_BL,
51         VPCCMD_W_BL,
52         VPCCMD_R_WIFI,
53         VPCCMD_W_WIFI,
54         VPCCMD_R_BT,
55         VPCCMD_W_BT,
56         VPCCMD_R_BL_POWER,
57         VPCCMD_R_NOVO,
58         VPCCMD_R_VPC2,
59         VPCCMD_R_TOUCHPAD,
60         VPCCMD_W_TOUCHPAD,
61         VPCCMD_R_CAMERA,
62         VPCCMD_W_CAMERA,
63         VPCCMD_R_3G,
64         VPCCMD_W_3G,
65         VPCCMD_R_ODD, /* 0x21 */
66         VPCCMD_R_RF = 0x23,
67         VPCCMD_W_RF,
68         VPCCMD_W_BL_POWER = 0x33,
69 };
70
71 struct ideapad_private {
72         struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
73         struct platform_device *platform_device;
74         struct input_dev *inputdev;
75         struct backlight_device *blightdev;
76         struct dentry *debug;
77         unsigned long cfg;
78 };
79
80 static acpi_handle ideapad_handle;
81 static struct ideapad_private *ideapad_priv;
82 static bool no_bt_rfkill;
83 module_param(no_bt_rfkill, bool, 0444);
84 MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");
85
86 /*
87  * ACPI Helpers
88  */
89 #define IDEAPAD_EC_TIMEOUT (100) /* in ms */
90
91 static int read_method_int(acpi_handle handle, const char *method, int *val)
92 {
93         acpi_status status;
94         unsigned long long result;
95
96         status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
97         if (ACPI_FAILURE(status)) {
98                 *val = -1;
99                 return -1;
100         } else {
101                 *val = result;
102                 return 0;
103         }
104 }
105
106 static int method_vpcr(acpi_handle handle, int cmd, int *ret)
107 {
108         acpi_status status;
109         unsigned long long result;
110         struct acpi_object_list params;
111         union acpi_object in_obj;
112
113         params.count = 1;
114         params.pointer = &in_obj;
115         in_obj.type = ACPI_TYPE_INTEGER;
116         in_obj.integer.value = cmd;
117
118         status = acpi_evaluate_integer(handle, "VPCR", &params, &result);
119
120         if (ACPI_FAILURE(status)) {
121                 *ret = -1;
122                 return -1;
123         } else {
124                 *ret = result;
125                 return 0;
126         }
127 }
128
129 static int method_vpcw(acpi_handle handle, int cmd, int data)
130 {
131         struct acpi_object_list params;
132         union acpi_object in_obj[2];
133         acpi_status status;
134
135         params.count = 2;
136         params.pointer = in_obj;
137         in_obj[0].type = ACPI_TYPE_INTEGER;
138         in_obj[0].integer.value = cmd;
139         in_obj[1].type = ACPI_TYPE_INTEGER;
140         in_obj[1].integer.value = data;
141
142         status = acpi_evaluate_object(handle, "VPCW", &params, NULL);
143         if (status != AE_OK)
144                 return -1;
145         return 0;
146 }
147
148 static int read_ec_data(acpi_handle handle, int cmd, unsigned long *data)
149 {
150         int val;
151         unsigned long int end_jiffies;
152
153         if (method_vpcw(handle, 1, cmd))
154                 return -1;
155
156         for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
157              time_before(jiffies, end_jiffies);) {
158                 schedule();
159                 if (method_vpcr(handle, 1, &val))
160                         return -1;
161                 if (val == 0) {
162                         if (method_vpcr(handle, 0, &val))
163                                 return -1;
164                         *data = val;
165                         return 0;
166                 }
167         }
168         pr_err("timeout in read_ec_cmd\n");
169         return -1;
170 }
171
172 static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
173 {
174         int val;
175         unsigned long int end_jiffies;
176
177         if (method_vpcw(handle, 0, data))
178                 return -1;
179         if (method_vpcw(handle, 1, cmd))
180                 return -1;
181
182         for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
183              time_before(jiffies, end_jiffies);) {
184                 schedule();
185                 if (method_vpcr(handle, 1, &val))
186                         return -1;
187                 if (val == 0)
188                         return 0;
189         }
190         pr_err("timeout in write_ec_cmd\n");
191         return -1;
192 }
193
194 /*
195  * debugfs
196  */
197 #define DEBUGFS_EVENT_LEN (4096)
198 static int debugfs_status_show(struct seq_file *s, void *data)
199 {
200         unsigned long value;
201
202         if (!read_ec_data(ideapad_handle, VPCCMD_R_BL_MAX, &value))
203                 seq_printf(s, "Backlight max:\t%lu\n", value);
204         if (!read_ec_data(ideapad_handle, VPCCMD_R_BL, &value))
205                 seq_printf(s, "Backlight now:\t%lu\n", value);
206         if (!read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &value))
207                 seq_printf(s, "BL power value:\t%s\n", value ? "On" : "Off");
208         seq_printf(s, "=====================\n");
209
210         if (!read_ec_data(ideapad_handle, VPCCMD_R_RF, &value))
211                 seq_printf(s, "Radio status:\t%s(%lu)\n",
212                            value ? "On" : "Off", value);
213         if (!read_ec_data(ideapad_handle, VPCCMD_R_WIFI, &value))
214                 seq_printf(s, "Wifi status:\t%s(%lu)\n",
215                            value ? "On" : "Off", value);
216         if (!read_ec_data(ideapad_handle, VPCCMD_R_BT, &value))
217                 seq_printf(s, "BT status:\t%s(%lu)\n",
218                            value ? "On" : "Off", value);
219         if (!read_ec_data(ideapad_handle, VPCCMD_R_3G, &value))
220                 seq_printf(s, "3G status:\t%s(%lu)\n",
221                            value ? "On" : "Off", value);
222         seq_printf(s, "=====================\n");
223
224         if (!read_ec_data(ideapad_handle, VPCCMD_R_TOUCHPAD, &value))
225                 seq_printf(s, "Touchpad status:%s(%lu)\n",
226                            value ? "On" : "Off", value);
227         if (!read_ec_data(ideapad_handle, VPCCMD_R_CAMERA, &value))
228                 seq_printf(s, "Camera status:\t%s(%lu)\n",
229                            value ? "On" : "Off", value);
230
231         return 0;
232 }
233
234 static int debugfs_status_open(struct inode *inode, struct file *file)
235 {
236         return single_open(file, debugfs_status_show, NULL);
237 }
238
239 static const struct file_operations debugfs_status_fops = {
240         .owner = THIS_MODULE,
241         .open = debugfs_status_open,
242         .read = seq_read,
243         .llseek = seq_lseek,
244         .release = single_release,
245 };
246
247 static int debugfs_cfg_show(struct seq_file *s, void *data)
248 {
249         if (!ideapad_priv) {
250                 seq_printf(s, "cfg: N/A\n");
251         } else {
252                 seq_printf(s, "cfg: 0x%.8lX\n\nCapability: ",
253                            ideapad_priv->cfg);
254                 if (test_bit(CFG_BT_BIT, &ideapad_priv->cfg))
255                         seq_printf(s, "Bluetooth ");
256                 if (test_bit(CFG_3G_BIT, &ideapad_priv->cfg))
257                         seq_printf(s, "3G ");
258                 if (test_bit(CFG_WIFI_BIT, &ideapad_priv->cfg))
259                         seq_printf(s, "Wireless ");
260                 if (test_bit(CFG_CAMERA_BIT, &ideapad_priv->cfg))
261                         seq_printf(s, "Camera ");
262                 seq_printf(s, "\nGraphic: ");
263                 switch ((ideapad_priv->cfg)&0x700) {
264                 case 0x100:
265                         seq_printf(s, "Intel");
266                         break;
267                 case 0x200:
268                         seq_printf(s, "ATI");
269                         break;
270                 case 0x300:
271                         seq_printf(s, "Nvidia");
272                         break;
273                 case 0x400:
274                         seq_printf(s, "Intel and ATI");
275                         break;
276                 case 0x500:
277                         seq_printf(s, "Intel and Nvidia");
278                         break;
279                 }
280                 seq_printf(s, "\n");
281         }
282         return 0;
283 }
284
285 static int debugfs_cfg_open(struct inode *inode, struct file *file)
286 {
287         return single_open(file, debugfs_cfg_show, NULL);
288 }
289
290 static const struct file_operations debugfs_cfg_fops = {
291         .owner = THIS_MODULE,
292         .open = debugfs_cfg_open,
293         .read = seq_read,
294         .llseek = seq_lseek,
295         .release = single_release,
296 };
297
298 static int __devinit ideapad_debugfs_init(struct ideapad_private *priv)
299 {
300         struct dentry *node;
301
302         priv->debug = debugfs_create_dir("ideapad", NULL);
303         if (priv->debug == NULL) {
304                 pr_err("failed to create debugfs directory");
305                 goto errout;
306         }
307
308         node = debugfs_create_file("cfg", S_IRUGO, priv->debug, NULL,
309                                    &debugfs_cfg_fops);
310         if (!node) {
311                 pr_err("failed to create cfg in debugfs");
312                 goto errout;
313         }
314
315         node = debugfs_create_file("status", S_IRUGO, priv->debug, NULL,
316                                    &debugfs_status_fops);
317         if (!node) {
318                 pr_err("failed to create event in debugfs");
319                 goto errout;
320         }
321
322         return 0;
323
324 errout:
325         return -ENOMEM;
326 }
327
328 static void ideapad_debugfs_exit(struct ideapad_private *priv)
329 {
330         debugfs_remove_recursive(priv->debug);
331         priv->debug = NULL;
332 }
333
334 /*
335  * sysfs
336  */
337 static ssize_t show_ideapad_cam(struct device *dev,
338                                 struct device_attribute *attr,
339                                 char *buf)
340 {
341         unsigned long result;
342
343         if (read_ec_data(ideapad_handle, VPCCMD_R_CAMERA, &result))
344                 return sprintf(buf, "-1\n");
345         return sprintf(buf, "%lu\n", result);
346 }
347
348 static ssize_t store_ideapad_cam(struct device *dev,
349                                  struct device_attribute *attr,
350                                  const char *buf, size_t count)
351 {
352         int ret, state;
353
354         if (!count)
355                 return 0;
356         if (sscanf(buf, "%i", &state) != 1)
357                 return -EINVAL;
358         ret = write_ec_cmd(ideapad_handle, VPCCMD_W_CAMERA, state);
359         if (ret < 0)
360                 return ret;
361         return count;
362 }
363
364 static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
365
366 static struct attribute *ideapad_attributes[] = {
367         &dev_attr_camera_power.attr,
368         NULL
369 };
370
371 static mode_t ideapad_is_visible(struct kobject *kobj,
372                                  struct attribute *attr,
373                                  int idx)
374 {
375         struct device *dev = container_of(kobj, struct device, kobj);
376         struct ideapad_private *priv = dev_get_drvdata(dev);
377         bool supported;
378
379         if (attr == &dev_attr_camera_power.attr)
380                 supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
381         else
382                 supported = true;
383
384         return supported ? attr->mode : 0;
385 }
386
387 static struct attribute_group ideapad_attribute_group = {
388         .is_visible = ideapad_is_visible,
389         .attrs = ideapad_attributes
390 };
391
392 /*
393  * Rfkill
394  */
395 struct ideapad_rfk_data {
396         char *name;
397         int cfgbit;
398         int opcode;
399         int type;
400 };
401
402 const struct ideapad_rfk_data ideapad_rfk_data[] = {
403         { "ideapad_wlan",    CFG_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
404         { "ideapad_bluetooth", CFG_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH },
405         { "ideapad_3g",        CFG_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN },
406 };
407
408 static int ideapad_rfk_set(void *data, bool blocked)
409 {
410         unsigned long dev = (unsigned long)data;
411         int opcode = ideapad_rfk_data[dev].opcode;
412
413         return write_ec_cmd(ideapad_handle, opcode, !blocked);
414 }
415
416 static struct rfkill_ops ideapad_rfk_ops = {
417         .set_block = ideapad_rfk_set,
418 };
419
420 static void ideapad_sync_rfk_state(struct ideapad_private *priv)
421 {
422         unsigned long hw_blocked;
423         int i;
424
425         if (read_ec_data(ideapad_handle, VPCCMD_R_RF, &hw_blocked))
426                 return;
427         hw_blocked = !hw_blocked;
428
429         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
430                 if (priv->rfk[i])
431                         rfkill_set_hw_state(priv->rfk[i], hw_blocked);
432 }
433
434 static int __devinit ideapad_register_rfkill(struct acpi_device *adevice,
435                                              int dev)
436 {
437         struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
438         int ret;
439         unsigned long sw_blocked;
440
441         if (no_bt_rfkill &&
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);
446                 return 0;
447         }
448
449         priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name, &adevice->dev,
450                                       ideapad_rfk_data[dev].type, &ideapad_rfk_ops,
451                                       (void *)(long)dev);
452         if (!priv->rfk[dev])
453                 return -ENOMEM;
454
455         if (read_ec_data(ideapad_handle, ideapad_rfk_data[dev].opcode-1,
456                          &sw_blocked)) {
457                 rfkill_init_sw_state(priv->rfk[dev], 0);
458         } else {
459                 sw_blocked = !sw_blocked;
460                 rfkill_init_sw_state(priv->rfk[dev], sw_blocked);
461         }
462
463         ret = rfkill_register(priv->rfk[dev]);
464         if (ret) {
465                 rfkill_destroy(priv->rfk[dev]);
466                 return ret;
467         }
468         return 0;
469 }
470
471 static void ideapad_unregister_rfkill(struct acpi_device *adevice, int dev)
472 {
473         struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
474
475         if (!priv->rfk[dev])
476                 return;
477
478         rfkill_unregister(priv->rfk[dev]);
479         rfkill_destroy(priv->rfk[dev]);
480 }
481
482 /*
483  * Platform device
484  */
485 static int __devinit ideapad_platform_init(struct ideapad_private *priv)
486 {
487         int result;
488
489         priv->platform_device = platform_device_alloc("ideapad", -1);
490         if (!priv->platform_device)
491                 return -ENOMEM;
492         platform_set_drvdata(priv->platform_device, priv);
493
494         result = platform_device_add(priv->platform_device);
495         if (result)
496                 goto fail_platform_device;
497
498         result = sysfs_create_group(&priv->platform_device->dev.kobj,
499                                     &ideapad_attribute_group);
500         if (result)
501                 goto fail_sysfs;
502         return 0;
503
504 fail_sysfs:
505         platform_device_del(priv->platform_device);
506 fail_platform_device:
507         platform_device_put(priv->platform_device);
508         return result;
509 }
510
511 static void ideapad_platform_exit(struct ideapad_private *priv)
512 {
513         sysfs_remove_group(&priv->platform_device->dev.kobj,
514                            &ideapad_attribute_group);
515         platform_device_unregister(priv->platform_device);
516 }
517
518 /*
519  * input device
520  */
521 static const struct key_entry ideapad_keymap[] = {
522         { KE_KEY, 6,  { KEY_SWITCHVIDEOMODE } },
523         { KE_KEY, 13, { KEY_WLAN } },
524         { KE_KEY, 16, { KEY_PROG1 } },
525         { KE_KEY, 17, { KEY_PROG2 } },
526         { KE_END, 0 },
527 };
528
529 static int __devinit ideapad_input_init(struct ideapad_private *priv)
530 {
531         struct input_dev *inputdev;
532         int error;
533
534         inputdev = input_allocate_device();
535         if (!inputdev) {
536                 pr_info("Unable to allocate input device\n");
537                 return -ENOMEM;
538         }
539
540         inputdev->name = "Ideapad extra buttons";
541         inputdev->phys = "ideapad/input0";
542         inputdev->id.bustype = BUS_HOST;
543         inputdev->dev.parent = &priv->platform_device->dev;
544
545         error = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
546         if (error) {
547                 pr_err("Unable to setup input device keymap\n");
548                 goto err_free_dev;
549         }
550
551         error = input_register_device(inputdev);
552         if (error) {
553                 pr_err("Unable to register input device\n");
554                 goto err_free_keymap;
555         }
556
557         priv->inputdev = inputdev;
558         return 0;
559
560 err_free_keymap:
561         sparse_keymap_free(inputdev);
562 err_free_dev:
563         input_free_device(inputdev);
564         return error;
565 }
566
567 static void ideapad_input_exit(struct ideapad_private *priv)
568 {
569         sparse_keymap_free(priv->inputdev);
570         input_unregister_device(priv->inputdev);
571         priv->inputdev = NULL;
572 }
573
574 static void ideapad_input_report(struct ideapad_private *priv,
575                                  unsigned long scancode)
576 {
577         sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
578 }
579
580 static void ideapad_input_novokey(struct ideapad_private *priv)
581 {
582         unsigned long long_pressed;
583
584         if (read_ec_data(ideapad_handle, VPCCMD_R_NOVO, &long_pressed))
585                 return;
586         if (long_pressed)
587                 ideapad_input_report(priv, 17);
588         else
589                 ideapad_input_report(priv, 16);
590 }
591
592 /*
593  * backlight
594  */
595 static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
596 {
597         unsigned long now;
598
599         if (read_ec_data(ideapad_handle, VPCCMD_R_BL, &now))
600                 return -EIO;
601         return now;
602 }
603
604 static int ideapad_backlight_update_status(struct backlight_device *blightdev)
605 {
606         if (write_ec_cmd(ideapad_handle, VPCCMD_W_BL,
607                          blightdev->props.brightness))
608                 return -EIO;
609         if (write_ec_cmd(ideapad_handle, VPCCMD_W_BL_POWER,
610                          blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
611                 return -EIO;
612
613         return 0;
614 }
615
616 static const struct backlight_ops ideapad_backlight_ops = {
617         .get_brightness = ideapad_backlight_get_brightness,
618         .update_status = ideapad_backlight_update_status,
619 };
620
621 static int ideapad_backlight_init(struct ideapad_private *priv)
622 {
623         struct backlight_device *blightdev;
624         struct backlight_properties props;
625         unsigned long max, now, power;
626
627         if (read_ec_data(ideapad_handle, VPCCMD_R_BL_MAX, &max))
628                 return -EIO;
629         if (read_ec_data(ideapad_handle, VPCCMD_R_BL, &now))
630                 return -EIO;
631         if (read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &power))
632                 return -EIO;
633
634         memset(&props, 0, sizeof(struct backlight_properties));
635         props.max_brightness = max;
636         props.type = BACKLIGHT_PLATFORM;
637         blightdev = backlight_device_register("ideapad",
638                                               &priv->platform_device->dev,
639                                               priv,
640                                               &ideapad_backlight_ops,
641                                               &props);
642         if (IS_ERR(blightdev)) {
643                 pr_err("Could not register backlight device\n");
644                 return PTR_ERR(blightdev);
645         }
646
647         priv->blightdev = blightdev;
648         blightdev->props.brightness = now;
649         blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
650         backlight_update_status(blightdev);
651
652         return 0;
653 }
654
655 static void ideapad_backlight_exit(struct ideapad_private *priv)
656 {
657         if (priv->blightdev)
658                 backlight_device_unregister(priv->blightdev);
659         priv->blightdev = NULL;
660 }
661
662 static void ideapad_backlight_notify_power(struct ideapad_private *priv)
663 {
664         unsigned long power;
665         struct backlight_device *blightdev = priv->blightdev;
666
667         if (!blightdev)
668                 return;
669         if (read_ec_data(ideapad_handle, VPCCMD_R_BL_POWER, &power))
670                 return;
671         blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
672 }
673
674 static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
675 {
676         unsigned long now;
677
678         /* if we control brightness via acpi video driver */
679         if (priv->blightdev == NULL) {
680                 read_ec_data(ideapad_handle, VPCCMD_R_BL, &now);
681                 return;
682         }
683
684         backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
685 }
686
687 /*
688  * module init/exit
689  */
690 static const struct acpi_device_id ideapad_device_ids[] = {
691         { "VPC2004", 0},
692         { "", 0},
693 };
694 MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
695
696 static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
697 {
698         int ret, i;
699         unsigned long cfg;
700         struct ideapad_private *priv;
701
702         if (read_method_int(adevice->handle, "_CFG", (int *)&cfg))
703                 return -ENODEV;
704
705         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
706         if (!priv)
707                 return -ENOMEM;
708         dev_set_drvdata(&adevice->dev, priv);
709         ideapad_priv = priv;
710         ideapad_handle = adevice->handle;
711         priv->cfg = cfg;
712
713         ret = ideapad_platform_init(priv);
714         if (ret)
715                 goto platform_failed;
716
717         ret = ideapad_debugfs_init(priv);
718         if (ret)
719                 goto debugfs_failed;
720
721         ret = ideapad_input_init(priv);
722         if (ret)
723                 goto input_failed;
724
725         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) {
726                 if (test_bit(ideapad_rfk_data[i].cfgbit, &cfg))
727                         ideapad_register_rfkill(adevice, i);
728                 else
729                         priv->rfk[i] = NULL;
730         }
731         ideapad_sync_rfk_state(priv);
732
733         if (!acpi_video_backlight_support()) {
734                 ret = ideapad_backlight_init(priv);
735                 if (ret && ret != -ENODEV)
736                         goto backlight_failed;
737         }
738
739         return 0;
740
741 backlight_failed:
742         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
743                 ideapad_unregister_rfkill(adevice, i);
744         ideapad_input_exit(priv);
745 input_failed:
746         ideapad_debugfs_exit(priv);
747 debugfs_failed:
748         ideapad_platform_exit(priv);
749 platform_failed:
750         kfree(priv);
751         return ret;
752 }
753
754 static int __devexit ideapad_acpi_remove(struct acpi_device *adevice, int type)
755 {
756         struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
757         int i;
758
759         ideapad_backlight_exit(priv);
760         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
761                 ideapad_unregister_rfkill(adevice, i);
762         ideapad_input_exit(priv);
763         ideapad_debugfs_exit(priv);
764         ideapad_platform_exit(priv);
765         dev_set_drvdata(&adevice->dev, NULL);
766         kfree(priv);
767
768         return 0;
769 }
770
771 static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
772 {
773         struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
774         acpi_handle handle = adevice->handle;
775         unsigned long vpc1, vpc2, vpc_bit;
776
777         if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
778                 return;
779         if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
780                 return;
781
782         vpc1 = (vpc2 << 8) | vpc1;
783         for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
784                 if (test_bit(vpc_bit, &vpc1)) {
785                         switch (vpc_bit) {
786                         case 9:
787                                 ideapad_sync_rfk_state(priv);
788                                 break;
789                         case 4:
790                                 ideapad_backlight_notify_brightness(priv);
791                                 break;
792                         case 3:
793                                 ideapad_input_novokey(priv);
794                                 break;
795                         case 2:
796                                 ideapad_backlight_notify_power(priv);
797                                 break;
798                         default:
799                                 ideapad_input_report(priv, vpc_bit);
800                         }
801                 }
802         }
803 }
804
805 static struct acpi_driver ideapad_acpi_driver = {
806         .name = "ideapad_acpi",
807         .class = "IdeaPad",
808         .ids = ideapad_device_ids,
809         .ops.add = ideapad_acpi_add,
810         .ops.remove = ideapad_acpi_remove,
811         .ops.notify = ideapad_acpi_notify,
812         .owner = THIS_MODULE,
813 };
814
815 static int __init ideapad_acpi_module_init(void)
816 {
817         return acpi_bus_register_driver(&ideapad_acpi_driver);
818 }
819
820 static void __exit ideapad_acpi_module_exit(void)
821 {
822         acpi_bus_unregister_driver(&ideapad_acpi_driver);
823 }
824
825 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
826 MODULE_DESCRIPTION("IdeaPad ACPI Extras");
827 MODULE_LICENSE("GPL");
828
829 module_init(ideapad_acpi_module_init);
830 module_exit(ideapad_acpi_module_exit);