2 * toshiba_acpi.c - Toshiba Laptop ACPI Extras
5 * Copyright (C) 2002-2004 John Belmonte
6 * Copyright (C) 2008 Philip Langdale
7 * Copyright (C) 2010 Pierre Ducroquet
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.
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.
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
24 * The devolpment page for this driver is located at
25 * http://memebeam.org/toys/ToshibaAcpiDriver.
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
38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
40 #define TOSHIBA_ACPI_VERSION "0.19"
41 #define PROC_INTERFACE_VERSION 1
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 #include <linux/acpi.h>
58 #include <asm/uaccess.h>
60 MODULE_AUTHOR("John Belmonte");
61 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
62 MODULE_LICENSE("GPL");
64 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
66 /* Scan code for Fn key on TOS1900 models */
67 #define TOS1900_FN_SCAN 0x6e
69 /* Toshiba ACPI method paths */
70 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX"
72 /* Toshiba HCI interface definitions
74 * HCI is Toshiba's "Hardware Control Interface" which is supposed to
75 * be uniform across all their models. Ideally we would just call
76 * dedicated ACPI methods instead of using this primitive interface.
77 * However the ACPI methods seem to be incomplete in some areas (for
78 * example they allow setting, but not reading, the LCD brightness value),
79 * so this is still useful.
81 * SCI stands for "System Configuration Interface" which aim is to
82 * conceal differences in hardware between different models.
88 #define HCI_SET 0xff00
89 #define HCI_GET 0xfe00
90 #define SCI_OPEN 0xf100
91 #define SCI_CLOSE 0xf200
92 #define SCI_GET 0xf300
93 #define SCI_SET 0xf400
96 #define HCI_SUCCESS 0x0000
97 #define HCI_FAILURE 0x1000
98 #define HCI_NOT_SUPPORTED 0x8000
99 #define HCI_EMPTY 0x8c00
100 #define SCI_OPEN_CLOSE_OK 0x0044
101 #define SCI_ALREADY_OPEN 0x8100
102 #define SCI_NOT_OPENED 0x8200
103 #define SCI_INPUT_DATA_ERROR 0x8300
104 #define SCI_NOT_PRESENT 0x8600
107 #define HCI_FAN 0x0004
108 #define HCI_TR_BACKLIGHT 0x0005
109 #define HCI_SYSTEM_EVENT 0x0016
110 #define HCI_VIDEO_OUT 0x001c
111 #define HCI_HOTKEY_EVENT 0x001e
112 #define HCI_LCD_BRIGHTNESS 0x002a
113 #define HCI_WIRELESS 0x0056
114 #define HCI_KBD_ILLUMINATION 0x0095
115 #define HCI_ECO_MODE 0x0097
116 #define SCI_ILLUMINATION 0x014e
117 #define SCI_KBD_ILLUM_STATUS 0x015c
118 #define SCI_TOUCHPAD 0x050e
120 /* field definitions */
121 #define HCI_HOTKEY_DISABLE 0x0b
122 #define HCI_HOTKEY_ENABLE 0x09
123 #define HCI_LCD_BRIGHTNESS_BITS 3
124 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS)
125 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS)
126 #define HCI_MISC_SHIFT 0x10
127 #define HCI_VIDEO_OUT_LCD 0x1
128 #define HCI_VIDEO_OUT_CRT 0x2
129 #define HCI_VIDEO_OUT_TV 0x4
130 #define HCI_WIRELESS_KILL_SWITCH 0x01
131 #define HCI_WIRELESS_BT_PRESENT 0x0f
132 #define HCI_WIRELESS_BT_ATTACH 0x40
133 #define HCI_WIRELESS_BT_POWER 0x80
134 #define SCI_KBD_MODE_FNZ 0x1
135 #define SCI_KBD_MODE_AUTO 0x2
137 struct toshiba_acpi_dev
{
138 struct acpi_device
*acpi_dev
;
139 const char *method_hci
;
140 struct rfkill
*bt_rfk
;
141 struct input_dev
*hotkey_dev
;
142 struct work_struct hotkey_work
;
143 struct backlight_device
*backlight_dev
;
144 struct led_classdev led_dev
;
145 struct led_classdev kbd_led
;
146 struct led_classdev eco_led
;
154 unsigned int illumination_supported
:1;
155 unsigned int video_supported
:1;
156 unsigned int fan_supported
:1;
157 unsigned int system_event_supported
:1;
158 unsigned int ntfy_supported
:1;
159 unsigned int info_supported
:1;
160 unsigned int tr_backlight_supported
:1;
161 unsigned int kbd_illum_supported
:1;
162 unsigned int kbd_led_registered
:1;
163 unsigned int touchpad_supported
:1;
164 unsigned int eco_supported
:1;
165 unsigned int sysfs_created
:1;
170 static struct toshiba_acpi_dev
*toshiba_acpi
;
172 static const struct acpi_device_id toshiba_device_ids
[] = {
178 MODULE_DEVICE_TABLE(acpi
, toshiba_device_ids
);
180 static const struct key_entry toshiba_acpi_keymap
[] = {
181 { KE_KEY
, 0x9e, { KEY_RFKILL
} },
182 { KE_KEY
, 0x101, { KEY_MUTE
} },
183 { KE_KEY
, 0x102, { KEY_ZOOMOUT
} },
184 { KE_KEY
, 0x103, { KEY_ZOOMIN
} },
185 { KE_KEY
, 0x12c, { KEY_KBDILLUMTOGGLE
} },
186 { KE_KEY
, 0x139, { KEY_ZOOMRESET
} },
187 { KE_KEY
, 0x13b, { KEY_COFFEE
} },
188 { KE_KEY
, 0x13c, { KEY_BATTERY
} },
189 { KE_KEY
, 0x13d, { KEY_SLEEP
} },
190 { KE_KEY
, 0x13e, { KEY_SUSPEND
} },
191 { KE_KEY
, 0x13f, { KEY_SWITCHVIDEOMODE
} },
192 { KE_KEY
, 0x140, { KEY_BRIGHTNESSDOWN
} },
193 { KE_KEY
, 0x141, { KEY_BRIGHTNESSUP
} },
194 { KE_KEY
, 0x142, { KEY_WLAN
} },
195 { KE_KEY
, 0x143, { KEY_TOUCHPAD_TOGGLE
} },
196 { KE_KEY
, 0x17f, { KEY_FN
} },
197 { KE_KEY
, 0xb05, { KEY_PROG2
} },
198 { KE_KEY
, 0xb06, { KEY_WWW
} },
199 { KE_KEY
, 0xb07, { KEY_MAIL
} },
200 { KE_KEY
, 0xb30, { KEY_STOP
} },
201 { KE_KEY
, 0xb31, { KEY_PREVIOUSSONG
} },
202 { KE_KEY
, 0xb32, { KEY_NEXTSONG
} },
203 { KE_KEY
, 0xb33, { KEY_PLAYPAUSE
} },
204 { KE_KEY
, 0xb5a, { KEY_MEDIA
} },
205 { KE_IGNORE
, 0x1430, { KEY_RESERVED
} },
212 static __inline__
void _set_bit(u32
* word
, u32 mask
, int value
)
214 *word
= (*word
& ~mask
) | (mask
* value
);
217 /* acpi interface wrappers
220 static int write_acpi_int(const char *methodName
, int val
)
224 status
= acpi_execute_simple_method(NULL
, (char *)methodName
, val
);
225 return (status
== AE_OK
) ? 0 : -EIO
;
228 /* Perform a raw HCI call. Here we don't care about input or output buffer
231 static acpi_status
hci_raw(struct toshiba_acpi_dev
*dev
,
232 const u32 in
[HCI_WORDS
], u32 out
[HCI_WORDS
])
234 struct acpi_object_list params
;
235 union acpi_object in_objs
[HCI_WORDS
];
236 struct acpi_buffer results
;
237 union acpi_object out_objs
[HCI_WORDS
+ 1];
241 params
.count
= HCI_WORDS
;
242 params
.pointer
= in_objs
;
243 for (i
= 0; i
< HCI_WORDS
; ++i
) {
244 in_objs
[i
].type
= ACPI_TYPE_INTEGER
;
245 in_objs
[i
].integer
.value
= in
[i
];
248 results
.length
= sizeof(out_objs
);
249 results
.pointer
= out_objs
;
251 status
= acpi_evaluate_object(dev
->acpi_dev
->handle
,
252 (char *)dev
->method_hci
, ¶ms
,
254 if ((status
== AE_OK
) && (out_objs
->package
.count
<= HCI_WORDS
)) {
255 for (i
= 0; i
< out_objs
->package
.count
; ++i
) {
256 out
[i
] = out_objs
->package
.elements
[i
].integer
.value
;
263 /* common hci tasks (get or set one or two value)
265 * In addition to the ACPI status, the HCI system returns a result which
266 * may be useful (such as "not supported").
269 static acpi_status
hci_write1(struct toshiba_acpi_dev
*dev
, u32 reg
,
270 u32 in1
, u32
*result
)
272 u32 in
[HCI_WORDS
] = { HCI_SET
, reg
, in1
, 0, 0, 0 };
274 acpi_status status
= hci_raw(dev
, in
, out
);
275 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
279 static acpi_status
hci_read1(struct toshiba_acpi_dev
*dev
, u32 reg
,
280 u32
*out1
, u32
*result
)
282 u32 in
[HCI_WORDS
] = { HCI_GET
, reg
, 0, 0, 0, 0 };
284 acpi_status status
= hci_raw(dev
, in
, out
);
286 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
290 static acpi_status
hci_write2(struct toshiba_acpi_dev
*dev
, u32 reg
,
291 u32 in1
, u32 in2
, u32
*result
)
293 u32 in
[HCI_WORDS
] = { HCI_SET
, reg
, in1
, in2
, 0, 0 };
295 acpi_status status
= hci_raw(dev
, in
, out
);
296 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
300 static acpi_status
hci_read2(struct toshiba_acpi_dev
*dev
, u32 reg
,
301 u32
*out1
, u32
*out2
, u32
*result
)
303 u32 in
[HCI_WORDS
] = { HCI_GET
, reg
, *out1
, *out2
, 0, 0 };
305 acpi_status status
= hci_raw(dev
, in
, out
);
308 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
315 static int sci_open(struct toshiba_acpi_dev
*dev
)
317 u32 in
[HCI_WORDS
] = { SCI_OPEN
, 0, 0, 0, 0, 0 };
321 status
= hci_raw(dev
, in
, out
);
322 if (ACPI_FAILURE(status
) || out
[0] == HCI_FAILURE
) {
323 pr_err("ACPI call to open SCI failed\n");
327 if (out
[0] == SCI_OPEN_CLOSE_OK
) {
329 } else if (out
[0] == SCI_ALREADY_OPEN
) {
330 pr_info("Toshiba SCI already opened\n");
332 } else if (out
[0] == SCI_NOT_PRESENT
) {
333 pr_info("Toshiba SCI is not present\n");
339 static void sci_close(struct toshiba_acpi_dev
*dev
)
341 u32 in
[HCI_WORDS
] = { SCI_CLOSE
, 0, 0, 0, 0, 0 };
345 status
= hci_raw(dev
, in
, out
);
346 if (ACPI_FAILURE(status
) || out
[0] == HCI_FAILURE
) {
347 pr_err("ACPI call to close SCI failed\n");
351 if (out
[0] == SCI_OPEN_CLOSE_OK
)
353 else if (out
[0] == SCI_NOT_OPENED
)
354 pr_info("Toshiba SCI not opened\n");
355 else if (out
[0] == SCI_NOT_PRESENT
)
356 pr_info("Toshiba SCI is not present\n");
359 static acpi_status
sci_read(struct toshiba_acpi_dev
*dev
, u32 reg
,
360 u32
*out1
, u32
*result
)
362 u32 in
[HCI_WORDS
] = { SCI_GET
, reg
, 0, 0, 0, 0 };
364 acpi_status status
= hci_raw(dev
, in
, out
);
366 *result
= (ACPI_SUCCESS(status
)) ? out
[0] : HCI_FAILURE
;
370 static acpi_status
sci_write(struct toshiba_acpi_dev
*dev
, u32 reg
,
371 u32 in1
, u32
*result
)
373 u32 in
[HCI_WORDS
] = { SCI_SET
, reg
, in1
, 0, 0, 0 };
375 acpi_status status
= hci_raw(dev
, in
, out
);
376 *result
= (ACPI_SUCCESS(status
)) ? out
[0] : HCI_FAILURE
;
380 /* Illumination support */
381 static int toshiba_illumination_available(struct toshiba_acpi_dev
*dev
)
383 u32 in
[HCI_WORDS
] = { SCI_GET
, SCI_ILLUMINATION
, 0, 0, 0, 0 };
390 status
= hci_raw(dev
, in
, out
);
392 if (ACPI_FAILURE(status
) || out
[0] == HCI_FAILURE
) {
393 pr_err("ACPI call to query Illumination support failed\n");
395 } else if (out
[0] == HCI_NOT_SUPPORTED
|| out
[1] != 1) {
396 pr_info("Illumination device not available\n");
403 static void toshiba_illumination_set(struct led_classdev
*cdev
,
404 enum led_brightness brightness
)
406 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
407 struct toshiba_acpi_dev
, led_dev
);
411 /* First request : initialize communication. */
415 /* Switch the illumination on/off */
416 state
= brightness
? 1 : 0;
417 status
= sci_write(dev
, SCI_ILLUMINATION
, state
, &result
);
419 if (ACPI_FAILURE(status
)) {
420 pr_err("ACPI call for illumination failed\n");
422 } else if (result
== HCI_NOT_SUPPORTED
) {
423 pr_info("Illumination not supported\n");
428 static enum led_brightness
toshiba_illumination_get(struct led_classdev
*cdev
)
430 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
431 struct toshiba_acpi_dev
, led_dev
);
435 /*Â First request : initialize communication. */
439 /* Check the illumination */
440 status
= sci_read(dev
, SCI_ILLUMINATION
, &state
, &result
);
442 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
443 pr_err("ACPI call for illumination failed\n");
445 } else if (result
== HCI_NOT_SUPPORTED
) {
446 pr_info("Illumination not supported\n");
450 return state
? LED_FULL
: LED_OFF
;
453 /* KBD Illumination */
454 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev
*dev
, u32 time
)
462 status
= sci_write(dev
, SCI_KBD_ILLUM_STATUS
, time
, &result
);
464 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
465 pr_err("ACPI call to set KBD backlight status failed\n");
467 } else if (result
== HCI_NOT_SUPPORTED
) {
468 pr_info("Keyboard backlight status not supported\n");
475 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev
*dev
, u32
*time
)
483 status
= sci_read(dev
, SCI_KBD_ILLUM_STATUS
, time
, &result
);
485 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
486 pr_err("ACPI call to get KBD backlight status failed\n");
488 } else if (result
== HCI_NOT_SUPPORTED
) {
489 pr_info("Keyboard backlight status not supported\n");
496 static enum led_brightness
toshiba_kbd_backlight_get(struct led_classdev
*cdev
)
498 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
499 struct toshiba_acpi_dev
, kbd_led
);
503 /* Check the keyboard backlight state */
504 status
= hci_read1(dev
, HCI_KBD_ILLUMINATION
, &state
, &result
);
505 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
506 pr_err("ACPI call to get the keyboard backlight failed\n");
508 } else if (result
== HCI_NOT_SUPPORTED
) {
509 pr_info("Keyboard backlight not supported\n");
513 return state
? LED_FULL
: LED_OFF
;
516 static void toshiba_kbd_backlight_set(struct led_classdev
*cdev
,
517 enum led_brightness brightness
)
519 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
520 struct toshiba_acpi_dev
, kbd_led
);
524 /* Set the keyboard backlight state */
525 state
= brightness
? 1 : 0;
526 status
= hci_write1(dev
, HCI_KBD_ILLUMINATION
, state
, &result
);
527 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
528 pr_err("ACPI call to set KBD Illumination mode failed\n");
530 } else if (result
== HCI_NOT_SUPPORTED
) {
531 pr_info("Keyboard backlight not supported\n");
536 /* TouchPad support */
537 static int toshiba_touchpad_set(struct toshiba_acpi_dev
*dev
, u32 state
)
545 status
= sci_write(dev
, SCI_TOUCHPAD
, state
, &result
);
547 if (ACPI_FAILURE(status
)) {
548 pr_err("ACPI call to set the touchpad failed\n");
550 } else if (result
== HCI_NOT_SUPPORTED
) {
557 static int toshiba_touchpad_get(struct toshiba_acpi_dev
*dev
, u32
*state
)
565 status
= sci_read(dev
, SCI_TOUCHPAD
, state
, &result
);
567 if (ACPI_FAILURE(status
)) {
568 pr_err("ACPI call to query the touchpad failed\n");
570 } else if (result
== HCI_NOT_SUPPORTED
) {
577 /* Eco Mode support */
578 static int toshiba_eco_mode_available(struct toshiba_acpi_dev
*dev
)
581 u32 in
[HCI_WORDS
] = { HCI_GET
, HCI_ECO_MODE
, 0, 1, 0, 0 };
584 status
= hci_raw(dev
, in
, out
);
585 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
586 pr_info("ACPI call to get ECO led failed\n");
593 static enum led_brightness
toshiba_eco_mode_get_status(struct led_classdev
*cdev
)
595 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
596 struct toshiba_acpi_dev
, eco_led
);
597 u32 in
[HCI_WORDS
] = { HCI_GET
, HCI_ECO_MODE
, 0, 1, 0, 0 };
601 status
= hci_raw(dev
, in
, out
);
602 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
603 pr_err("ACPI call to get ECO led failed\n");
607 return out
[2] ? LED_FULL
: LED_OFF
;
610 static void toshiba_eco_mode_set_status(struct led_classdev
*cdev
,
611 enum led_brightness brightness
)
613 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
614 struct toshiba_acpi_dev
, eco_led
);
615 u32 in
[HCI_WORDS
] = { HCI_SET
, HCI_ECO_MODE
, 0, 1, 0, 0 };
619 /* Switch the Eco Mode led on/off */
620 in
[2] = (brightness
) ? 1 : 0;
621 status
= hci_raw(dev
, in
, out
);
622 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
623 pr_err("ACPI call to set ECO led failed\n");
628 /* Bluetooth rfkill handlers */
630 static u32
hci_get_bt_present(struct toshiba_acpi_dev
*dev
, bool *present
)
637 hci_read2(dev
, HCI_WIRELESS
, &value
, &value2
, &hci_result
);
638 if (hci_result
== HCI_SUCCESS
)
639 *present
= (value
& HCI_WIRELESS_BT_PRESENT
) ? true : false;
644 static u32
hci_get_radio_state(struct toshiba_acpi_dev
*dev
, bool *radio_state
)
651 hci_read2(dev
, HCI_WIRELESS
, &value
, &value2
, &hci_result
);
653 *radio_state
= value
& HCI_WIRELESS_KILL_SWITCH
;
657 static int bt_rfkill_set_block(void *data
, bool blocked
)
659 struct toshiba_acpi_dev
*dev
= data
;
660 u32 result1
, result2
;
665 value
= (blocked
== false);
667 mutex_lock(&dev
->mutex
);
668 if (hci_get_radio_state(dev
, &radio_state
) != HCI_SUCCESS
) {
678 hci_write2(dev
, HCI_WIRELESS
, value
, HCI_WIRELESS_BT_POWER
, &result1
);
679 hci_write2(dev
, HCI_WIRELESS
, value
, HCI_WIRELESS_BT_ATTACH
, &result2
);
681 if (result1
!= HCI_SUCCESS
|| result2
!= HCI_SUCCESS
)
686 mutex_unlock(&dev
->mutex
);
690 static void bt_rfkill_poll(struct rfkill
*rfkill
, void *data
)
695 struct toshiba_acpi_dev
*dev
= data
;
697 mutex_lock(&dev
->mutex
);
699 hci_result
= hci_get_radio_state(dev
, &value
);
700 if (hci_result
!= HCI_SUCCESS
) {
701 /* Can't do anything useful */
702 mutex_unlock(&dev
->mutex
);
706 new_rfk_state
= value
;
708 mutex_unlock(&dev
->mutex
);
710 if (rfkill_set_hw_state(rfkill
, !new_rfk_state
))
711 bt_rfkill_set_block(data
, true);
714 static const struct rfkill_ops toshiba_rfk_ops
= {
715 .set_block
= bt_rfkill_set_block
,
716 .poll
= bt_rfkill_poll
,
719 static int get_tr_backlight_status(struct toshiba_acpi_dev
*dev
, bool *enabled
)
724 hci_read1(dev
, HCI_TR_BACKLIGHT
, &status
, &hci_result
);
726 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
729 static int set_tr_backlight_status(struct toshiba_acpi_dev
*dev
, bool enable
)
734 hci_write1(dev
, HCI_TR_BACKLIGHT
, value
, &hci_result
);
735 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
738 static struct proc_dir_entry
*toshiba_proc_dir
/*= 0*/ ;
740 static int __get_lcd_brightness(struct toshiba_acpi_dev
*dev
)
746 if (dev
->tr_backlight_supported
) {
748 int ret
= get_tr_backlight_status(dev
, &enabled
);
756 hci_read1(dev
, HCI_LCD_BRIGHTNESS
, &value
, &hci_result
);
757 if (hci_result
== HCI_SUCCESS
)
758 return brightness
+ (value
>> HCI_LCD_BRIGHTNESS_SHIFT
);
763 static int get_lcd_brightness(struct backlight_device
*bd
)
765 struct toshiba_acpi_dev
*dev
= bl_get_data(bd
);
766 return __get_lcd_brightness(dev
);
769 static int lcd_proc_show(struct seq_file
*m
, void *v
)
771 struct toshiba_acpi_dev
*dev
= m
->private;
775 if (!dev
->backlight_dev
)
778 levels
= dev
->backlight_dev
->props
.max_brightness
+ 1;
779 value
= get_lcd_brightness(dev
->backlight_dev
);
781 seq_printf(m
, "brightness: %d\n", value
);
782 seq_printf(m
, "brightness_levels: %d\n", levels
);
786 pr_err("Error reading LCD brightness\n");
790 static int lcd_proc_open(struct inode
*inode
, struct file
*file
)
792 return single_open(file
, lcd_proc_show
, PDE_DATA(inode
));
795 static int set_lcd_brightness(struct toshiba_acpi_dev
*dev
, int value
)
799 if (dev
->tr_backlight_supported
) {
800 bool enable
= !value
;
801 int ret
= set_tr_backlight_status(dev
, enable
);
808 value
= value
<< HCI_LCD_BRIGHTNESS_SHIFT
;
809 hci_write1(dev
, HCI_LCD_BRIGHTNESS
, value
, &hci_result
);
810 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
813 static int set_lcd_status(struct backlight_device
*bd
)
815 struct toshiba_acpi_dev
*dev
= bl_get_data(bd
);
816 return set_lcd_brightness(dev
, bd
->props
.brightness
);
819 static ssize_t
lcd_proc_write(struct file
*file
, const char __user
*buf
,
820 size_t count
, loff_t
*pos
)
822 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
827 int levels
= dev
->backlight_dev
->props
.max_brightness
+ 1;
829 len
= min(count
, sizeof(cmd
) - 1);
830 if (copy_from_user(cmd
, buf
, len
))
834 if (sscanf(cmd
, " brightness : %i", &value
) == 1 &&
835 value
>= 0 && value
< levels
) {
836 ret
= set_lcd_brightness(dev
, value
);
845 static const struct file_operations lcd_proc_fops
= {
846 .owner
= THIS_MODULE
,
847 .open
= lcd_proc_open
,
850 .release
= single_release
,
851 .write
= lcd_proc_write
,
854 static int get_video_status(struct toshiba_acpi_dev
*dev
, u32
*status
)
858 hci_read1(dev
, HCI_VIDEO_OUT
, status
, &hci_result
);
859 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
862 static int video_proc_show(struct seq_file
*m
, void *v
)
864 struct toshiba_acpi_dev
*dev
= m
->private;
868 ret
= get_video_status(dev
, &value
);
870 int is_lcd
= (value
& HCI_VIDEO_OUT_LCD
) ? 1 : 0;
871 int is_crt
= (value
& HCI_VIDEO_OUT_CRT
) ? 1 : 0;
872 int is_tv
= (value
& HCI_VIDEO_OUT_TV
) ? 1 : 0;
873 seq_printf(m
, "lcd_out: %d\n", is_lcd
);
874 seq_printf(m
, "crt_out: %d\n", is_crt
);
875 seq_printf(m
, "tv_out: %d\n", is_tv
);
881 static int video_proc_open(struct inode
*inode
, struct file
*file
)
883 return single_open(file
, video_proc_show
, PDE_DATA(inode
));
886 static ssize_t
video_proc_write(struct file
*file
, const char __user
*buf
,
887 size_t count
, loff_t
*pos
)
889 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
899 cmd
= kmalloc(count
+ 1, GFP_KERNEL
);
902 if (copy_from_user(cmd
, buf
, count
)) {
910 /* scan expression. Multiple expressions may be delimited with ;
912 * NOTE: to keep scanning simple, invalid fields are ignored
915 if (sscanf(buffer
, " lcd_out : %i", &value
) == 1)
917 else if (sscanf(buffer
, " crt_out : %i", &value
) == 1)
919 else if (sscanf(buffer
, " tv_out : %i", &value
) == 1)
921 /* advance to one character past the next ; */
926 while (remain
&& *(buffer
- 1) != ';');
931 ret
= get_video_status(dev
, &video_out
);
933 unsigned int new_video_out
= video_out
;
935 _set_bit(&new_video_out
, HCI_VIDEO_OUT_LCD
, lcd_out
);
937 _set_bit(&new_video_out
, HCI_VIDEO_OUT_CRT
, crt_out
);
939 _set_bit(&new_video_out
, HCI_VIDEO_OUT_TV
, tv_out
);
940 /* To avoid unnecessary video disruption, only write the new
941 * video setting if something changed. */
942 if (new_video_out
!= video_out
)
943 ret
= write_acpi_int(METHOD_VIDEO_OUT
, new_video_out
);
946 return ret
? ret
: count
;
949 static const struct file_operations video_proc_fops
= {
950 .owner
= THIS_MODULE
,
951 .open
= video_proc_open
,
954 .release
= single_release
,
955 .write
= video_proc_write
,
958 static int get_fan_status(struct toshiba_acpi_dev
*dev
, u32
*status
)
962 hci_read1(dev
, HCI_FAN
, status
, &hci_result
);
963 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
966 static int fan_proc_show(struct seq_file
*m
, void *v
)
968 struct toshiba_acpi_dev
*dev
= m
->private;
972 ret
= get_fan_status(dev
, &value
);
974 seq_printf(m
, "running: %d\n", (value
> 0));
975 seq_printf(m
, "force_on: %d\n", dev
->force_fan
);
981 static int fan_proc_open(struct inode
*inode
, struct file
*file
)
983 return single_open(file
, fan_proc_show
, PDE_DATA(inode
));
986 static ssize_t
fan_proc_write(struct file
*file
, const char __user
*buf
,
987 size_t count
, loff_t
*pos
)
989 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
995 len
= min(count
, sizeof(cmd
) - 1);
996 if (copy_from_user(cmd
, buf
, len
))
1000 if (sscanf(cmd
, " force_on : %i", &value
) == 1 &&
1001 value
>= 0 && value
<= 1) {
1002 hci_write1(dev
, HCI_FAN
, value
, &hci_result
);
1003 if (hci_result
!= HCI_SUCCESS
)
1006 dev
->force_fan
= value
;
1014 static const struct file_operations fan_proc_fops
= {
1015 .owner
= THIS_MODULE
,
1016 .open
= fan_proc_open
,
1018 .llseek
= seq_lseek
,
1019 .release
= single_release
,
1020 .write
= fan_proc_write
,
1023 static int keys_proc_show(struct seq_file
*m
, void *v
)
1025 struct toshiba_acpi_dev
*dev
= m
->private;
1029 if (!dev
->key_event_valid
&& dev
->system_event_supported
) {
1030 hci_read1(dev
, HCI_SYSTEM_EVENT
, &value
, &hci_result
);
1031 if (hci_result
== HCI_SUCCESS
) {
1032 dev
->key_event_valid
= 1;
1033 dev
->last_key_event
= value
;
1034 } else if (hci_result
== HCI_EMPTY
) {
1035 /* better luck next time */
1036 } else if (hci_result
== HCI_NOT_SUPPORTED
) {
1037 /* This is a workaround for an unresolved issue on
1038 * some machines where system events sporadically
1039 * become disabled. */
1040 hci_write1(dev
, HCI_SYSTEM_EVENT
, 1, &hci_result
);
1041 pr_notice("Re-enabled hotkeys\n");
1043 pr_err("Error reading hotkey status\n");
1048 seq_printf(m
, "hotkey_ready: %d\n", dev
->key_event_valid
);
1049 seq_printf(m
, "hotkey: 0x%04x\n", dev
->last_key_event
);
1053 static int keys_proc_open(struct inode
*inode
, struct file
*file
)
1055 return single_open(file
, keys_proc_show
, PDE_DATA(inode
));
1058 static ssize_t
keys_proc_write(struct file
*file
, const char __user
*buf
,
1059 size_t count
, loff_t
*pos
)
1061 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
1066 len
= min(count
, sizeof(cmd
) - 1);
1067 if (copy_from_user(cmd
, buf
, len
))
1071 if (sscanf(cmd
, " hotkey_ready : %i", &value
) == 1 && value
== 0) {
1072 dev
->key_event_valid
= 0;
1080 static const struct file_operations keys_proc_fops
= {
1081 .owner
= THIS_MODULE
,
1082 .open
= keys_proc_open
,
1084 .llseek
= seq_lseek
,
1085 .release
= single_release
,
1086 .write
= keys_proc_write
,
1089 static int version_proc_show(struct seq_file
*m
, void *v
)
1091 seq_printf(m
, "driver: %s\n", TOSHIBA_ACPI_VERSION
);
1092 seq_printf(m
, "proc_interface: %d\n", PROC_INTERFACE_VERSION
);
1096 static int version_proc_open(struct inode
*inode
, struct file
*file
)
1098 return single_open(file
, version_proc_show
, PDE_DATA(inode
));
1101 static const struct file_operations version_proc_fops
= {
1102 .owner
= THIS_MODULE
,
1103 .open
= version_proc_open
,
1105 .llseek
= seq_lseek
,
1106 .release
= single_release
,
1109 /* proc and module init
1112 #define PROC_TOSHIBA "toshiba"
1114 static void create_toshiba_proc_entries(struct toshiba_acpi_dev
*dev
)
1116 if (dev
->backlight_dev
)
1117 proc_create_data("lcd", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1118 &lcd_proc_fops
, dev
);
1119 if (dev
->video_supported
)
1120 proc_create_data("video", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1121 &video_proc_fops
, dev
);
1122 if (dev
->fan_supported
)
1123 proc_create_data("fan", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1124 &fan_proc_fops
, dev
);
1125 if (dev
->hotkey_dev
)
1126 proc_create_data("keys", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1127 &keys_proc_fops
, dev
);
1128 proc_create_data("version", S_IRUGO
, toshiba_proc_dir
,
1129 &version_proc_fops
, dev
);
1132 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev
*dev
)
1134 if (dev
->backlight_dev
)
1135 remove_proc_entry("lcd", toshiba_proc_dir
);
1136 if (dev
->video_supported
)
1137 remove_proc_entry("video", toshiba_proc_dir
);
1138 if (dev
->fan_supported
)
1139 remove_proc_entry("fan", toshiba_proc_dir
);
1140 if (dev
->hotkey_dev
)
1141 remove_proc_entry("keys", toshiba_proc_dir
);
1142 remove_proc_entry("version", toshiba_proc_dir
);
1145 static const struct backlight_ops toshiba_backlight_data
= {
1146 .options
= BL_CORE_SUSPENDRESUME
,
1147 .get_brightness
= get_lcd_brightness
,
1148 .update_status
= set_lcd_status
,
1155 static ssize_t
toshiba_kbd_bl_mode_store(struct device
*dev
,
1156 struct device_attribute
*attr
,
1157 const char *buf
, size_t count
)
1159 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1163 if (sscanf(buf
, "%i", &mode
) != 1 && (mode
!= 2 || mode
!= 1))
1166 /* Set the Keyboard Backlight Mode where:
1167 * Mode - Auto (2) | FN-Z (1)
1168 * Auto - KBD backlight turns off automatically in given time
1169 * FN-Z - KBD backlight "toggles" when hotkey pressed
1171 if (mode
!= -1 && toshiba
->kbd_mode
!= mode
) {
1172 time
= toshiba
->kbd_time
<< HCI_MISC_SHIFT
;
1173 time
= time
+ toshiba
->kbd_mode
;
1174 if (toshiba_kbd_illum_status_set(toshiba
, time
) < 0)
1176 toshiba
->kbd_mode
= mode
;
1182 static ssize_t
toshiba_kbd_bl_mode_show(struct device
*dev
,
1183 struct device_attribute
*attr
,
1186 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1189 if (toshiba_kbd_illum_status_get(toshiba
, &time
) < 0)
1192 return sprintf(buf
, "%i\n", time
& 0x07);
1195 static ssize_t
toshiba_kbd_bl_timeout_store(struct device
*dev
,
1196 struct device_attribute
*attr
,
1197 const char *buf
, size_t count
)
1199 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1202 if (sscanf(buf
, "%i", &time
) != 1 && (time
< 0 || time
> 60))
1205 /* Set the Keyboard Backlight Timeout: 0-60 seconds */
1206 if (time
!= -1 && toshiba
->kbd_time
!= time
) {
1207 time
= time
<< HCI_MISC_SHIFT
;
1208 time
= (toshiba
->kbd_mode
== SCI_KBD_MODE_AUTO
) ?
1209 time
+ 1 : time
+ 2;
1210 if (toshiba_kbd_illum_status_set(toshiba
, time
) < 0)
1212 toshiba
->kbd_time
= time
>> HCI_MISC_SHIFT
;
1218 static ssize_t
toshiba_kbd_bl_timeout_show(struct device
*dev
,
1219 struct device_attribute
*attr
,
1222 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1225 if (toshiba_kbd_illum_status_get(toshiba
, &time
) < 0)
1228 return sprintf(buf
, "%i\n", time
>> HCI_MISC_SHIFT
);
1231 static ssize_t
toshiba_touchpad_store(struct device
*dev
,
1232 struct device_attribute
*attr
,
1233 const char *buf
, size_t count
)
1235 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1238 /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */
1239 if (sscanf(buf
, "%i", &state
) == 1 && (state
== 0 || state
== 1)) {
1240 if (toshiba_touchpad_set(toshiba
, state
) < 0)
1247 static ssize_t
toshiba_touchpad_show(struct device
*dev
,
1248 struct device_attribute
*attr
, char *buf
)
1250 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1254 ret
= toshiba_touchpad_get(toshiba
, &state
);
1258 return sprintf(buf
, "%i\n", state
);
1261 static DEVICE_ATTR(kbd_backlight_mode
, S_IRUGO
| S_IWUSR
,
1262 toshiba_kbd_bl_mode_show
, toshiba_kbd_bl_mode_store
);
1263 static DEVICE_ATTR(kbd_backlight_timeout
, S_IRUGO
| S_IWUSR
,
1264 toshiba_kbd_bl_timeout_show
, toshiba_kbd_bl_timeout_store
);
1265 static DEVICE_ATTR(touchpad
, S_IRUGO
| S_IWUSR
,
1266 toshiba_touchpad_show
, toshiba_touchpad_store
);
1268 static struct attribute
*toshiba_attributes
[] = {
1269 &dev_attr_kbd_backlight_mode
.attr
,
1270 &dev_attr_kbd_backlight_timeout
.attr
,
1271 &dev_attr_touchpad
.attr
,
1275 static umode_t
toshiba_sysfs_is_visible(struct kobject
*kobj
,
1276 struct attribute
*attr
, int idx
)
1278 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1279 struct toshiba_acpi_dev
*drv
= dev_get_drvdata(dev
);
1282 if (attr
== &dev_attr_kbd_backlight_mode
.attr
)
1283 exists
= (drv
->kbd_illum_supported
) ? true : false;
1284 else if (attr
== &dev_attr_kbd_backlight_timeout
.attr
)
1285 exists
= (drv
->kbd_mode
== SCI_KBD_MODE_AUTO
) ? true : false;
1286 else if (attr
== &dev_attr_touchpad
.attr
)
1287 exists
= (drv
->touchpad_supported
) ? true : false;
1289 return exists
? attr
->mode
: 0;
1292 static struct attribute_group toshiba_attr_group
= {
1293 .is_visible
= toshiba_sysfs_is_visible
,
1294 .attrs
= toshiba_attributes
,
1297 static bool toshiba_acpi_i8042_filter(unsigned char data
, unsigned char str
,
1303 if (unlikely(data
== 0xe0))
1306 if ((data
& 0x7f) == TOS1900_FN_SCAN
) {
1307 schedule_work(&toshiba_acpi
->hotkey_work
);
1314 static void toshiba_acpi_hotkey_work(struct work_struct
*work
)
1316 acpi_handle ec_handle
= ec_get_handle();
1322 status
= acpi_evaluate_object(ec_handle
, "NTFY", NULL
, NULL
);
1323 if (ACPI_FAILURE(status
))
1324 pr_err("ACPI NTFY method execution failed\n");
1328 * Returns hotkey scancode, or < 0 on failure.
1330 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev
*dev
)
1332 unsigned long long value
;
1335 status
= acpi_evaluate_integer(dev
->acpi_dev
->handle
, "INFO",
1337 if (ACPI_FAILURE(status
)) {
1338 pr_err("ACPI INFO method execution failed\n");
1345 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev
*dev
,
1348 if (scancode
== 0x100)
1351 /* act on key press; ignore key release */
1352 if (scancode
& 0x80)
1355 if (!sparse_keymap_report_event(dev
->hotkey_dev
, scancode
, 1, true))
1356 pr_info("Unknown key %x\n", scancode
);
1359 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev
*dev
)
1362 acpi_handle ec_handle
;
1366 dev
->hotkey_dev
= input_allocate_device();
1367 if (!dev
->hotkey_dev
)
1370 dev
->hotkey_dev
->name
= "Toshiba input device";
1371 dev
->hotkey_dev
->phys
= "toshiba_acpi/input0";
1372 dev
->hotkey_dev
->id
.bustype
= BUS_HOST
;
1374 error
= sparse_keymap_setup(dev
->hotkey_dev
, toshiba_acpi_keymap
, NULL
);
1379 * For some machines the SCI responsible for providing hotkey
1380 * notification doesn't fire. We can trigger the notification
1381 * whenever the Fn key is pressed using the NTFY method, if
1382 * supported, so if it's present set up an i8042 key filter
1386 ec_handle
= ec_get_handle();
1387 if (ec_handle
&& acpi_has_method(ec_handle
, "NTFY")) {
1388 INIT_WORK(&dev
->hotkey_work
, toshiba_acpi_hotkey_work
);
1390 error
= i8042_install_filter(toshiba_acpi_i8042_filter
);
1392 pr_err("Error installing key filter\n");
1393 goto err_free_keymap
;
1396 dev
->ntfy_supported
= 1;
1400 * Determine hotkey query interface. Prefer using the INFO
1401 * method when it is available.
1403 if (acpi_has_method(dev
->acpi_dev
->handle
, "INFO"))
1404 dev
->info_supported
= 1;
1406 hci_write1(dev
, HCI_SYSTEM_EVENT
, 1, &hci_result
);
1407 if (hci_result
== HCI_SUCCESS
)
1408 dev
->system_event_supported
= 1;
1411 if (!dev
->info_supported
&& !dev
->system_event_supported
) {
1412 pr_warn("No hotkey query interface found\n");
1413 goto err_remove_filter
;
1416 status
= acpi_evaluate_object(dev
->acpi_dev
->handle
, "ENAB", NULL
, NULL
);
1417 if (ACPI_FAILURE(status
)) {
1418 pr_info("Unable to enable hotkeys\n");
1420 goto err_remove_filter
;
1423 error
= input_register_device(dev
->hotkey_dev
);
1425 pr_info("Unable to register input device\n");
1426 goto err_remove_filter
;
1429 hci_write1(dev
, HCI_HOTKEY_EVENT
, HCI_HOTKEY_ENABLE
, &hci_result
);
1433 if (dev
->ntfy_supported
)
1434 i8042_remove_filter(toshiba_acpi_i8042_filter
);
1436 sparse_keymap_free(dev
->hotkey_dev
);
1438 input_free_device(dev
->hotkey_dev
);
1439 dev
->hotkey_dev
= NULL
;
1443 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev
*dev
)
1445 struct backlight_properties props
;
1451 * Some machines don't support the backlight methods at all, and
1452 * others support it read-only. Either of these is pretty useless,
1453 * so only register the backlight device if the backlight method
1454 * supports both reads and writes.
1456 brightness
= __get_lcd_brightness(dev
);
1459 ret
= set_lcd_brightness(dev
, brightness
);
1461 pr_debug("Backlight method is read-only, disabling backlight support\n");
1465 /* Determine whether or not BIOS supports transflective backlight */
1466 ret
= get_tr_backlight_status(dev
, &enabled
);
1467 dev
->tr_backlight_supported
= !ret
;
1469 memset(&props
, 0, sizeof(props
));
1470 props
.type
= BACKLIGHT_PLATFORM
;
1471 props
.max_brightness
= HCI_LCD_BRIGHTNESS_LEVELS
- 1;
1473 /* adding an extra level and having 0 change to transflective mode */
1474 if (dev
->tr_backlight_supported
)
1475 props
.max_brightness
++;
1477 dev
->backlight_dev
= backlight_device_register("toshiba",
1478 &dev
->acpi_dev
->dev
,
1480 &toshiba_backlight_data
,
1482 if (IS_ERR(dev
->backlight_dev
)) {
1483 ret
= PTR_ERR(dev
->backlight_dev
);
1484 pr_err("Could not register toshiba backlight device\n");
1485 dev
->backlight_dev
= NULL
;
1489 dev
->backlight_dev
->props
.brightness
= brightness
;
1493 static int toshiba_acpi_remove(struct acpi_device
*acpi_dev
)
1495 struct toshiba_acpi_dev
*dev
= acpi_driver_data(acpi_dev
);
1497 remove_toshiba_proc_entries(dev
);
1499 if (dev
->sysfs_created
)
1500 sysfs_remove_group(&dev
->acpi_dev
->dev
.kobj
,
1501 &toshiba_attr_group
);
1503 if (dev
->ntfy_supported
) {
1504 i8042_remove_filter(toshiba_acpi_i8042_filter
);
1505 cancel_work_sync(&dev
->hotkey_work
);
1508 if (dev
->hotkey_dev
) {
1509 input_unregister_device(dev
->hotkey_dev
);
1510 sparse_keymap_free(dev
->hotkey_dev
);
1514 rfkill_unregister(dev
->bt_rfk
);
1515 rfkill_destroy(dev
->bt_rfk
);
1518 if (dev
->backlight_dev
)
1519 backlight_device_unregister(dev
->backlight_dev
);
1521 if (dev
->illumination_supported
)
1522 led_classdev_unregister(&dev
->led_dev
);
1524 if (dev
->kbd_led_registered
)
1525 led_classdev_unregister(&dev
->kbd_led
);
1527 if (dev
->eco_supported
)
1528 led_classdev_unregister(&dev
->eco_led
);
1531 toshiba_acpi
= NULL
;
1538 static const char *find_hci_method(acpi_handle handle
)
1540 if (acpi_has_method(handle
, "GHCI"))
1543 if (acpi_has_method(handle
, "SPFC"))
1549 static int toshiba_acpi_add(struct acpi_device
*acpi_dev
)
1551 struct toshiba_acpi_dev
*dev
;
1552 const char *hci_method
;
1560 pr_info("Toshiba Laptop ACPI Extras version %s\n",
1561 TOSHIBA_ACPI_VERSION
);
1563 hci_method
= find_hci_method(acpi_dev
->handle
);
1565 pr_err("HCI interface not found\n");
1569 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1572 dev
->acpi_dev
= acpi_dev
;
1573 dev
->method_hci
= hci_method
;
1574 acpi_dev
->driver_data
= dev
;
1575 dev_set_drvdata(&acpi_dev
->dev
, dev
);
1577 if (toshiba_acpi_setup_keyboard(dev
))
1578 pr_info("Unable to activate hotkeys\n");
1580 mutex_init(&dev
->mutex
);
1582 ret
= toshiba_acpi_setup_backlight(dev
);
1586 /* Register rfkill switch for Bluetooth */
1587 if (hci_get_bt_present(dev
, &bt_present
) == HCI_SUCCESS
&& bt_present
) {
1588 dev
->bt_rfk
= rfkill_alloc("Toshiba Bluetooth",
1590 RFKILL_TYPE_BLUETOOTH
,
1594 pr_err("unable to allocate rfkill device\n");
1599 ret
= rfkill_register(dev
->bt_rfk
);
1601 pr_err("unable to register rfkill device\n");
1602 rfkill_destroy(dev
->bt_rfk
);
1607 if (toshiba_illumination_available(dev
)) {
1608 dev
->led_dev
.name
= "toshiba::illumination";
1609 dev
->led_dev
.max_brightness
= 1;
1610 dev
->led_dev
.brightness_set
= toshiba_illumination_set
;
1611 dev
->led_dev
.brightness_get
= toshiba_illumination_get
;
1612 if (!led_classdev_register(&acpi_dev
->dev
, &dev
->led_dev
))
1613 dev
->illumination_supported
= 1;
1616 if (toshiba_eco_mode_available(dev
)) {
1617 dev
->eco_led
.name
= "toshiba::eco_mode";
1618 dev
->eco_led
.max_brightness
= 1;
1619 dev
->eco_led
.brightness_set
= toshiba_eco_mode_set_status
;
1620 dev
->eco_led
.brightness_get
= toshiba_eco_mode_get_status
;
1621 if (!led_classdev_register(&dev
->acpi_dev
->dev
, &dev
->eco_led
))
1622 dev
->eco_supported
= 1;
1625 ret
= toshiba_kbd_illum_status_get(dev
, &dummy
);
1627 dev
->kbd_time
= dummy
>> HCI_MISC_SHIFT
;
1628 dev
->kbd_mode
= dummy
& 0x07;
1630 dev
->kbd_illum_supported
= !ret
;
1632 * Only register the LED if KBD illumination is supported
1633 * and the keyboard backlight operation mode is set to FN-Z
1635 if (dev
->kbd_illum_supported
&& dev
->kbd_mode
== SCI_KBD_MODE_FNZ
) {
1636 dev
->kbd_led
.name
= "toshiba::kbd_backlight";
1637 dev
->kbd_led
.max_brightness
= 1;
1638 dev
->kbd_led
.brightness_set
= toshiba_kbd_backlight_set
;
1639 dev
->kbd_led
.brightness_get
= toshiba_kbd_backlight_get
;
1640 if (!led_classdev_register(&dev
->acpi_dev
->dev
, &dev
->kbd_led
))
1641 dev
->kbd_led_registered
= 1;
1644 ret
= toshiba_touchpad_get(dev
, &dummy
);
1645 dev
->touchpad_supported
= !ret
;
1647 /* Determine whether or not BIOS supports fan and video interfaces */
1649 ret
= get_video_status(dev
, &dummy
);
1650 dev
->video_supported
= !ret
;
1652 ret
= get_fan_status(dev
, &dummy
);
1653 dev
->fan_supported
= !ret
;
1655 ret
= sysfs_create_group(&dev
->acpi_dev
->dev
.kobj
,
1656 &toshiba_attr_group
);
1658 dev
->sysfs_created
= 0;
1661 dev
->sysfs_created
= !ret
;
1663 create_toshiba_proc_entries(dev
);
1670 toshiba_acpi_remove(acpi_dev
);
1674 static void toshiba_acpi_notify(struct acpi_device
*acpi_dev
, u32 event
)
1676 struct toshiba_acpi_dev
*dev
= acpi_driver_data(acpi_dev
);
1677 u32 hci_result
, value
;
1684 if (dev
->info_supported
) {
1685 scancode
= toshiba_acpi_query_hotkey(dev
);
1687 pr_err("Failed to query hotkey event\n");
1688 else if (scancode
!= 0)
1689 toshiba_acpi_report_hotkey(dev
, scancode
);
1690 } else if (dev
->system_event_supported
) {
1692 hci_read1(dev
, HCI_SYSTEM_EVENT
, &value
, &hci_result
);
1693 switch (hci_result
) {
1695 toshiba_acpi_report_hotkey(dev
, (int)value
);
1697 case HCI_NOT_SUPPORTED
:
1699 * This is a workaround for an unresolved
1700 * issue on some machines where system events
1701 * sporadically become disabled.
1703 hci_write1(dev
, HCI_SYSTEM_EVENT
, 1,
1705 pr_notice("Re-enabled hotkeys\n");
1711 } while (retries
&& hci_result
!= HCI_EMPTY
);
1715 #ifdef CONFIG_PM_SLEEP
1716 static int toshiba_acpi_suspend(struct device
*device
)
1718 struct toshiba_acpi_dev
*dev
= acpi_driver_data(to_acpi_device(device
));
1721 if (dev
->hotkey_dev
)
1722 hci_write1(dev
, HCI_HOTKEY_EVENT
, HCI_HOTKEY_DISABLE
, &result
);
1727 static int toshiba_acpi_resume(struct device
*device
)
1729 struct toshiba_acpi_dev
*dev
= acpi_driver_data(to_acpi_device(device
));
1732 if (dev
->hotkey_dev
)
1733 hci_write1(dev
, HCI_HOTKEY_EVENT
, HCI_HOTKEY_ENABLE
, &result
);
1739 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm
,
1740 toshiba_acpi_suspend
, toshiba_acpi_resume
);
1742 static struct acpi_driver toshiba_acpi_driver
= {
1743 .name
= "Toshiba ACPI driver",
1744 .owner
= THIS_MODULE
,
1745 .ids
= toshiba_device_ids
,
1746 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
1748 .add
= toshiba_acpi_add
,
1749 .remove
= toshiba_acpi_remove
,
1750 .notify
= toshiba_acpi_notify
,
1752 .drv
.pm
= &toshiba_acpi_pm
,
1755 static int __init
toshiba_acpi_init(void)
1760 * Machines with this WMI guid aren't supported due to bugs in
1761 * their AML. This check relies on wmi initializing before
1762 * toshiba_acpi to guarantee guids have been identified.
1764 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID
))
1767 toshiba_proc_dir
= proc_mkdir(PROC_TOSHIBA
, acpi_root_dir
);
1768 if (!toshiba_proc_dir
) {
1769 pr_err("Unable to create proc dir " PROC_TOSHIBA
"\n");
1773 ret
= acpi_bus_register_driver(&toshiba_acpi_driver
);
1775 pr_err("Failed to register ACPI driver: %d\n", ret
);
1776 remove_proc_entry(PROC_TOSHIBA
, acpi_root_dir
);
1782 static void __exit
toshiba_acpi_exit(void)
1784 acpi_bus_unregister_driver(&toshiba_acpi_driver
);
1785 if (toshiba_proc_dir
)
1786 remove_proc_entry(PROC_TOSHIBA
, acpi_root_dir
);
1789 module_init(toshiba_acpi_init
);
1790 module_exit(toshiba_acpi_exit
);