5f1256d5e9332cf45dbdd2031987ea41fe0212cf
[linux-3.10.git] / drivers / platform / x86 / toshiba_acpi.c
1 /*
2  *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
3  *
4  *
5  *  Copyright (C) 2002-2004 John Belmonte
6  *  Copyright (C) 2008 Philip Langdale
7  *  Copyright (C) 2010 Pierre Ducroquet
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
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  *
23  *
24  *  The devolpment page for this driver is located at
25  *  http://memebeam.org/toys/ToshibaAcpiDriver.
26  *
27  *  Credits:
28  *      Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
29  *              engineering the Windows drivers
30  *      Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
31  *      Rob Miller - TV out and hotkeys help
32  *
33  *
34  *  TODO
35  *
36  */
37
38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
39
40 #define TOSHIBA_ACPI_VERSION    "0.19"
41 #define PROC_INTERFACE_VERSION  1
42
43 #include <linux/kernel.h>
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/types.h>
47 #include <linux/proc_fs.h>
48 #include <linux/seq_file.h>
49 #include <linux/backlight.h>
50 #include <linux/rfkill.h>
51 #include <linux/input.h>
52 #include <linux/input/sparse-keymap.h>
53 #include <linux/leds.h>
54 #include <linux/slab.h>
55 #include <linux/workqueue.h>
56 #include <linux/i8042.h>
57
58 #include <asm/uaccess.h>
59
60 #include <acpi/acpi_drivers.h>
61
62 MODULE_AUTHOR("John Belmonte");
63 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
64 MODULE_LICENSE("GPL");
65
66 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
67
68 /* Scan code for Fn key on TOS1900 models */
69 #define TOS1900_FN_SCAN         0x6e
70
71 /* Toshiba ACPI method paths */
72 #define METHOD_VIDEO_OUT        "\\_SB_.VALX.DSSX"
73
74 /* Toshiba HCI interface definitions
75  *
76  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
77  * be uniform across all their models.  Ideally we would just call
78  * dedicated ACPI methods instead of using this primitive interface.
79  * However the ACPI methods seem to be incomplete in some areas (for
80  * example they allow setting, but not reading, the LCD brightness value),
81  * so this is still useful.
82  */
83
84 #define HCI_WORDS                       6
85
86 /* operations */
87 #define HCI_SET                         0xff00
88 #define HCI_GET                         0xfe00
89
90 /* return codes */
91 #define HCI_SUCCESS                     0x0000
92 #define HCI_FAILURE                     0x1000
93 #define HCI_NOT_SUPPORTED               0x8000
94 #define HCI_EMPTY                       0x8c00
95
96 /* registers */
97 #define HCI_FAN                         0x0004
98 #define HCI_TR_BACKLIGHT                0x0005
99 #define HCI_SYSTEM_EVENT                0x0016
100 #define HCI_VIDEO_OUT                   0x001c
101 #define HCI_HOTKEY_EVENT                0x001e
102 #define HCI_LCD_BRIGHTNESS              0x002a
103 #define HCI_WIRELESS                    0x0056
104
105 /* field definitions */
106 #define HCI_HOTKEY_DISABLE              0x0b
107 #define HCI_HOTKEY_ENABLE               0x09
108 #define HCI_LCD_BRIGHTNESS_BITS         3
109 #define HCI_LCD_BRIGHTNESS_SHIFT        (16-HCI_LCD_BRIGHTNESS_BITS)
110 #define HCI_LCD_BRIGHTNESS_LEVELS       (1 << HCI_LCD_BRIGHTNESS_BITS)
111 #define HCI_VIDEO_OUT_LCD               0x1
112 #define HCI_VIDEO_OUT_CRT               0x2
113 #define HCI_VIDEO_OUT_TV                0x4
114 #define HCI_WIRELESS_KILL_SWITCH        0x01
115 #define HCI_WIRELESS_BT_PRESENT         0x0f
116 #define HCI_WIRELESS_BT_ATTACH          0x40
117 #define HCI_WIRELESS_BT_POWER           0x80
118
119 struct toshiba_acpi_dev {
120         struct acpi_device *acpi_dev;
121         const char *method_hci;
122         struct rfkill *bt_rfk;
123         struct input_dev *hotkey_dev;
124         struct work_struct hotkey_work;
125         struct backlight_device *backlight_dev;
126         struct led_classdev led_dev;
127
128         int force_fan;
129         int last_key_event;
130         int key_event_valid;
131
132         unsigned int illumination_supported:1;
133         unsigned int video_supported:1;
134         unsigned int fan_supported:1;
135         unsigned int system_event_supported:1;
136         unsigned int ntfy_supported:1;
137         unsigned int info_supported:1;
138         unsigned int tr_backlight_supported:1;
139
140         struct mutex mutex;
141 };
142
143 static struct toshiba_acpi_dev *toshiba_acpi;
144
145 static const struct acpi_device_id toshiba_device_ids[] = {
146         {"TOS6200", 0},
147         {"TOS6208", 0},
148         {"TOS1900", 0},
149         {"", 0},
150 };
151 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
152
153 static const struct key_entry toshiba_acpi_keymap[] __devinitconst = {
154         { KE_KEY, 0x101, { KEY_MUTE } },
155         { KE_KEY, 0x102, { KEY_ZOOMOUT } },
156         { KE_KEY, 0x103, { KEY_ZOOMIN } },
157         { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
158         { KE_KEY, 0x139, { KEY_ZOOMRESET } },
159         { KE_KEY, 0x13b, { KEY_COFFEE } },
160         { KE_KEY, 0x13c, { KEY_BATTERY } },
161         { KE_KEY, 0x13d, { KEY_SLEEP } },
162         { KE_KEY, 0x13e, { KEY_SUSPEND } },
163         { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
164         { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
165         { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
166         { KE_KEY, 0x142, { KEY_WLAN } },
167         { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } },
168         { KE_KEY, 0x17f, { KEY_FN } },
169         { KE_KEY, 0xb05, { KEY_PROG2 } },
170         { KE_KEY, 0xb06, { KEY_WWW } },
171         { KE_KEY, 0xb07, { KEY_MAIL } },
172         { KE_KEY, 0xb30, { KEY_STOP } },
173         { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
174         { KE_KEY, 0xb32, { KEY_NEXTSONG } },
175         { KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
176         { KE_KEY, 0xb5a, { KEY_MEDIA } },
177         { KE_IGNORE, 0x1430, { KEY_RESERVED } },
178         { KE_END, 0 },
179 };
180
181 /* utility
182  */
183
184 static __inline__ void _set_bit(u32 * word, u32 mask, int value)
185 {
186         *word = (*word & ~mask) | (mask * value);
187 }
188
189 /* acpi interface wrappers
190  */
191
192 static int write_acpi_int(const char *methodName, int val)
193 {
194         struct acpi_object_list params;
195         union acpi_object in_objs[1];
196         acpi_status status;
197
198         params.count = ARRAY_SIZE(in_objs);
199         params.pointer = in_objs;
200         in_objs[0].type = ACPI_TYPE_INTEGER;
201         in_objs[0].integer.value = val;
202
203         status = acpi_evaluate_object(NULL, (char *)methodName, &params, NULL);
204         return (status == AE_OK) ? 0 : -EIO;
205 }
206
207 /* Perform a raw HCI call.  Here we don't care about input or output buffer
208  * format.
209  */
210 static acpi_status hci_raw(struct toshiba_acpi_dev *dev,
211                            const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
212 {
213         struct acpi_object_list params;
214         union acpi_object in_objs[HCI_WORDS];
215         struct acpi_buffer results;
216         union acpi_object out_objs[HCI_WORDS + 1];
217         acpi_status status;
218         int i;
219
220         params.count = HCI_WORDS;
221         params.pointer = in_objs;
222         for (i = 0; i < HCI_WORDS; ++i) {
223                 in_objs[i].type = ACPI_TYPE_INTEGER;
224                 in_objs[i].integer.value = in[i];
225         }
226
227         results.length = sizeof(out_objs);
228         results.pointer = out_objs;
229
230         status = acpi_evaluate_object(dev->acpi_dev->handle,
231                                       (char *)dev->method_hci, &params,
232                                       &results);
233         if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
234                 for (i = 0; i < out_objs->package.count; ++i) {
235                         out[i] = out_objs->package.elements[i].integer.value;
236                 }
237         }
238
239         return status;
240 }
241
242 /* common hci tasks (get or set one or two value)
243  *
244  * In addition to the ACPI status, the HCI system returns a result which
245  * may be useful (such as "not supported").
246  */
247
248 static acpi_status hci_write1(struct toshiba_acpi_dev *dev, u32 reg,
249                               u32 in1, u32 *result)
250 {
251         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
252         u32 out[HCI_WORDS];
253         acpi_status status = hci_raw(dev, in, out);
254         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
255         return status;
256 }
257
258 static acpi_status hci_read1(struct toshiba_acpi_dev *dev, u32 reg,
259                              u32 *out1, u32 *result)
260 {
261         u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
262         u32 out[HCI_WORDS];
263         acpi_status status = hci_raw(dev, in, out);
264         *out1 = out[2];
265         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
266         return status;
267 }
268
269 static acpi_status hci_write2(struct toshiba_acpi_dev *dev, u32 reg,
270                               u32 in1, u32 in2, u32 *result)
271 {
272         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
273         u32 out[HCI_WORDS];
274         acpi_status status = hci_raw(dev, in, out);
275         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
276         return status;
277 }
278
279 static acpi_status hci_read2(struct toshiba_acpi_dev *dev, u32 reg,
280                              u32 *out1, u32 *out2, u32 *result)
281 {
282         u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
283         u32 out[HCI_WORDS];
284         acpi_status status = hci_raw(dev, in, out);
285         *out1 = out[2];
286         *out2 = out[3];
287         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
288         return status;
289 }
290
291 /* Illumination support */
292 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev)
293 {
294         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
295         u32 out[HCI_WORDS];
296         acpi_status status;
297
298         in[0] = 0xf100;
299         status = hci_raw(dev, in, out);
300         if (ACPI_FAILURE(status)) {
301                 pr_info("Illumination device not available\n");
302                 return 0;
303         }
304         in[0] = 0xf400;
305         status = hci_raw(dev, in, out);
306         return 1;
307 }
308
309 static void toshiba_illumination_set(struct led_classdev *cdev,
310                                      enum led_brightness brightness)
311 {
312         struct toshiba_acpi_dev *dev = container_of(cdev,
313                         struct toshiba_acpi_dev, led_dev);
314         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
315         u32 out[HCI_WORDS];
316         acpi_status status;
317
318         /* First request : initialize communication. */
319         in[0] = 0xf100;
320         status = hci_raw(dev, in, out);
321         if (ACPI_FAILURE(status)) {
322                 pr_info("Illumination device not available\n");
323                 return;
324         }
325
326         if (brightness) {
327                 /* Switch the illumination on */
328                 in[0] = 0xf400;
329                 in[1] = 0x14e;
330                 in[2] = 1;
331                 status = hci_raw(dev, in, out);
332                 if (ACPI_FAILURE(status)) {
333                         pr_info("ACPI call for illumination failed\n");
334                         return;
335                 }
336         } else {
337                 /* Switch the illumination off */
338                 in[0] = 0xf400;
339                 in[1] = 0x14e;
340                 in[2] = 0;
341                 status = hci_raw(dev, in, out);
342                 if (ACPI_FAILURE(status)) {
343                         pr_info("ACPI call for illumination failed.\n");
344                         return;
345                 }
346         }
347
348         /* Last request : close communication. */
349         in[0] = 0xf200;
350         in[1] = 0;
351         in[2] = 0;
352         hci_raw(dev, in, out);
353 }
354
355 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
356 {
357         struct toshiba_acpi_dev *dev = container_of(cdev,
358                         struct toshiba_acpi_dev, led_dev);
359         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
360         u32 out[HCI_WORDS];
361         acpi_status status;
362         enum led_brightness result;
363
364         /*¬†First request : initialize communication. */
365         in[0] = 0xf100;
366         status = hci_raw(dev, in, out);
367         if (ACPI_FAILURE(status)) {
368                 pr_info("Illumination device not available\n");
369                 return LED_OFF;
370         }
371
372         /* Check the illumination */
373         in[0] = 0xf300;
374         in[1] = 0x14e;
375         status = hci_raw(dev, in, out);
376         if (ACPI_FAILURE(status)) {
377                 pr_info("ACPI call for illumination failed.\n");
378                 return LED_OFF;
379         }
380
381         result = out[2] ? LED_FULL : LED_OFF;
382
383         /* Last request : close communication. */
384         in[0] = 0xf200;
385         in[1] = 0;
386         in[2] = 0;
387         hci_raw(dev, in, out);
388
389         return result;
390 }
391
392 /* Bluetooth rfkill handlers */
393
394 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
395 {
396         u32 hci_result;
397         u32 value, value2;
398
399         value = 0;
400         value2 = 0;
401         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
402         if (hci_result == HCI_SUCCESS)
403                 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;
404
405         return hci_result;
406 }
407
408 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state)
409 {
410         u32 hci_result;
411         u32 value, value2;
412
413         value = 0;
414         value2 = 0x0001;
415         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
416
417         *radio_state = value & HCI_WIRELESS_KILL_SWITCH;
418         return hci_result;
419 }
420
421 static int bt_rfkill_set_block(void *data, bool blocked)
422 {
423         struct toshiba_acpi_dev *dev = data;
424         u32 result1, result2;
425         u32 value;
426         int err;
427         bool radio_state;
428
429         value = (blocked == false);
430
431         mutex_lock(&dev->mutex);
432         if (hci_get_radio_state(dev, &radio_state) != HCI_SUCCESS) {
433                 err = -EIO;
434                 goto out;
435         }
436
437         if (!radio_state) {
438                 err = 0;
439                 goto out;
440         }
441
442         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
443         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);
444
445         if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
446                 err = -EIO;
447         else
448                 err = 0;
449  out:
450         mutex_unlock(&dev->mutex);
451         return err;
452 }
453
454 static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
455 {
456         bool new_rfk_state;
457         bool value;
458         u32 hci_result;
459         struct toshiba_acpi_dev *dev = data;
460
461         mutex_lock(&dev->mutex);
462
463         hci_result = hci_get_radio_state(dev, &value);
464         if (hci_result != HCI_SUCCESS) {
465                 /* Can't do anything useful */
466                 mutex_unlock(&dev->mutex);
467                 return;
468         }
469
470         new_rfk_state = value;
471
472         mutex_unlock(&dev->mutex);
473
474         if (rfkill_set_hw_state(rfkill, !new_rfk_state))
475                 bt_rfkill_set_block(data, true);
476 }
477
478 static const struct rfkill_ops toshiba_rfk_ops = {
479         .set_block = bt_rfkill_set_block,
480         .poll = bt_rfkill_poll,
481 };
482
483 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, bool *enabled)
484 {
485         u32 hci_result;
486         u32 status;
487
488         hci_read1(dev, HCI_TR_BACKLIGHT, &status, &hci_result);
489         *enabled = !status;
490         return hci_result == HCI_SUCCESS ? 0 : -EIO;
491 }
492
493 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable)
494 {
495         u32 hci_result;
496         u32 value = !enable;
497
498         hci_write1(dev, HCI_TR_BACKLIGHT, value, &hci_result);
499         return hci_result == HCI_SUCCESS ? 0 : -EIO;
500 }
501
502 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
503
504 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
505 {
506         u32 hci_result;
507         u32 value;
508         int brightness = 0;
509
510         if (dev->tr_backlight_supported) {
511                 bool enabled;
512                 int ret = get_tr_backlight_status(dev, &enabled);
513                 if (ret)
514                         return ret;
515                 if (enabled)
516                         return 0;
517                 brightness++;
518         }
519
520         hci_read1(dev, HCI_LCD_BRIGHTNESS, &value, &hci_result);
521         if (hci_result == HCI_SUCCESS)
522                 return brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT);
523
524         return -EIO;
525 }
526
527 static int get_lcd_brightness(struct backlight_device *bd)
528 {
529         struct toshiba_acpi_dev *dev = bl_get_data(bd);
530         return __get_lcd_brightness(dev);
531 }
532
533 static int lcd_proc_show(struct seq_file *m, void *v)
534 {
535         struct toshiba_acpi_dev *dev = m->private;
536         int value;
537         int levels;
538
539         if (!dev->backlight_dev)
540                 return -ENODEV;
541
542         levels = dev->backlight_dev->props.max_brightness + 1;
543         value = get_lcd_brightness(dev->backlight_dev);
544         if (value >= 0) {
545                 seq_printf(m, "brightness:              %d\n", value);
546                 seq_printf(m, "brightness_levels:       %d\n", levels);
547                 return 0;
548         }
549
550         pr_err("Error reading LCD brightness\n");
551         return -EIO;
552 }
553
554 static int lcd_proc_open(struct inode *inode, struct file *file)
555 {
556         return single_open(file, lcd_proc_show, PDE(inode)->data);
557 }
558
559 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
560 {
561         u32 hci_result;
562
563         if (dev->tr_backlight_supported) {
564                 bool enable = !value;
565                 int ret = set_tr_backlight_status(dev, enable);
566                 if (ret)
567                         return ret;
568                 if (value)
569                         value--;
570         }
571
572         value = value << HCI_LCD_BRIGHTNESS_SHIFT;
573         hci_write1(dev, HCI_LCD_BRIGHTNESS, value, &hci_result);
574         return hci_result == HCI_SUCCESS ? 0 : -EIO;
575 }
576
577 static int set_lcd_status(struct backlight_device *bd)
578 {
579         struct toshiba_acpi_dev *dev = bl_get_data(bd);
580         return set_lcd_brightness(dev, bd->props.brightness);
581 }
582
583 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
584                               size_t count, loff_t *pos)
585 {
586         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
587         char cmd[42];
588         size_t len;
589         int value;
590         int ret;
591         int levels = dev->backlight_dev->props.max_brightness + 1;
592
593         len = min(count, sizeof(cmd) - 1);
594         if (copy_from_user(cmd, buf, len))
595                 return -EFAULT;
596         cmd[len] = '\0';
597
598         if (sscanf(cmd, " brightness : %i", &value) == 1 &&
599             value >= 0 && value < levels) {
600                 ret = set_lcd_brightness(dev, value);
601                 if (ret == 0)
602                         ret = count;
603         } else {
604                 ret = -EINVAL;
605         }
606         return ret;
607 }
608
609 static const struct file_operations lcd_proc_fops = {
610         .owner          = THIS_MODULE,
611         .open           = lcd_proc_open,
612         .read           = seq_read,
613         .llseek         = seq_lseek,
614         .release        = single_release,
615         .write          = lcd_proc_write,
616 };
617
618 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
619 {
620         u32 hci_result;
621
622         hci_read1(dev, HCI_VIDEO_OUT, status, &hci_result);
623         return hci_result == HCI_SUCCESS ? 0 : -EIO;
624 }
625
626 static int video_proc_show(struct seq_file *m, void *v)
627 {
628         struct toshiba_acpi_dev *dev = m->private;
629         u32 value;
630         int ret;
631
632         ret = get_video_status(dev, &value);
633         if (!ret) {
634                 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
635                 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
636                 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
637                 seq_printf(m, "lcd_out:                 %d\n", is_lcd);
638                 seq_printf(m, "crt_out:                 %d\n", is_crt);
639                 seq_printf(m, "tv_out:                  %d\n", is_tv);
640         }
641
642         return ret;
643 }
644
645 static int video_proc_open(struct inode *inode, struct file *file)
646 {
647         return single_open(file, video_proc_show, PDE(inode)->data);
648 }
649
650 static ssize_t video_proc_write(struct file *file, const char __user *buf,
651                                 size_t count, loff_t *pos)
652 {
653         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
654         char *cmd, *buffer;
655         int ret;
656         int value;
657         int remain = count;
658         int lcd_out = -1;
659         int crt_out = -1;
660         int tv_out = -1;
661         u32 video_out;
662
663         cmd = kmalloc(count + 1, GFP_KERNEL);
664         if (!cmd)
665                 return -ENOMEM;
666         if (copy_from_user(cmd, buf, count)) {
667                 kfree(cmd);
668                 return -EFAULT;
669         }
670         cmd[count] = '\0';
671
672         buffer = cmd;
673
674         /* scan expression.  Multiple expressions may be delimited with ;
675          *
676          *  NOTE: to keep scanning simple, invalid fields are ignored
677          */
678         while (remain) {
679                 if (sscanf(buffer, " lcd_out : %i", &value) == 1)
680                         lcd_out = value & 1;
681                 else if (sscanf(buffer, " crt_out : %i", &value) == 1)
682                         crt_out = value & 1;
683                 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
684                         tv_out = value & 1;
685                 /* advance to one character past the next ; */
686                 do {
687                         ++buffer;
688                         --remain;
689                 }
690                 while (remain && *(buffer - 1) != ';');
691         }
692
693         kfree(cmd);
694
695         ret = get_video_status(dev, &video_out);
696         if (!ret) {
697                 unsigned int new_video_out = video_out;
698                 if (lcd_out != -1)
699                         _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
700                 if (crt_out != -1)
701                         _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
702                 if (tv_out != -1)
703                         _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
704                 /* To avoid unnecessary video disruption, only write the new
705                  * video setting if something changed. */
706                 if (new_video_out != video_out)
707                         ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
708         }
709
710         return ret ? ret : count;
711 }
712
713 static const struct file_operations video_proc_fops = {
714         .owner          = THIS_MODULE,
715         .open           = video_proc_open,
716         .read           = seq_read,
717         .llseek         = seq_lseek,
718         .release        = single_release,
719         .write          = video_proc_write,
720 };
721
722 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
723 {
724         u32 hci_result;
725
726         hci_read1(dev, HCI_FAN, status, &hci_result);
727         return hci_result == HCI_SUCCESS ? 0 : -EIO;
728 }
729
730 static int fan_proc_show(struct seq_file *m, void *v)
731 {
732         struct toshiba_acpi_dev *dev = m->private;
733         int ret;
734         u32 value;
735
736         ret = get_fan_status(dev, &value);
737         if (!ret) {
738                 seq_printf(m, "running:                 %d\n", (value > 0));
739                 seq_printf(m, "force_on:                %d\n", dev->force_fan);
740         }
741
742         return ret;
743 }
744
745 static int fan_proc_open(struct inode *inode, struct file *file)
746 {
747         return single_open(file, fan_proc_show, PDE(inode)->data);
748 }
749
750 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
751                               size_t count, loff_t *pos)
752 {
753         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
754         char cmd[42];
755         size_t len;
756         int value;
757         u32 hci_result;
758
759         len = min(count, sizeof(cmd) - 1);
760         if (copy_from_user(cmd, buf, len))
761                 return -EFAULT;
762         cmd[len] = '\0';
763
764         if (sscanf(cmd, " force_on : %i", &value) == 1 &&
765             value >= 0 && value <= 1) {
766                 hci_write1(dev, HCI_FAN, value, &hci_result);
767                 if (hci_result != HCI_SUCCESS)
768                         return -EIO;
769                 else
770                         dev->force_fan = value;
771         } else {
772                 return -EINVAL;
773         }
774
775         return count;
776 }
777
778 static const struct file_operations fan_proc_fops = {
779         .owner          = THIS_MODULE,
780         .open           = fan_proc_open,
781         .read           = seq_read,
782         .llseek         = seq_lseek,
783         .release        = single_release,
784         .write          = fan_proc_write,
785 };
786
787 static int keys_proc_show(struct seq_file *m, void *v)
788 {
789         struct toshiba_acpi_dev *dev = m->private;
790         u32 hci_result;
791         u32 value;
792
793         if (!dev->key_event_valid && dev->system_event_supported) {
794                 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
795                 if (hci_result == HCI_SUCCESS) {
796                         dev->key_event_valid = 1;
797                         dev->last_key_event = value;
798                 } else if (hci_result == HCI_EMPTY) {
799                         /* better luck next time */
800                 } else if (hci_result == HCI_NOT_SUPPORTED) {
801                         /* This is a workaround for an unresolved issue on
802                          * some machines where system events sporadically
803                          * become disabled. */
804                         hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
805                         pr_notice("Re-enabled hotkeys\n");
806                 } else {
807                         pr_err("Error reading hotkey status\n");
808                         return -EIO;
809                 }
810         }
811
812         seq_printf(m, "hotkey_ready:            %d\n", dev->key_event_valid);
813         seq_printf(m, "hotkey:                  0x%04x\n", dev->last_key_event);
814         return 0;
815 }
816
817 static int keys_proc_open(struct inode *inode, struct file *file)
818 {
819         return single_open(file, keys_proc_show, PDE(inode)->data);
820 }
821
822 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
823                                size_t count, loff_t *pos)
824 {
825         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
826         char cmd[42];
827         size_t len;
828         int value;
829
830         len = min(count, sizeof(cmd) - 1);
831         if (copy_from_user(cmd, buf, len))
832                 return -EFAULT;
833         cmd[len] = '\0';
834
835         if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
836                 dev->key_event_valid = 0;
837         } else {
838                 return -EINVAL;
839         }
840
841         return count;
842 }
843
844 static const struct file_operations keys_proc_fops = {
845         .owner          = THIS_MODULE,
846         .open           = keys_proc_open,
847         .read           = seq_read,
848         .llseek         = seq_lseek,
849         .release        = single_release,
850         .write          = keys_proc_write,
851 };
852
853 static int version_proc_show(struct seq_file *m, void *v)
854 {
855         seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
856         seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
857         return 0;
858 }
859
860 static int version_proc_open(struct inode *inode, struct file *file)
861 {
862         return single_open(file, version_proc_show, PDE(inode)->data);
863 }
864
865 static const struct file_operations version_proc_fops = {
866         .owner          = THIS_MODULE,
867         .open           = version_proc_open,
868         .read           = seq_read,
869         .llseek         = seq_lseek,
870         .release        = single_release,
871 };
872
873 /* proc and module init
874  */
875
876 #define PROC_TOSHIBA            "toshiba"
877
878 static void __devinit
879 create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
880 {
881         if (dev->backlight_dev)
882                 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
883                                  &lcd_proc_fops, dev);
884         if (dev->video_supported)
885                 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
886                                  &video_proc_fops, dev);
887         if (dev->fan_supported)
888                 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
889                                  &fan_proc_fops, dev);
890         if (dev->hotkey_dev)
891                 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
892                                  &keys_proc_fops, dev);
893         proc_create_data("version", S_IRUGO, toshiba_proc_dir,
894                          &version_proc_fops, dev);
895 }
896
897 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
898 {
899         if (dev->backlight_dev)
900                 remove_proc_entry("lcd", toshiba_proc_dir);
901         if (dev->video_supported)
902                 remove_proc_entry("video", toshiba_proc_dir);
903         if (dev->fan_supported)
904                 remove_proc_entry("fan", toshiba_proc_dir);
905         if (dev->hotkey_dev)
906                 remove_proc_entry("keys", toshiba_proc_dir);
907         remove_proc_entry("version", toshiba_proc_dir);
908 }
909
910 static const struct backlight_ops toshiba_backlight_data = {
911         .options = BL_CORE_SUSPENDRESUME,
912         .get_brightness = get_lcd_brightness,
913         .update_status  = set_lcd_status,
914 };
915
916 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str,
917                                       struct serio *port)
918 {
919         if (str & 0x20)
920                 return false;
921
922         if (unlikely(data == 0xe0))
923                 return false;
924
925         if ((data & 0x7f) == TOS1900_FN_SCAN) {
926                 schedule_work(&toshiba_acpi->hotkey_work);
927                 return true;
928         }
929
930         return false;
931 }
932
933 static void toshiba_acpi_hotkey_work(struct work_struct *work)
934 {
935         acpi_handle ec_handle = ec_get_handle();
936         acpi_status status;
937
938         if (!ec_handle)
939                 return;
940
941         status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL);
942         if (ACPI_FAILURE(status))
943                 pr_err("ACPI NTFY method execution failed\n");
944 }
945
946 /*
947  * Returns hotkey scancode, or < 0 on failure.
948  */
949 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
950 {
951         struct acpi_buffer buf;
952         union acpi_object out_obj;
953         acpi_status status;
954
955         buf.pointer = &out_obj;
956         buf.length = sizeof(out_obj);
957
958         status = acpi_evaluate_object(dev->acpi_dev->handle, "INFO",
959                                       NULL, &buf);
960         if (ACPI_FAILURE(status) || out_obj.type != ACPI_TYPE_INTEGER) {
961                 pr_err("ACPI INFO method execution failed\n");
962                 return -EIO;
963         }
964
965         return out_obj.integer.value;
966 }
967
968 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
969                                        int scancode)
970 {
971         if (scancode == 0x100)
972                 return;
973
974         /* act on key press; ignore key release */
975         if (scancode & 0x80)
976                 return;
977
978         if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true))
979                 pr_info("Unknown key %x\n", scancode);
980 }
981
982 static int __devinit toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
983 {
984         acpi_status status;
985         acpi_handle ec_handle, handle;
986         int error;
987         u32 hci_result;
988
989         dev->hotkey_dev = input_allocate_device();
990         if (!dev->hotkey_dev) {
991                 pr_info("Unable to register input device\n");
992                 return -ENOMEM;
993         }
994
995         dev->hotkey_dev->name = "Toshiba input device";
996         dev->hotkey_dev->phys = "toshiba_acpi/input0";
997         dev->hotkey_dev->id.bustype = BUS_HOST;
998
999         error = sparse_keymap_setup(dev->hotkey_dev, toshiba_acpi_keymap, NULL);
1000         if (error)
1001                 goto err_free_dev;
1002
1003         /*
1004          * For some machines the SCI responsible for providing hotkey
1005          * notification doesn't fire. We can trigger the notification
1006          * whenever the Fn key is pressed using the NTFY method, if
1007          * supported, so if it's present set up an i8042 key filter
1008          * for this purpose.
1009          */
1010         status = AE_ERROR;
1011         ec_handle = ec_get_handle();
1012         if (ec_handle)
1013                 status = acpi_get_handle(ec_handle, "NTFY", &handle);
1014
1015         if (ACPI_SUCCESS(status)) {
1016                 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);
1017
1018                 error = i8042_install_filter(toshiba_acpi_i8042_filter);
1019                 if (error) {
1020                         pr_err("Error installing key filter\n");
1021                         goto err_free_keymap;
1022                 }
1023
1024                 dev->ntfy_supported = 1;
1025         }
1026
1027         /*
1028          * Determine hotkey query interface. Prefer using the INFO
1029          * method when it is available.
1030          */
1031         status = acpi_get_handle(dev->acpi_dev->handle, "INFO", &handle);
1032         if (ACPI_SUCCESS(status)) {
1033                 dev->info_supported = 1;
1034         } else {
1035                 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
1036                 if (hci_result == HCI_SUCCESS)
1037                         dev->system_event_supported = 1;
1038         }
1039
1040         if (!dev->info_supported && !dev->system_event_supported) {
1041                 pr_warn("No hotkey query interface found\n");
1042                 goto err_remove_filter;
1043         }
1044
1045         status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", NULL, NULL);
1046         if (ACPI_FAILURE(status)) {
1047                 pr_info("Unable to enable hotkeys\n");
1048                 error = -ENODEV;
1049                 goto err_remove_filter;
1050         }
1051
1052         error = input_register_device(dev->hotkey_dev);
1053         if (error) {
1054                 pr_info("Unable to register input device\n");
1055                 goto err_remove_filter;
1056         }
1057
1058         hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &hci_result);
1059         return 0;
1060
1061  err_remove_filter:
1062         if (dev->ntfy_supported)
1063                 i8042_remove_filter(toshiba_acpi_i8042_filter);
1064  err_free_keymap:
1065         sparse_keymap_free(dev->hotkey_dev);
1066  err_free_dev:
1067         input_free_device(dev->hotkey_dev);
1068         dev->hotkey_dev = NULL;
1069         return error;
1070 }
1071
1072 static int __devinit toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
1073 {
1074         struct backlight_properties props;
1075         int brightness;
1076         int ret;
1077         bool enabled;
1078
1079         /*
1080          * Some machines don't support the backlight methods at all, and
1081          * others support it read-only. Either of these is pretty useless,
1082          * so only register the backlight device if the backlight method
1083          * supports both reads and writes.
1084          */
1085         brightness = __get_lcd_brightness(dev);
1086         if (brightness < 0)
1087                 return 0;
1088         ret = set_lcd_brightness(dev, brightness);
1089         if (ret) {
1090                 pr_debug("Backlight method is read-only, disabling backlight support\n");
1091                 return 0;
1092         }
1093
1094         /* Determine whether or not BIOS supports transflective backlight */
1095         ret = get_tr_backlight_status(dev, &enabled);
1096         dev->tr_backlight_supported = !ret;
1097
1098         memset(&props, 0, sizeof(props));
1099         props.type = BACKLIGHT_PLATFORM;
1100         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
1101
1102         /* adding an extra level and having 0 change to transflective mode */
1103         if (dev->tr_backlight_supported)
1104                 props.max_brightness++;
1105
1106         dev->backlight_dev = backlight_device_register("toshiba",
1107                                                        &dev->acpi_dev->dev,
1108                                                        dev,
1109                                                        &toshiba_backlight_data,
1110                                                        &props);
1111         if (IS_ERR(dev->backlight_dev)) {
1112                 ret = PTR_ERR(dev->backlight_dev);
1113                 pr_err("Could not register toshiba backlight device\n");
1114                 dev->backlight_dev = NULL;
1115                 return ret;
1116         }
1117
1118         dev->backlight_dev->props.brightness = brightness;
1119         return 0;
1120 }
1121
1122 static int toshiba_acpi_remove(struct acpi_device *acpi_dev, int type)
1123 {
1124         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1125
1126         remove_toshiba_proc_entries(dev);
1127
1128         if (dev->ntfy_supported) {
1129                 i8042_remove_filter(toshiba_acpi_i8042_filter);
1130                 cancel_work_sync(&dev->hotkey_work);
1131         }
1132
1133         if (dev->hotkey_dev) {
1134                 input_unregister_device(dev->hotkey_dev);
1135                 sparse_keymap_free(dev->hotkey_dev);
1136         }
1137
1138         if (dev->bt_rfk) {
1139                 rfkill_unregister(dev->bt_rfk);
1140                 rfkill_destroy(dev->bt_rfk);
1141         }
1142
1143         if (dev->backlight_dev)
1144                 backlight_device_unregister(dev->backlight_dev);
1145
1146         if (dev->illumination_supported)
1147                 led_classdev_unregister(&dev->led_dev);
1148
1149         if (toshiba_acpi)
1150                 toshiba_acpi = NULL;
1151
1152         kfree(dev);
1153
1154         return 0;
1155 }
1156
1157 static const char * __devinit find_hci_method(acpi_handle handle)
1158 {
1159         acpi_status status;
1160         acpi_handle hci_handle;
1161
1162         status = acpi_get_handle(handle, "GHCI", &hci_handle);
1163         if (ACPI_SUCCESS(status))
1164                 return "GHCI";
1165
1166         status = acpi_get_handle(handle, "SPFC", &hci_handle);
1167         if (ACPI_SUCCESS(status))
1168                 return "SPFC";
1169
1170         return NULL;
1171 }
1172
1173 static int __devinit toshiba_acpi_add(struct acpi_device *acpi_dev)
1174 {
1175         struct toshiba_acpi_dev *dev;
1176         const char *hci_method;
1177         u32 dummy;
1178         bool bt_present;
1179         int ret = 0;
1180
1181         if (toshiba_acpi)
1182                 return -EBUSY;
1183
1184         pr_info("Toshiba Laptop ACPI Extras version %s\n",
1185                TOSHIBA_ACPI_VERSION);
1186
1187         hci_method = find_hci_method(acpi_dev->handle);
1188         if (!hci_method) {
1189                 pr_err("HCI interface not found\n");
1190                 return -ENODEV;
1191         }
1192
1193         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1194         if (!dev)
1195                 return -ENOMEM;
1196         dev->acpi_dev = acpi_dev;
1197         dev->method_hci = hci_method;
1198         acpi_dev->driver_data = dev;
1199
1200         if (toshiba_acpi_setup_keyboard(dev))
1201                 pr_info("Unable to activate hotkeys\n");
1202
1203         mutex_init(&dev->mutex);
1204
1205         ret = toshiba_acpi_setup_backlight(dev);
1206         if (ret)
1207                 goto error;
1208
1209         /* Register rfkill switch for Bluetooth */
1210         if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) {
1211                 dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth",
1212                                            &acpi_dev->dev,
1213                                            RFKILL_TYPE_BLUETOOTH,
1214                                            &toshiba_rfk_ops,
1215                                            dev);
1216                 if (!dev->bt_rfk) {
1217                         pr_err("unable to allocate rfkill device\n");
1218                         ret = -ENOMEM;
1219                         goto error;
1220                 }
1221
1222                 ret = rfkill_register(dev->bt_rfk);
1223                 if (ret) {
1224                         pr_err("unable to register rfkill device\n");
1225                         rfkill_destroy(dev->bt_rfk);
1226                         goto error;
1227                 }
1228         }
1229
1230         if (toshiba_illumination_available(dev)) {
1231                 dev->led_dev.name = "toshiba::illumination";
1232                 dev->led_dev.max_brightness = 1;
1233                 dev->led_dev.brightness_set = toshiba_illumination_set;
1234                 dev->led_dev.brightness_get = toshiba_illumination_get;
1235                 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
1236                         dev->illumination_supported = 1;
1237         }
1238
1239         /* Determine whether or not BIOS supports fan and video interfaces */
1240
1241         ret = get_video_status(dev, &dummy);
1242         dev->video_supported = !ret;
1243
1244         ret = get_fan_status(dev, &dummy);
1245         dev->fan_supported = !ret;
1246
1247         create_toshiba_proc_entries(dev);
1248
1249         toshiba_acpi = dev;
1250
1251         return 0;
1252
1253 error:
1254         toshiba_acpi_remove(acpi_dev, 0);
1255         return ret;
1256 }
1257
1258 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
1259 {
1260         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1261         u32 hci_result, value;
1262         int retries = 3;
1263         int scancode;
1264
1265         if (event != 0x80)
1266                 return;
1267
1268         if (dev->info_supported) {
1269                 scancode = toshiba_acpi_query_hotkey(dev);
1270                 if (scancode < 0)
1271                         pr_err("Failed to query hotkey event\n");
1272                 else if (scancode != 0)
1273                         toshiba_acpi_report_hotkey(dev, scancode);
1274         } else if (dev->system_event_supported) {
1275                 do {
1276                         hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
1277                         switch (hci_result) {
1278                         case HCI_SUCCESS:
1279                                 toshiba_acpi_report_hotkey(dev, (int)value);
1280                                 break;
1281                         case HCI_NOT_SUPPORTED:
1282                                 /*
1283                                  * This is a workaround for an unresolved
1284                                  * issue on some machines where system events
1285                                  * sporadically become disabled.
1286                                  */
1287                                 hci_write1(dev, HCI_SYSTEM_EVENT, 1,
1288                                            &hci_result);
1289                                 pr_notice("Re-enabled hotkeys\n");
1290                                 /* fall through */
1291                         default:
1292                                 retries--;
1293                                 break;
1294                         }
1295                 } while (retries && hci_result != HCI_EMPTY);
1296         }
1297 }
1298
1299 #ifdef CONFIG_PM_SLEEP
1300 static int toshiba_acpi_suspend(struct device *device)
1301 {
1302         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1303         u32 result;
1304
1305         if (dev->hotkey_dev)
1306                 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE, &result);
1307
1308         return 0;
1309 }
1310
1311 static int toshiba_acpi_resume(struct device *device)
1312 {
1313         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1314         u32 result;
1315
1316         if (dev->hotkey_dev)
1317                 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &result);
1318
1319         return 0;
1320 }
1321 #endif
1322
1323 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
1324                          toshiba_acpi_suspend, toshiba_acpi_resume);
1325
1326 static struct acpi_driver toshiba_acpi_driver = {
1327         .name   = "Toshiba ACPI driver",
1328         .owner  = THIS_MODULE,
1329         .ids    = toshiba_device_ids,
1330         .flags  = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1331         .ops    = {
1332                 .add            = toshiba_acpi_add,
1333                 .remove         = toshiba_acpi_remove,
1334                 .notify         = toshiba_acpi_notify,
1335         },
1336         .drv.pm = &toshiba_acpi_pm,
1337 };
1338
1339 static int __init toshiba_acpi_init(void)
1340 {
1341         int ret;
1342
1343         /*
1344          * Machines with this WMI guid aren't supported due to bugs in
1345          * their AML. This check relies on wmi initializing before
1346          * toshiba_acpi to guarantee guids have been identified.
1347          */
1348         if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
1349                 return -ENODEV;
1350
1351         toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
1352         if (!toshiba_proc_dir) {
1353                 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
1354                 return -ENODEV;
1355         }
1356
1357         ret = acpi_bus_register_driver(&toshiba_acpi_driver);
1358         if (ret) {
1359                 pr_err("Failed to register ACPI driver: %d\n", ret);
1360                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1361         }
1362
1363         return ret;
1364 }
1365
1366 static void __exit toshiba_acpi_exit(void)
1367 {
1368         acpi_bus_unregister_driver(&toshiba_acpi_driver);
1369         if (toshiba_proc_dir)
1370                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1371 }
1372
1373 module_init(toshiba_acpi_init);
1374 module_exit(toshiba_acpi_exit);