2 * toshiba_acpi.c - Toshiba Laptop ACPI Extras
5 * Copyright (C) 2002-2004 John Belmonte
6 * Copyright (C) 2008 Philip Langdale
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 * The devolpment page for this driver is located at
24 * http://memebeam.org/toys/ToshibaAcpiDriver.
27 * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
28 * engineering the Windows drivers
29 * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
30 * Rob Miller - TV out and hotkeys help
37 #define TOSHIBA_ACPI_VERSION "0.19"
38 #define PROC_INTERFACE_VERSION 1
40 #include <linux/kernel.h>
41 #include <linux/module.h>
42 #include <linux/init.h>
43 #include <linux/types.h>
44 #include <linux/proc_fs.h>
45 #include <linux/seq_file.h>
46 #include <linux/backlight.h>
47 #include <linux/platform_device.h>
48 #include <linux/rfkill.h>
50 #include <asm/uaccess.h>
52 #include <acpi/acpi_drivers.h>
54 MODULE_AUTHOR("John Belmonte");
55 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
56 MODULE_LICENSE("GPL");
58 #define MY_LOGPREFIX "toshiba_acpi: "
59 #define MY_ERR KERN_ERR MY_LOGPREFIX
60 #define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
61 #define MY_INFO KERN_INFO MY_LOGPREFIX
63 /* Toshiba ACPI method paths */
64 #define METHOD_LCD_BRIGHTNESS "\\_SB_.PCI0.VGA_.LCD_._BCM"
65 #define METHOD_HCI_1 "\\_SB_.VALD.GHCI"
66 #define METHOD_HCI_2 "\\_SB_.VALZ.GHCI"
67 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX"
69 /* Toshiba HCI interface definitions
71 * HCI is Toshiba's "Hardware Control Interface" which is supposed to
72 * be uniform across all their models. Ideally we would just call
73 * dedicated ACPI methods instead of using this primitive interface.
74 * However the ACPI methods seem to be incomplete in some areas (for
75 * example they allow setting, but not reading, the LCD brightness value),
76 * so this is still useful.
82 #define HCI_SET 0xff00
83 #define HCI_GET 0xfe00
86 #define HCI_SUCCESS 0x0000
87 #define HCI_FAILURE 0x1000
88 #define HCI_NOT_SUPPORTED 0x8000
89 #define HCI_EMPTY 0x8c00
92 #define HCI_FAN 0x0004
93 #define HCI_SYSTEM_EVENT 0x0016
94 #define HCI_VIDEO_OUT 0x001c
95 #define HCI_HOTKEY_EVENT 0x001e
96 #define HCI_LCD_BRIGHTNESS 0x002a
97 #define HCI_WIRELESS 0x0056
99 /* field definitions */
100 #define HCI_LCD_BRIGHTNESS_BITS 3
101 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS)
102 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS)
103 #define HCI_VIDEO_OUT_LCD 0x1
104 #define HCI_VIDEO_OUT_CRT 0x2
105 #define HCI_VIDEO_OUT_TV 0x4
106 #define HCI_WIRELESS_KILL_SWITCH 0x01
107 #define HCI_WIRELESS_BT_PRESENT 0x0f
108 #define HCI_WIRELESS_BT_ATTACH 0x40
109 #define HCI_WIRELESS_BT_POWER 0x80
111 static const struct acpi_device_id toshiba_device_ids[] = {
117 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
122 static __inline__ void _set_bit(u32 * word, u32 mask, int value)
124 *word = (*word & ~mask) | (mask * value);
127 /* acpi interface wrappers
130 static int is_valid_acpi_path(const char *methodName)
135 status = acpi_get_handle(NULL, (char *)methodName, &handle);
136 return !ACPI_FAILURE(status);
139 static int write_acpi_int(const char *methodName, int val)
141 struct acpi_object_list params;
142 union acpi_object in_objs[1];
145 params.count = ARRAY_SIZE(in_objs);
146 params.pointer = in_objs;
147 in_objs[0].type = ACPI_TYPE_INTEGER;
148 in_objs[0].integer.value = val;
150 status = acpi_evaluate_object(NULL, (char *)methodName, ¶ms, NULL);
151 return (status == AE_OK);
155 static int read_acpi_int(const char *methodName, int *pVal)
157 struct acpi_buffer results;
158 union acpi_object out_objs[1];
161 results.length = sizeof(out_objs);
162 results.pointer = out_objs;
164 status = acpi_evaluate_object(0, (char *)methodName, 0, &results);
165 *pVal = out_objs[0].integer.value;
167 return (status == AE_OK) && (out_objs[0].type == ACPI_TYPE_INTEGER);
171 static const char *method_hci /*= 0*/ ;
173 /* Perform a raw HCI call. Here we don't care about input or output buffer
176 static acpi_status hci_raw(const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
178 struct acpi_object_list params;
179 union acpi_object in_objs[HCI_WORDS];
180 struct acpi_buffer results;
181 union acpi_object out_objs[HCI_WORDS + 1];
185 params.count = HCI_WORDS;
186 params.pointer = in_objs;
187 for (i = 0; i < HCI_WORDS; ++i) {
188 in_objs[i].type = ACPI_TYPE_INTEGER;
189 in_objs[i].integer.value = in[i];
192 results.length = sizeof(out_objs);
193 results.pointer = out_objs;
195 status = acpi_evaluate_object(NULL, (char *)method_hci, ¶ms,
197 if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
198 for (i = 0; i < out_objs->package.count; ++i) {
199 out[i] = out_objs->package.elements[i].integer.value;
206 /* common hci tasks (get or set one or two value)
208 * In addition to the ACPI status, the HCI system returns a result which
209 * may be useful (such as "not supported").
212 static acpi_status hci_write1(u32 reg, u32 in1, u32 * result)
214 u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
216 acpi_status status = hci_raw(in, out);
217 *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
221 static acpi_status hci_read1(u32 reg, u32 * out1, u32 * result)
223 u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
225 acpi_status status = hci_raw(in, out);
227 *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
231 static acpi_status hci_write2(u32 reg, u32 in1, u32 in2, u32 *result)
233 u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
235 acpi_status status = hci_raw(in, out);
236 *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
240 static acpi_status hci_read2(u32 reg, u32 *out1, u32 *out2, u32 *result)
242 u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
244 acpi_status status = hci_raw(in, out);
247 *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
251 struct toshiba_acpi_dev {
252 struct platform_device *p_dev;
253 struct rfkill *bt_rfk;
260 static struct toshiba_acpi_dev toshiba_acpi = {
261 .bt_name = "Toshiba Bluetooth",
264 /* Bluetooth rfkill handlers */
266 static u32 hci_get_bt_present(bool *present)
273 hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);
274 if (hci_result == HCI_SUCCESS)
275 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;
280 static u32 hci_get_radio_state(bool *radio_state)
287 hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);
289 *radio_state = value & HCI_WIRELESS_KILL_SWITCH;
293 static int bt_rfkill_set_block(void *data, bool blocked)
295 struct toshiba_acpi_dev *dev = data;
296 u32 result1, result2;
301 value = (blocked == false);
303 mutex_lock(&dev->mutex);
304 if (hci_get_radio_state(&radio_state) != HCI_SUCCESS) {
314 hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
315 hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);
317 if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
322 mutex_unlock(&dev->mutex);
326 static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
331 struct toshiba_acpi_dev *dev = data;
333 mutex_lock(&dev->mutex);
335 hci_result = hci_get_radio_state(&value);
336 if (hci_result != HCI_SUCCESS) {
337 /* Can't do anything useful */
338 mutex_unlock(&dev->mutex);
342 new_rfk_state = value;
344 mutex_unlock(&dev->mutex);
346 if (rfkill_set_hw_state(rfkill, !new_rfk_state))
347 bt_rfkill_set_block(data, true);
350 static const struct rfkill_ops toshiba_rfk_ops = {
351 .set_block = bt_rfkill_set_block,
352 .poll = bt_rfkill_poll,
355 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
356 static struct backlight_device *toshiba_backlight_device;
357 static int force_fan;
358 static int last_key_event;
359 static int key_event_valid;
361 static int get_lcd(struct backlight_device *bd)
366 hci_read1(HCI_LCD_BRIGHTNESS, &value, &hci_result);
367 if (hci_result == HCI_SUCCESS) {
368 return (value >> HCI_LCD_BRIGHTNESS_SHIFT);
373 static int lcd_proc_show(struct seq_file *m, void *v)
375 int value = get_lcd(NULL);
378 seq_printf(m, "brightness: %d\n", value);
379 seq_printf(m, "brightness_levels: %d\n",
380 HCI_LCD_BRIGHTNESS_LEVELS);
382 printk(MY_ERR "Error reading LCD brightness\n");
388 static int lcd_proc_open(struct inode *inode, struct file *file)
390 return single_open(file, lcd_proc_show, NULL);
393 static int set_lcd(int value)
397 value = value << HCI_LCD_BRIGHTNESS_SHIFT;
398 hci_write1(HCI_LCD_BRIGHTNESS, value, &hci_result);
399 if (hci_result != HCI_SUCCESS)
405 static int set_lcd_status(struct backlight_device *bd)
407 return set_lcd(bd->props.brightness);
410 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
411 size_t count, loff_t *pos)
418 len = min(count, sizeof(cmd) - 1);
419 if (copy_from_user(cmd, buf, len))
423 if (sscanf(cmd, " brightness : %i", &value) == 1 &&
424 value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS) {
425 ret = set_lcd(value);
434 static const struct file_operations lcd_proc_fops = {
435 .owner = THIS_MODULE,
436 .open = lcd_proc_open,
439 .release = single_release,
440 .write = lcd_proc_write,
443 static int video_proc_show(struct seq_file *m, void *v)
448 hci_read1(HCI_VIDEO_OUT, &value, &hci_result);
449 if (hci_result == HCI_SUCCESS) {
450 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
451 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
452 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
453 seq_printf(m, "lcd_out: %d\n", is_lcd);
454 seq_printf(m, "crt_out: %d\n", is_crt);
455 seq_printf(m, "tv_out: %d\n", is_tv);
457 printk(MY_ERR "Error reading video out status\n");
463 static int video_proc_open(struct inode *inode, struct file *file)
465 return single_open(file, video_proc_show, NULL);
468 static ssize_t video_proc_write(struct file *file, const char __user *buf,
469 size_t count, loff_t *pos)
480 cmd = kmalloc(count + 1, GFP_KERNEL);
483 if (copy_from_user(cmd, buf, count)) {
491 /* scan expression. Multiple expressions may be delimited with ;
493 * NOTE: to keep scanning simple, invalid fields are ignored
496 if (sscanf(buffer, " lcd_out : %i", &value) == 1)
498 else if (sscanf(buffer, " crt_out : %i", &value) == 1)
500 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
502 /* advance to one character past the next ; */
507 while (remain && *(buffer - 1) != ';');
512 hci_read1(HCI_VIDEO_OUT, &video_out, &hci_result);
513 if (hci_result == HCI_SUCCESS) {
514 unsigned int new_video_out = video_out;
516 _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
518 _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
520 _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
521 /* To avoid unnecessary video disruption, only write the new
522 * video setting if something changed. */
523 if (new_video_out != video_out)
524 write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
532 static const struct file_operations video_proc_fops = {
533 .owner = THIS_MODULE,
534 .open = video_proc_open,
537 .release = single_release,
538 .write = video_proc_write,
541 static int fan_proc_show(struct seq_file *m, void *v)
546 hci_read1(HCI_FAN, &value, &hci_result);
547 if (hci_result == HCI_SUCCESS) {
548 seq_printf(m, "running: %d\n", (value > 0));
549 seq_printf(m, "force_on: %d\n", force_fan);
551 printk(MY_ERR "Error reading fan status\n");
557 static int fan_proc_open(struct inode *inode, struct file *file)
559 return single_open(file, fan_proc_show, NULL);
562 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
563 size_t count, loff_t *pos)
570 len = min(count, sizeof(cmd) - 1);
571 if (copy_from_user(cmd, buf, len))
575 if (sscanf(cmd, " force_on : %i", &value) == 1 &&
576 value >= 0 && value <= 1) {
577 hci_write1(HCI_FAN, value, &hci_result);
578 if (hci_result != HCI_SUCCESS)
589 static const struct file_operations fan_proc_fops = {
590 .owner = THIS_MODULE,
591 .open = fan_proc_open,
594 .release = single_release,
595 .write = fan_proc_write,
598 static int keys_proc_show(struct seq_file *m, void *v)
603 if (!key_event_valid) {
604 hci_read1(HCI_SYSTEM_EVENT, &value, &hci_result);
605 if (hci_result == HCI_SUCCESS) {
607 last_key_event = value;
608 } else if (hci_result == HCI_EMPTY) {
609 /* better luck next time */
610 } else if (hci_result == HCI_NOT_SUPPORTED) {
611 /* This is a workaround for an unresolved issue on
612 * some machines where system events sporadically
613 * become disabled. */
614 hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
615 printk(MY_NOTICE "Re-enabled hotkeys\n");
617 printk(MY_ERR "Error reading hotkey status\n");
622 seq_printf(m, "hotkey_ready: %d\n", key_event_valid);
623 seq_printf(m, "hotkey: 0x%04x\n", last_key_event);
628 static int keys_proc_open(struct inode *inode, struct file *file)
630 return single_open(file, keys_proc_show, NULL);
633 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
634 size_t count, loff_t *pos)
640 len = min(count, sizeof(cmd) - 1);
641 if (copy_from_user(cmd, buf, len))
645 if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
654 static const struct file_operations keys_proc_fops = {
655 .owner = THIS_MODULE,
656 .open = keys_proc_open,
659 .release = single_release,
660 .write = keys_proc_write,
663 static int version_proc_show(struct seq_file *m, void *v)
665 seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION);
666 seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION);
670 static int version_proc_open(struct inode *inode, struct file *file)
672 return single_open(file, version_proc_show, PDE(inode)->data);
675 static const struct file_operations version_proc_fops = {
676 .owner = THIS_MODULE,
677 .open = version_proc_open,
680 .release = single_release,
683 /* proc and module init
686 #define PROC_TOSHIBA "toshiba"
688 static acpi_status __init add_device(void)
690 proc_create("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, &lcd_proc_fops);
691 proc_create("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, &video_proc_fops);
692 proc_create("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, &fan_proc_fops);
693 proc_create("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, &keys_proc_fops);
694 proc_create("version", S_IRUGO, toshiba_proc_dir, &version_proc_fops);
699 static acpi_status remove_device(void)
701 remove_proc_entry("lcd", toshiba_proc_dir);
702 remove_proc_entry("video", toshiba_proc_dir);
703 remove_proc_entry("fan", toshiba_proc_dir);
704 remove_proc_entry("keys", toshiba_proc_dir);
705 remove_proc_entry("version", toshiba_proc_dir);
709 static struct backlight_ops toshiba_backlight_data = {
710 .get_brightness = get_lcd,
711 .update_status = set_lcd_status,
714 static void toshiba_acpi_exit(void)
716 if (toshiba_acpi.bt_rfk) {
717 rfkill_unregister(toshiba_acpi.bt_rfk);
718 rfkill_destroy(toshiba_acpi.bt_rfk);
721 if (toshiba_backlight_device)
722 backlight_device_unregister(toshiba_backlight_device);
726 if (toshiba_proc_dir)
727 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
729 platform_device_unregister(toshiba_acpi.p_dev);
734 static int __init toshiba_acpi_init(void)
736 acpi_status status = AE_OK;
744 /* simple device detection: look for HCI method */
745 if (is_valid_acpi_path(METHOD_HCI_1))
746 method_hci = METHOD_HCI_1;
747 else if (is_valid_acpi_path(METHOD_HCI_2))
748 method_hci = METHOD_HCI_2;
752 printk(MY_INFO "Toshiba Laptop ACPI Extras version %s\n",
753 TOSHIBA_ACPI_VERSION);
754 printk(MY_INFO " HCI method: %s\n", method_hci);
756 mutex_init(&toshiba_acpi.mutex);
758 toshiba_acpi.p_dev = platform_device_register_simple("toshiba_acpi",
760 if (IS_ERR(toshiba_acpi.p_dev)) {
761 ret = PTR_ERR(toshiba_acpi.p_dev);
762 printk(MY_ERR "unable to register platform device\n");
763 toshiba_acpi.p_dev = NULL;
771 /* enable event fifo */
772 hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
774 toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
775 if (!toshiba_proc_dir) {
779 status = add_device();
780 if (ACPI_FAILURE(status)) {
786 toshiba_backlight_device = backlight_device_register("toshiba",
787 &toshiba_acpi.p_dev->dev,
789 &toshiba_backlight_data);
790 if (IS_ERR(toshiba_backlight_device)) {
791 ret = PTR_ERR(toshiba_backlight_device);
793 printk(KERN_ERR "Could not register toshiba backlight device\n");
794 toshiba_backlight_device = NULL;
798 toshiba_backlight_device->props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
800 /* Register rfkill switch for Bluetooth */
801 if (hci_get_bt_present(&bt_present) == HCI_SUCCESS && bt_present) {
802 toshiba_acpi.bt_rfk = rfkill_alloc(toshiba_acpi.bt_name,
803 &toshiba_acpi.p_dev->dev,
804 RFKILL_TYPE_BLUETOOTH,
807 if (!toshiba_acpi.bt_rfk) {
808 printk(MY_ERR "unable to allocate rfkill device\n");
813 ret = rfkill_register(toshiba_acpi.bt_rfk);
815 printk(MY_ERR "unable to register rfkill device\n");
816 rfkill_destroy(toshiba_acpi.bt_rfk);
825 module_init(toshiba_acpi_init);
826 module_exit(toshiba_acpi_exit);