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
8 * Copyright (C) 2014 Azael Avalos
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 * The devolpment page for this driver is located at
26 * http://memebeam.org/toys/ToshibaAcpiDriver.
29 * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
30 * engineering the Windows drivers
31 * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
32 * Rob Miller - TV out and hotkeys help
39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
41 #define TOSHIBA_ACPI_VERSION "0.20"
42 #define PROC_INTERFACE_VERSION 1
44 #include <linux/kernel.h>
45 #include <linux/module.h>
46 #include <linux/init.h>
47 #include <linux/types.h>
48 #include <linux/proc_fs.h>
49 #include <linux/seq_file.h>
50 #include <linux/backlight.h>
51 #include <linux/rfkill.h>
52 #include <linux/input.h>
53 #include <linux/input/sparse-keymap.h>
54 #include <linux/leds.h>
55 #include <linux/slab.h>
56 #include <linux/workqueue.h>
57 #include <linux/i8042.h>
58 #include <linux/acpi.h>
59 #include <linux/dmi.h>
60 #include <asm/uaccess.h>
62 MODULE_AUTHOR("John Belmonte");
63 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
64 MODULE_LICENSE("GPL");
66 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
68 /* Scan code for Fn key on TOS1900 models */
69 #define TOS1900_FN_SCAN 0x6e
71 /* Toshiba ACPI method paths */
72 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX"
74 /* Toshiba HCI interface definitions
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.
83 * SCI stands for "System Configuration Interface" which aim is to
84 * conceal differences in hardware between different models.
90 #define HCI_SET 0xff00
91 #define HCI_GET 0xfe00
92 #define SCI_OPEN 0xf100
93 #define SCI_CLOSE 0xf200
94 #define SCI_GET 0xf300
95 #define SCI_SET 0xf400
98 #define HCI_SUCCESS 0x0000
99 #define HCI_FAILURE 0x1000
100 #define HCI_NOT_SUPPORTED 0x8000
101 #define HCI_EMPTY 0x8c00
102 #define HCI_DATA_NOT_AVAILABLE 0x8d20
103 #define HCI_NOT_INITIALIZED 0x8d50
104 #define SCI_OPEN_CLOSE_OK 0x0044
105 #define SCI_ALREADY_OPEN 0x8100
106 #define SCI_NOT_OPENED 0x8200
107 #define SCI_INPUT_DATA_ERROR 0x8300
108 #define SCI_NOT_PRESENT 0x8600
111 #define HCI_FAN 0x0004
112 #define HCI_TR_BACKLIGHT 0x0005
113 #define HCI_SYSTEM_EVENT 0x0016
114 #define HCI_VIDEO_OUT 0x001c
115 #define HCI_HOTKEY_EVENT 0x001e
116 #define HCI_LCD_BRIGHTNESS 0x002a
117 #define HCI_WIRELESS 0x0056
118 #define HCI_ACCELEROMETER 0x006d
119 #define HCI_KBD_ILLUMINATION 0x0095
120 #define HCI_ECO_MODE 0x0097
121 #define HCI_ACCELEROMETER2 0x00a6
122 #define SCI_ILLUMINATION 0x014e
123 #define SCI_KBD_ILLUM_STATUS 0x015c
124 #define SCI_TOUCHPAD 0x050e
126 /* field definitions */
127 #define HCI_ACCEL_MASK 0x7fff
128 #define HCI_HOTKEY_DISABLE 0x0b
129 #define HCI_HOTKEY_ENABLE 0x09
130 #define HCI_LCD_BRIGHTNESS_BITS 3
131 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS)
132 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS)
133 #define HCI_MISC_SHIFT 0x10
134 #define HCI_VIDEO_OUT_LCD 0x1
135 #define HCI_VIDEO_OUT_CRT 0x2
136 #define HCI_VIDEO_OUT_TV 0x4
137 #define HCI_WIRELESS_KILL_SWITCH 0x01
138 #define HCI_WIRELESS_BT_PRESENT 0x0f
139 #define HCI_WIRELESS_BT_ATTACH 0x40
140 #define HCI_WIRELESS_BT_POWER 0x80
141 #define SCI_KBD_MODE_FNZ 0x1
142 #define SCI_KBD_MODE_AUTO 0x2
144 struct toshiba_acpi_dev
{
145 struct acpi_device
*acpi_dev
;
146 const char *method_hci
;
147 struct rfkill
*bt_rfk
;
148 struct input_dev
*hotkey_dev
;
149 struct work_struct hotkey_work
;
150 struct backlight_device
*backlight_dev
;
151 struct led_classdev led_dev
;
152 struct led_classdev kbd_led
;
153 struct led_classdev eco_led
;
161 unsigned int illumination_supported
:1;
162 unsigned int video_supported
:1;
163 unsigned int fan_supported
:1;
164 unsigned int system_event_supported
:1;
165 unsigned int ntfy_supported
:1;
166 unsigned int info_supported
:1;
167 unsigned int tr_backlight_supported
:1;
168 unsigned int kbd_illum_supported
:1;
169 unsigned int kbd_led_registered
:1;
170 unsigned int touchpad_supported
:1;
171 unsigned int eco_supported
:1;
172 unsigned int accelerometer_supported
:1;
173 unsigned int sysfs_created
:1;
178 static struct toshiba_acpi_dev
*toshiba_acpi
;
180 static const struct acpi_device_id toshiba_device_ids
[] = {
186 MODULE_DEVICE_TABLE(acpi
, toshiba_device_ids
);
188 static const struct key_entry toshiba_acpi_keymap
[] = {
189 { KE_KEY
, 0x9e, { KEY_RFKILL
} },
190 { KE_KEY
, 0x101, { KEY_MUTE
} },
191 { KE_KEY
, 0x102, { KEY_ZOOMOUT
} },
192 { KE_KEY
, 0x103, { KEY_ZOOMIN
} },
193 { KE_KEY
, 0x12c, { KEY_KBDILLUMTOGGLE
} },
194 { KE_KEY
, 0x139, { KEY_ZOOMRESET
} },
195 { KE_KEY
, 0x13b, { KEY_COFFEE
} },
196 { KE_KEY
, 0x13c, { KEY_BATTERY
} },
197 { KE_KEY
, 0x13d, { KEY_SLEEP
} },
198 { KE_KEY
, 0x13e, { KEY_SUSPEND
} },
199 { KE_KEY
, 0x13f, { KEY_SWITCHVIDEOMODE
} },
200 { KE_KEY
, 0x140, { KEY_BRIGHTNESSDOWN
} },
201 { KE_KEY
, 0x141, { KEY_BRIGHTNESSUP
} },
202 { KE_KEY
, 0x142, { KEY_WLAN
} },
203 { KE_KEY
, 0x143, { KEY_TOUCHPAD_TOGGLE
} },
204 { KE_KEY
, 0x17f, { KEY_FN
} },
205 { KE_KEY
, 0xb05, { KEY_PROG2
} },
206 { KE_KEY
, 0xb06, { KEY_WWW
} },
207 { KE_KEY
, 0xb07, { KEY_MAIL
} },
208 { KE_KEY
, 0xb30, { KEY_STOP
} },
209 { KE_KEY
, 0xb31, { KEY_PREVIOUSSONG
} },
210 { KE_KEY
, 0xb32, { KEY_NEXTSONG
} },
211 { KE_KEY
, 0xb33, { KEY_PLAYPAUSE
} },
212 { KE_KEY
, 0xb5a, { KEY_MEDIA
} },
213 { KE_IGNORE
, 0x1430, { KEY_RESERVED
} },
217 /* alternative keymap */
218 static const struct dmi_system_id toshiba_alt_keymap_dmi
[] = {
221 DMI_MATCH(DMI_SYS_VENDOR
, "TOSHIBA"),
222 DMI_MATCH(DMI_PRODUCT_NAME
, "Satellite M840"),
227 DMI_MATCH(DMI_SYS_VENDOR
, "TOSHIBA"),
228 DMI_MATCH(DMI_PRODUCT_NAME
, "Qosmio X75-A"),
234 static const struct key_entry toshiba_acpi_alt_keymap
[] = {
235 { KE_KEY
, 0x157, { KEY_MUTE
} },
236 { KE_KEY
, 0x102, { KEY_ZOOMOUT
} },
237 { KE_KEY
, 0x103, { KEY_ZOOMIN
} },
238 { KE_KEY
, 0x12c, { KEY_KBDILLUMTOGGLE
} },
239 { KE_KEY
, 0x139, { KEY_ZOOMRESET
} },
240 { KE_KEY
, 0x13e, { KEY_SWITCHVIDEOMODE
} },
241 { KE_KEY
, 0x13c, { KEY_BRIGHTNESSDOWN
} },
242 { KE_KEY
, 0x13d, { KEY_BRIGHTNESSUP
} },
243 { KE_KEY
, 0x158, { KEY_WLAN
} },
244 { KE_KEY
, 0x13f, { KEY_TOUCHPAD_TOGGLE
} },
251 static __inline__
void _set_bit(u32
* word
, u32 mask
, int value
)
253 *word
= (*word
& ~mask
) | (mask
* value
);
256 /* acpi interface wrappers
259 static int write_acpi_int(const char *methodName
, int val
)
263 status
= acpi_execute_simple_method(NULL
, (char *)methodName
, val
);
264 return (status
== AE_OK
) ? 0 : -EIO
;
267 /* Perform a raw HCI call. Here we don't care about input or output buffer
270 static acpi_status
hci_raw(struct toshiba_acpi_dev
*dev
,
271 const u32 in
[HCI_WORDS
], u32 out
[HCI_WORDS
])
273 struct acpi_object_list params
;
274 union acpi_object in_objs
[HCI_WORDS
];
275 struct acpi_buffer results
;
276 union acpi_object out_objs
[HCI_WORDS
+ 1];
280 params
.count
= HCI_WORDS
;
281 params
.pointer
= in_objs
;
282 for (i
= 0; i
< HCI_WORDS
; ++i
) {
283 in_objs
[i
].type
= ACPI_TYPE_INTEGER
;
284 in_objs
[i
].integer
.value
= in
[i
];
287 results
.length
= sizeof(out_objs
);
288 results
.pointer
= out_objs
;
290 status
= acpi_evaluate_object(dev
->acpi_dev
->handle
,
291 (char *)dev
->method_hci
, ¶ms
,
293 if ((status
== AE_OK
) && (out_objs
->package
.count
<= HCI_WORDS
)) {
294 for (i
= 0; i
< out_objs
->package
.count
; ++i
) {
295 out
[i
] = out_objs
->package
.elements
[i
].integer
.value
;
302 /* common hci tasks (get or set one or two value)
304 * In addition to the ACPI status, the HCI system returns a result which
305 * may be useful (such as "not supported").
308 static acpi_status
hci_write1(struct toshiba_acpi_dev
*dev
, u32 reg
,
309 u32 in1
, u32
*result
)
311 u32 in
[HCI_WORDS
] = { HCI_SET
, reg
, in1
, 0, 0, 0 };
313 acpi_status status
= hci_raw(dev
, in
, out
);
314 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
318 static acpi_status
hci_read1(struct toshiba_acpi_dev
*dev
, u32 reg
,
319 u32
*out1
, u32
*result
)
321 u32 in
[HCI_WORDS
] = { HCI_GET
, reg
, 0, 0, 0, 0 };
323 acpi_status status
= hci_raw(dev
, in
, out
);
325 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
329 static acpi_status
hci_write2(struct toshiba_acpi_dev
*dev
, u32 reg
,
330 u32 in1
, u32 in2
, u32
*result
)
332 u32 in
[HCI_WORDS
] = { HCI_SET
, reg
, in1
, in2
, 0, 0 };
334 acpi_status status
= hci_raw(dev
, in
, out
);
335 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
339 static acpi_status
hci_read2(struct toshiba_acpi_dev
*dev
, u32 reg
,
340 u32
*out1
, u32
*out2
, u32
*result
)
342 u32 in
[HCI_WORDS
] = { HCI_GET
, reg
, *out1
, *out2
, 0, 0 };
344 acpi_status status
= hci_raw(dev
, in
, out
);
347 *result
= (status
== AE_OK
) ? out
[0] : HCI_FAILURE
;
354 static int sci_open(struct toshiba_acpi_dev
*dev
)
356 u32 in
[HCI_WORDS
] = { SCI_OPEN
, 0, 0, 0, 0, 0 };
360 status
= hci_raw(dev
, in
, out
);
361 if (ACPI_FAILURE(status
) || out
[0] == HCI_FAILURE
) {
362 pr_err("ACPI call to open SCI failed\n");
366 if (out
[0] == SCI_OPEN_CLOSE_OK
) {
368 } else if (out
[0] == SCI_ALREADY_OPEN
) {
369 pr_info("Toshiba SCI already opened\n");
371 } else if (out
[0] == SCI_NOT_PRESENT
) {
372 pr_info("Toshiba SCI is not present\n");
378 static void sci_close(struct toshiba_acpi_dev
*dev
)
380 u32 in
[HCI_WORDS
] = { SCI_CLOSE
, 0, 0, 0, 0, 0 };
384 status
= hci_raw(dev
, in
, out
);
385 if (ACPI_FAILURE(status
) || out
[0] == HCI_FAILURE
) {
386 pr_err("ACPI call to close SCI failed\n");
390 if (out
[0] == SCI_OPEN_CLOSE_OK
)
392 else if (out
[0] == SCI_NOT_OPENED
)
393 pr_info("Toshiba SCI not opened\n");
394 else if (out
[0] == SCI_NOT_PRESENT
)
395 pr_info("Toshiba SCI is not present\n");
398 static acpi_status
sci_read(struct toshiba_acpi_dev
*dev
, u32 reg
,
399 u32
*out1
, u32
*result
)
401 u32 in
[HCI_WORDS
] = { SCI_GET
, reg
, 0, 0, 0, 0 };
403 acpi_status status
= hci_raw(dev
, in
, out
);
405 *result
= (ACPI_SUCCESS(status
)) ? out
[0] : HCI_FAILURE
;
409 static acpi_status
sci_write(struct toshiba_acpi_dev
*dev
, u32 reg
,
410 u32 in1
, u32
*result
)
412 u32 in
[HCI_WORDS
] = { SCI_SET
, reg
, in1
, 0, 0, 0 };
414 acpi_status status
= hci_raw(dev
, in
, out
);
415 *result
= (ACPI_SUCCESS(status
)) ? out
[0] : HCI_FAILURE
;
419 /* Illumination support */
420 static int toshiba_illumination_available(struct toshiba_acpi_dev
*dev
)
422 u32 in
[HCI_WORDS
] = { SCI_GET
, SCI_ILLUMINATION
, 0, 0, 0, 0 };
429 status
= hci_raw(dev
, in
, out
);
431 if (ACPI_FAILURE(status
) || out
[0] == HCI_FAILURE
) {
432 pr_err("ACPI call to query Illumination support failed\n");
434 } else if (out
[0] == HCI_NOT_SUPPORTED
|| out
[1] != 1) {
435 pr_info("Illumination device not available\n");
442 static void toshiba_illumination_set(struct led_classdev
*cdev
,
443 enum led_brightness brightness
)
445 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
446 struct toshiba_acpi_dev
, led_dev
);
450 /* First request : initialize communication. */
454 /* Switch the illumination on/off */
455 state
= brightness
? 1 : 0;
456 status
= sci_write(dev
, SCI_ILLUMINATION
, state
, &result
);
458 if (ACPI_FAILURE(status
)) {
459 pr_err("ACPI call for illumination failed\n");
461 } else if (result
== HCI_NOT_SUPPORTED
) {
462 pr_info("Illumination not supported\n");
467 static enum led_brightness
toshiba_illumination_get(struct led_classdev
*cdev
)
469 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
470 struct toshiba_acpi_dev
, led_dev
);
474 /*Â First request : initialize communication. */
478 /* Check the illumination */
479 status
= sci_read(dev
, SCI_ILLUMINATION
, &state
, &result
);
481 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
482 pr_err("ACPI call for illumination failed\n");
484 } else if (result
== HCI_NOT_SUPPORTED
) {
485 pr_info("Illumination not supported\n");
489 return state
? LED_FULL
: LED_OFF
;
492 /* KBD Illumination */
493 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev
*dev
, u32 time
)
501 status
= sci_write(dev
, SCI_KBD_ILLUM_STATUS
, time
, &result
);
503 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
504 pr_err("ACPI call to set KBD backlight status failed\n");
506 } else if (result
== HCI_NOT_SUPPORTED
) {
507 pr_info("Keyboard backlight status not supported\n");
514 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev
*dev
, u32
*time
)
522 status
= sci_read(dev
, SCI_KBD_ILLUM_STATUS
, time
, &result
);
524 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
525 pr_err("ACPI call to get KBD backlight status failed\n");
527 } else if (result
== HCI_NOT_SUPPORTED
) {
528 pr_info("Keyboard backlight status not supported\n");
535 static enum led_brightness
toshiba_kbd_backlight_get(struct led_classdev
*cdev
)
537 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
538 struct toshiba_acpi_dev
, kbd_led
);
542 /* Check the keyboard backlight state */
543 status
= hci_read1(dev
, HCI_KBD_ILLUMINATION
, &state
, &result
);
544 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
545 pr_err("ACPI call to get the keyboard backlight failed\n");
547 } else if (result
== HCI_NOT_SUPPORTED
) {
548 pr_info("Keyboard backlight not supported\n");
552 return state
? LED_FULL
: LED_OFF
;
555 static void toshiba_kbd_backlight_set(struct led_classdev
*cdev
,
556 enum led_brightness brightness
)
558 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
559 struct toshiba_acpi_dev
, kbd_led
);
563 /* Set the keyboard backlight state */
564 state
= brightness
? 1 : 0;
565 status
= hci_write1(dev
, HCI_KBD_ILLUMINATION
, state
, &result
);
566 if (ACPI_FAILURE(status
) || result
== SCI_INPUT_DATA_ERROR
) {
567 pr_err("ACPI call to set KBD Illumination mode failed\n");
569 } else if (result
== HCI_NOT_SUPPORTED
) {
570 pr_info("Keyboard backlight not supported\n");
575 /* TouchPad support */
576 static int toshiba_touchpad_set(struct toshiba_acpi_dev
*dev
, u32 state
)
584 status
= sci_write(dev
, SCI_TOUCHPAD
, state
, &result
);
586 if (ACPI_FAILURE(status
)) {
587 pr_err("ACPI call to set the touchpad failed\n");
589 } else if (result
== HCI_NOT_SUPPORTED
) {
596 static int toshiba_touchpad_get(struct toshiba_acpi_dev
*dev
, u32
*state
)
604 status
= sci_read(dev
, SCI_TOUCHPAD
, state
, &result
);
606 if (ACPI_FAILURE(status
)) {
607 pr_err("ACPI call to query the touchpad failed\n");
609 } else if (result
== HCI_NOT_SUPPORTED
) {
616 /* Eco Mode support */
617 static int toshiba_eco_mode_available(struct toshiba_acpi_dev
*dev
)
620 u32 in
[HCI_WORDS
] = { HCI_GET
, HCI_ECO_MODE
, 0, 1, 0, 0 };
623 status
= hci_raw(dev
, in
, out
);
624 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
625 pr_info("ACPI call to get ECO led failed\n");
632 static enum led_brightness
toshiba_eco_mode_get_status(struct led_classdev
*cdev
)
634 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
635 struct toshiba_acpi_dev
, eco_led
);
636 u32 in
[HCI_WORDS
] = { HCI_GET
, HCI_ECO_MODE
, 0, 1, 0, 0 };
640 status
= hci_raw(dev
, in
, out
);
641 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
642 pr_err("ACPI call to get ECO led failed\n");
646 return out
[2] ? LED_FULL
: LED_OFF
;
649 static void toshiba_eco_mode_set_status(struct led_classdev
*cdev
,
650 enum led_brightness brightness
)
652 struct toshiba_acpi_dev
*dev
= container_of(cdev
,
653 struct toshiba_acpi_dev
, eco_led
);
654 u32 in
[HCI_WORDS
] = { HCI_SET
, HCI_ECO_MODE
, 0, 1, 0, 0 };
658 /* Switch the Eco Mode led on/off */
659 in
[2] = (brightness
) ? 1 : 0;
660 status
= hci_raw(dev
, in
, out
);
661 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
662 pr_err("ACPI call to set ECO led failed\n");
667 /* Accelerometer support */
668 static int toshiba_accelerometer_supported(struct toshiba_acpi_dev
*dev
)
670 u32 in
[HCI_WORDS
] = { HCI_GET
, HCI_ACCELEROMETER2
, 0, 0, 0, 0 };
674 /* Check if the accelerometer call exists,
675 * this call also serves as initialization
677 status
= hci_raw(dev
, in
, out
);
678 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
679 pr_err("ACPI call to query the accelerometer failed\n");
681 } else if (out
[0] == HCI_DATA_NOT_AVAILABLE
||
682 out
[0] == HCI_NOT_INITIALIZED
) {
683 pr_err("Accelerometer not initialized\n");
685 } else if (out
[0] == HCI_NOT_SUPPORTED
) {
686 pr_info("Accelerometer not supported\n");
693 static int toshiba_accelerometer_get(struct toshiba_acpi_dev
*dev
,
696 u32 in
[HCI_WORDS
] = { HCI_GET
, HCI_ACCELEROMETER
, 0, 1, 0, 0 };
700 /* Check the Accelerometer status */
701 status
= hci_raw(dev
, in
, out
);
702 if (ACPI_FAILURE(status
) || out
[0] == SCI_INPUT_DATA_ERROR
) {
703 pr_err("ACPI call to query the accelerometer failed\n");
713 /* Bluetooth rfkill handlers */
715 static u32
hci_get_bt_present(struct toshiba_acpi_dev
*dev
, bool *present
)
722 hci_read2(dev
, HCI_WIRELESS
, &value
, &value2
, &hci_result
);
723 if (hci_result
== HCI_SUCCESS
)
724 *present
= (value
& HCI_WIRELESS_BT_PRESENT
) ? true : false;
729 static u32
hci_get_radio_state(struct toshiba_acpi_dev
*dev
, bool *radio_state
)
736 hci_read2(dev
, HCI_WIRELESS
, &value
, &value2
, &hci_result
);
738 *radio_state
= value
& HCI_WIRELESS_KILL_SWITCH
;
742 static int bt_rfkill_set_block(void *data
, bool blocked
)
744 struct toshiba_acpi_dev
*dev
= data
;
745 u32 result1
, result2
;
750 value
= (blocked
== false);
752 mutex_lock(&dev
->mutex
);
753 if (hci_get_radio_state(dev
, &radio_state
) != HCI_SUCCESS
) {
763 hci_write2(dev
, HCI_WIRELESS
, value
, HCI_WIRELESS_BT_POWER
, &result1
);
764 hci_write2(dev
, HCI_WIRELESS
, value
, HCI_WIRELESS_BT_ATTACH
, &result2
);
766 if (result1
!= HCI_SUCCESS
|| result2
!= HCI_SUCCESS
)
771 mutex_unlock(&dev
->mutex
);
775 static void bt_rfkill_poll(struct rfkill
*rfkill
, void *data
)
780 struct toshiba_acpi_dev
*dev
= data
;
782 mutex_lock(&dev
->mutex
);
784 hci_result
= hci_get_radio_state(dev
, &value
);
785 if (hci_result
!= HCI_SUCCESS
) {
786 /* Can't do anything useful */
787 mutex_unlock(&dev
->mutex
);
791 new_rfk_state
= value
;
793 mutex_unlock(&dev
->mutex
);
795 if (rfkill_set_hw_state(rfkill
, !new_rfk_state
))
796 bt_rfkill_set_block(data
, true);
799 static const struct rfkill_ops toshiba_rfk_ops
= {
800 .set_block
= bt_rfkill_set_block
,
801 .poll
= bt_rfkill_poll
,
804 static int get_tr_backlight_status(struct toshiba_acpi_dev
*dev
, bool *enabled
)
809 hci_read1(dev
, HCI_TR_BACKLIGHT
, &status
, &hci_result
);
811 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
814 static int set_tr_backlight_status(struct toshiba_acpi_dev
*dev
, bool enable
)
819 hci_write1(dev
, HCI_TR_BACKLIGHT
, value
, &hci_result
);
820 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
823 static struct proc_dir_entry
*toshiba_proc_dir
/*= 0*/ ;
825 static int __get_lcd_brightness(struct toshiba_acpi_dev
*dev
)
831 if (dev
->tr_backlight_supported
) {
833 int ret
= get_tr_backlight_status(dev
, &enabled
);
841 hci_read1(dev
, HCI_LCD_BRIGHTNESS
, &value
, &hci_result
);
842 if (hci_result
== HCI_SUCCESS
)
843 return brightness
+ (value
>> HCI_LCD_BRIGHTNESS_SHIFT
);
848 static int get_lcd_brightness(struct backlight_device
*bd
)
850 struct toshiba_acpi_dev
*dev
= bl_get_data(bd
);
851 return __get_lcd_brightness(dev
);
854 static int lcd_proc_show(struct seq_file
*m
, void *v
)
856 struct toshiba_acpi_dev
*dev
= m
->private;
860 if (!dev
->backlight_dev
)
863 levels
= dev
->backlight_dev
->props
.max_brightness
+ 1;
864 value
= get_lcd_brightness(dev
->backlight_dev
);
866 seq_printf(m
, "brightness: %d\n", value
);
867 seq_printf(m
, "brightness_levels: %d\n", levels
);
871 pr_err("Error reading LCD brightness\n");
875 static int lcd_proc_open(struct inode
*inode
, struct file
*file
)
877 return single_open(file
, lcd_proc_show
, PDE_DATA(inode
));
880 static int set_lcd_brightness(struct toshiba_acpi_dev
*dev
, int value
)
882 u32 in
[HCI_WORDS
] = { HCI_SET
, HCI_LCD_BRIGHTNESS
, 0, 0, 0, 0 };
886 if (dev
->tr_backlight_supported
) {
887 bool enable
= !value
;
888 int ret
= set_tr_backlight_status(dev
, enable
);
895 in
[2] = value
<< HCI_LCD_BRIGHTNESS_SHIFT
;
896 status
= hci_raw(dev
, in
, out
);
897 if (ACPI_FAILURE(status
) || out
[0] == HCI_FAILURE
) {
898 pr_err("ACPI call to set brightness failed");
901 /* Extra check for "incomplete" backlight method, where the AML code
902 * doesn't check for HCI_SET or HCI_GET and returns HCI_SUCCESS,
903 * the actual brightness, and in some cases the max brightness.
905 if (out
[2] > 0 || out
[3] == 0xE000)
908 return out
[0] == HCI_SUCCESS
? 0 : -EIO
;
911 static int set_lcd_status(struct backlight_device
*bd
)
913 struct toshiba_acpi_dev
*dev
= bl_get_data(bd
);
914 return set_lcd_brightness(dev
, bd
->props
.brightness
);
917 static ssize_t
lcd_proc_write(struct file
*file
, const char __user
*buf
,
918 size_t count
, loff_t
*pos
)
920 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
925 int levels
= dev
->backlight_dev
->props
.max_brightness
+ 1;
927 len
= min(count
, sizeof(cmd
) - 1);
928 if (copy_from_user(cmd
, buf
, len
))
932 if (sscanf(cmd
, " brightness : %i", &value
) == 1 &&
933 value
>= 0 && value
< levels
) {
934 ret
= set_lcd_brightness(dev
, value
);
943 static const struct file_operations lcd_proc_fops
= {
944 .owner
= THIS_MODULE
,
945 .open
= lcd_proc_open
,
948 .release
= single_release
,
949 .write
= lcd_proc_write
,
952 static int get_video_status(struct toshiba_acpi_dev
*dev
, u32
*status
)
956 hci_read1(dev
, HCI_VIDEO_OUT
, status
, &hci_result
);
957 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
960 static int video_proc_show(struct seq_file
*m
, void *v
)
962 struct toshiba_acpi_dev
*dev
= m
->private;
966 ret
= get_video_status(dev
, &value
);
968 int is_lcd
= (value
& HCI_VIDEO_OUT_LCD
) ? 1 : 0;
969 int is_crt
= (value
& HCI_VIDEO_OUT_CRT
) ? 1 : 0;
970 int is_tv
= (value
& HCI_VIDEO_OUT_TV
) ? 1 : 0;
971 seq_printf(m
, "lcd_out: %d\n", is_lcd
);
972 seq_printf(m
, "crt_out: %d\n", is_crt
);
973 seq_printf(m
, "tv_out: %d\n", is_tv
);
979 static int video_proc_open(struct inode
*inode
, struct file
*file
)
981 return single_open(file
, video_proc_show
, PDE_DATA(inode
));
984 static ssize_t
video_proc_write(struct file
*file
, const char __user
*buf
,
985 size_t count
, loff_t
*pos
)
987 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
997 cmd
= kmalloc(count
+ 1, GFP_KERNEL
);
1000 if (copy_from_user(cmd
, buf
, count
)) {
1008 /* scan expression. Multiple expressions may be delimited with ;
1010 * NOTE: to keep scanning simple, invalid fields are ignored
1013 if (sscanf(buffer
, " lcd_out : %i", &value
) == 1)
1014 lcd_out
= value
& 1;
1015 else if (sscanf(buffer
, " crt_out : %i", &value
) == 1)
1016 crt_out
= value
& 1;
1017 else if (sscanf(buffer
, " tv_out : %i", &value
) == 1)
1019 /* advance to one character past the next ; */
1024 while (remain
&& *(buffer
- 1) != ';');
1029 ret
= get_video_status(dev
, &video_out
);
1031 unsigned int new_video_out
= video_out
;
1033 _set_bit(&new_video_out
, HCI_VIDEO_OUT_LCD
, lcd_out
);
1035 _set_bit(&new_video_out
, HCI_VIDEO_OUT_CRT
, crt_out
);
1037 _set_bit(&new_video_out
, HCI_VIDEO_OUT_TV
, tv_out
);
1038 /* To avoid unnecessary video disruption, only write the new
1039 * video setting if something changed. */
1040 if (new_video_out
!= video_out
)
1041 ret
= write_acpi_int(METHOD_VIDEO_OUT
, new_video_out
);
1044 return ret
? ret
: count
;
1047 static const struct file_operations video_proc_fops
= {
1048 .owner
= THIS_MODULE
,
1049 .open
= video_proc_open
,
1051 .llseek
= seq_lseek
,
1052 .release
= single_release
,
1053 .write
= video_proc_write
,
1056 static int get_fan_status(struct toshiba_acpi_dev
*dev
, u32
*status
)
1060 hci_read1(dev
, HCI_FAN
, status
, &hci_result
);
1061 return hci_result
== HCI_SUCCESS
? 0 : -EIO
;
1064 static int fan_proc_show(struct seq_file
*m
, void *v
)
1066 struct toshiba_acpi_dev
*dev
= m
->private;
1070 ret
= get_fan_status(dev
, &value
);
1072 seq_printf(m
, "running: %d\n", (value
> 0));
1073 seq_printf(m
, "force_on: %d\n", dev
->force_fan
);
1079 static int fan_proc_open(struct inode
*inode
, struct file
*file
)
1081 return single_open(file
, fan_proc_show
, PDE_DATA(inode
));
1084 static ssize_t
fan_proc_write(struct file
*file
, const char __user
*buf
,
1085 size_t count
, loff_t
*pos
)
1087 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
1093 len
= min(count
, sizeof(cmd
) - 1);
1094 if (copy_from_user(cmd
, buf
, len
))
1098 if (sscanf(cmd
, " force_on : %i", &value
) == 1 &&
1099 value
>= 0 && value
<= 1) {
1100 hci_write1(dev
, HCI_FAN
, value
, &hci_result
);
1101 if (hci_result
!= HCI_SUCCESS
)
1104 dev
->force_fan
= value
;
1112 static const struct file_operations fan_proc_fops
= {
1113 .owner
= THIS_MODULE
,
1114 .open
= fan_proc_open
,
1116 .llseek
= seq_lseek
,
1117 .release
= single_release
,
1118 .write
= fan_proc_write
,
1121 static int keys_proc_show(struct seq_file
*m
, void *v
)
1123 struct toshiba_acpi_dev
*dev
= m
->private;
1127 if (!dev
->key_event_valid
&& dev
->system_event_supported
) {
1128 hci_read1(dev
, HCI_SYSTEM_EVENT
, &value
, &hci_result
);
1129 if (hci_result
== HCI_SUCCESS
) {
1130 dev
->key_event_valid
= 1;
1131 dev
->last_key_event
= value
;
1132 } else if (hci_result
== HCI_EMPTY
) {
1133 /* better luck next time */
1134 } else if (hci_result
== HCI_NOT_SUPPORTED
) {
1135 /* This is a workaround for an unresolved issue on
1136 * some machines where system events sporadically
1137 * become disabled. */
1138 hci_write1(dev
, HCI_SYSTEM_EVENT
, 1, &hci_result
);
1139 pr_notice("Re-enabled hotkeys\n");
1141 pr_err("Error reading hotkey status\n");
1146 seq_printf(m
, "hotkey_ready: %d\n", dev
->key_event_valid
);
1147 seq_printf(m
, "hotkey: 0x%04x\n", dev
->last_key_event
);
1151 static int keys_proc_open(struct inode
*inode
, struct file
*file
)
1153 return single_open(file
, keys_proc_show
, PDE_DATA(inode
));
1156 static ssize_t
keys_proc_write(struct file
*file
, const char __user
*buf
,
1157 size_t count
, loff_t
*pos
)
1159 struct toshiba_acpi_dev
*dev
= PDE_DATA(file_inode(file
));
1164 len
= min(count
, sizeof(cmd
) - 1);
1165 if (copy_from_user(cmd
, buf
, len
))
1169 if (sscanf(cmd
, " hotkey_ready : %i", &value
) == 1 && value
== 0) {
1170 dev
->key_event_valid
= 0;
1178 static const struct file_operations keys_proc_fops
= {
1179 .owner
= THIS_MODULE
,
1180 .open
= keys_proc_open
,
1182 .llseek
= seq_lseek
,
1183 .release
= single_release
,
1184 .write
= keys_proc_write
,
1187 static int version_proc_show(struct seq_file
*m
, void *v
)
1189 seq_printf(m
, "driver: %s\n", TOSHIBA_ACPI_VERSION
);
1190 seq_printf(m
, "proc_interface: %d\n", PROC_INTERFACE_VERSION
);
1194 static int version_proc_open(struct inode
*inode
, struct file
*file
)
1196 return single_open(file
, version_proc_show
, PDE_DATA(inode
));
1199 static const struct file_operations version_proc_fops
= {
1200 .owner
= THIS_MODULE
,
1201 .open
= version_proc_open
,
1203 .llseek
= seq_lseek
,
1204 .release
= single_release
,
1207 /* proc and module init
1210 #define PROC_TOSHIBA "toshiba"
1212 static void create_toshiba_proc_entries(struct toshiba_acpi_dev
*dev
)
1214 if (dev
->backlight_dev
)
1215 proc_create_data("lcd", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1216 &lcd_proc_fops
, dev
);
1217 if (dev
->video_supported
)
1218 proc_create_data("video", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1219 &video_proc_fops
, dev
);
1220 if (dev
->fan_supported
)
1221 proc_create_data("fan", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1222 &fan_proc_fops
, dev
);
1223 if (dev
->hotkey_dev
)
1224 proc_create_data("keys", S_IRUGO
| S_IWUSR
, toshiba_proc_dir
,
1225 &keys_proc_fops
, dev
);
1226 proc_create_data("version", S_IRUGO
, toshiba_proc_dir
,
1227 &version_proc_fops
, dev
);
1230 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev
*dev
)
1232 if (dev
->backlight_dev
)
1233 remove_proc_entry("lcd", toshiba_proc_dir
);
1234 if (dev
->video_supported
)
1235 remove_proc_entry("video", toshiba_proc_dir
);
1236 if (dev
->fan_supported
)
1237 remove_proc_entry("fan", toshiba_proc_dir
);
1238 if (dev
->hotkey_dev
)
1239 remove_proc_entry("keys", toshiba_proc_dir
);
1240 remove_proc_entry("version", toshiba_proc_dir
);
1243 static const struct backlight_ops toshiba_backlight_data
= {
1244 .options
= BL_CORE_SUSPENDRESUME
,
1245 .get_brightness
= get_lcd_brightness
,
1246 .update_status
= set_lcd_status
,
1253 static ssize_t
toshiba_kbd_bl_mode_store(struct device
*dev
,
1254 struct device_attribute
*attr
,
1255 const char *buf
, size_t count
)
1257 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1261 if (sscanf(buf
, "%i", &mode
) != 1 && (mode
!= 2 || mode
!= 1))
1264 /* Set the Keyboard Backlight Mode where:
1265 * Mode - Auto (2) | FN-Z (1)
1266 * Auto - KBD backlight turns off automatically in given time
1267 * FN-Z - KBD backlight "toggles" when hotkey pressed
1269 if (mode
!= -1 && toshiba
->kbd_mode
!= mode
) {
1270 time
= toshiba
->kbd_time
<< HCI_MISC_SHIFT
;
1271 time
= time
+ toshiba
->kbd_mode
;
1272 if (toshiba_kbd_illum_status_set(toshiba
, time
) < 0)
1274 toshiba
->kbd_mode
= mode
;
1280 static ssize_t
toshiba_kbd_bl_mode_show(struct device
*dev
,
1281 struct device_attribute
*attr
,
1284 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1287 if (toshiba_kbd_illum_status_get(toshiba
, &time
) < 0)
1290 return sprintf(buf
, "%i\n", time
& 0x07);
1293 static ssize_t
toshiba_kbd_bl_timeout_store(struct device
*dev
,
1294 struct device_attribute
*attr
,
1295 const char *buf
, size_t count
)
1297 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1300 if (sscanf(buf
, "%i", &time
) != 1 && (time
< 0 || time
> 60))
1303 /* Set the Keyboard Backlight Timeout: 0-60 seconds */
1304 if (time
!= -1 && toshiba
->kbd_time
!= time
) {
1305 time
= time
<< HCI_MISC_SHIFT
;
1306 time
= (toshiba
->kbd_mode
== SCI_KBD_MODE_AUTO
) ?
1307 time
+ 1 : time
+ 2;
1308 if (toshiba_kbd_illum_status_set(toshiba
, time
) < 0)
1310 toshiba
->kbd_time
= time
>> HCI_MISC_SHIFT
;
1316 static ssize_t
toshiba_kbd_bl_timeout_show(struct device
*dev
,
1317 struct device_attribute
*attr
,
1320 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1323 if (toshiba_kbd_illum_status_get(toshiba
, &time
) < 0)
1326 return sprintf(buf
, "%i\n", time
>> HCI_MISC_SHIFT
);
1329 static ssize_t
toshiba_touchpad_store(struct device
*dev
,
1330 struct device_attribute
*attr
,
1331 const char *buf
, size_t count
)
1333 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1336 /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */
1337 if (sscanf(buf
, "%i", &state
) == 1 && (state
== 0 || state
== 1)) {
1338 if (toshiba_touchpad_set(toshiba
, state
) < 0)
1345 static ssize_t
toshiba_touchpad_show(struct device
*dev
,
1346 struct device_attribute
*attr
, char *buf
)
1348 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1352 ret
= toshiba_touchpad_get(toshiba
, &state
);
1356 return sprintf(buf
, "%i\n", state
);
1359 static ssize_t
toshiba_position_show(struct device
*dev
,
1360 struct device_attribute
*attr
, char *buf
)
1362 struct toshiba_acpi_dev
*toshiba
= dev_get_drvdata(dev
);
1363 u32 xyval
, zval
, tmp
;
1368 ret
= toshiba_accelerometer_get(toshiba
, &xyval
, &zval
);
1372 x
= xyval
& HCI_ACCEL_MASK
;
1373 tmp
= xyval
>> HCI_MISC_SHIFT
;
1374 y
= tmp
& HCI_ACCEL_MASK
;
1375 z
= zval
& HCI_ACCEL_MASK
;
1377 return sprintf(buf
, "%d %d %d\n", x
, y
, z
);
1380 static DEVICE_ATTR(kbd_backlight_mode
, S_IRUGO
| S_IWUSR
,
1381 toshiba_kbd_bl_mode_show
, toshiba_kbd_bl_mode_store
);
1382 static DEVICE_ATTR(kbd_backlight_timeout
, S_IRUGO
| S_IWUSR
,
1383 toshiba_kbd_bl_timeout_show
, toshiba_kbd_bl_timeout_store
);
1384 static DEVICE_ATTR(touchpad
, S_IRUGO
| S_IWUSR
,
1385 toshiba_touchpad_show
, toshiba_touchpad_store
);
1386 static DEVICE_ATTR(position
, S_IRUGO
, toshiba_position_show
, NULL
);
1388 static struct attribute
*toshiba_attributes
[] = {
1389 &dev_attr_kbd_backlight_mode
.attr
,
1390 &dev_attr_kbd_backlight_timeout
.attr
,
1391 &dev_attr_touchpad
.attr
,
1392 &dev_attr_position
.attr
,
1396 static umode_t
toshiba_sysfs_is_visible(struct kobject
*kobj
,
1397 struct attribute
*attr
, int idx
)
1399 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1400 struct toshiba_acpi_dev
*drv
= dev_get_drvdata(dev
);
1403 if (attr
== &dev_attr_kbd_backlight_mode
.attr
)
1404 exists
= (drv
->kbd_illum_supported
) ? true : false;
1405 else if (attr
== &dev_attr_kbd_backlight_timeout
.attr
)
1406 exists
= (drv
->kbd_mode
== SCI_KBD_MODE_AUTO
) ? true : false;
1407 else if (attr
== &dev_attr_touchpad
.attr
)
1408 exists
= (drv
->touchpad_supported
) ? true : false;
1409 else if (attr
== &dev_attr_position
.attr
)
1410 exists
= (drv
->accelerometer_supported
) ? true : false;
1412 return exists
? attr
->mode
: 0;
1415 static struct attribute_group toshiba_attr_group
= {
1416 .is_visible
= toshiba_sysfs_is_visible
,
1417 .attrs
= toshiba_attributes
,
1420 static bool toshiba_acpi_i8042_filter(unsigned char data
, unsigned char str
,
1426 if (unlikely(data
== 0xe0))
1429 if ((data
& 0x7f) == TOS1900_FN_SCAN
) {
1430 schedule_work(&toshiba_acpi
->hotkey_work
);
1437 static void toshiba_acpi_hotkey_work(struct work_struct
*work
)
1439 acpi_handle ec_handle
= ec_get_handle();
1445 status
= acpi_evaluate_object(ec_handle
, "NTFY", NULL
, NULL
);
1446 if (ACPI_FAILURE(status
))
1447 pr_err("ACPI NTFY method execution failed\n");
1451 * Returns hotkey scancode, or < 0 on failure.
1453 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev
*dev
)
1455 unsigned long long value
;
1458 status
= acpi_evaluate_integer(dev
->acpi_dev
->handle
, "INFO",
1460 if (ACPI_FAILURE(status
)) {
1461 pr_err("ACPI INFO method execution failed\n");
1468 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev
*dev
,
1471 if (scancode
== 0x100)
1474 /* act on key press; ignore key release */
1475 if (scancode
& 0x80)
1478 if (!sparse_keymap_report_event(dev
->hotkey_dev
, scancode
, 1, true))
1479 pr_info("Unknown key %x\n", scancode
);
1482 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev
*dev
)
1485 acpi_handle ec_handle
;
1488 const struct key_entry
*keymap
= toshiba_acpi_keymap
;
1490 dev
->hotkey_dev
= input_allocate_device();
1491 if (!dev
->hotkey_dev
)
1494 dev
->hotkey_dev
->name
= "Toshiba input device";
1495 dev
->hotkey_dev
->phys
= "toshiba_acpi/input0";
1496 dev
->hotkey_dev
->id
.bustype
= BUS_HOST
;
1498 if (dmi_check_system(toshiba_alt_keymap_dmi
))
1499 keymap
= toshiba_acpi_alt_keymap
;
1500 error
= sparse_keymap_setup(dev
->hotkey_dev
, keymap
, NULL
);
1505 * For some machines the SCI responsible for providing hotkey
1506 * notification doesn't fire. We can trigger the notification
1507 * whenever the Fn key is pressed using the NTFY method, if
1508 * supported, so if it's present set up an i8042 key filter
1512 ec_handle
= ec_get_handle();
1513 if (ec_handle
&& acpi_has_method(ec_handle
, "NTFY")) {
1514 INIT_WORK(&dev
->hotkey_work
, toshiba_acpi_hotkey_work
);
1516 error
= i8042_install_filter(toshiba_acpi_i8042_filter
);
1518 pr_err("Error installing key filter\n");
1519 goto err_free_keymap
;
1522 dev
->ntfy_supported
= 1;
1526 * Determine hotkey query interface. Prefer using the INFO
1527 * method when it is available.
1529 if (acpi_has_method(dev
->acpi_dev
->handle
, "INFO"))
1530 dev
->info_supported
= 1;
1532 hci_write1(dev
, HCI_SYSTEM_EVENT
, 1, &hci_result
);
1533 if (hci_result
== HCI_SUCCESS
)
1534 dev
->system_event_supported
= 1;
1537 if (!dev
->info_supported
&& !dev
->system_event_supported
) {
1538 pr_warn("No hotkey query interface found\n");
1539 goto err_remove_filter
;
1542 status
= acpi_evaluate_object(dev
->acpi_dev
->handle
, "ENAB", NULL
, NULL
);
1543 if (ACPI_FAILURE(status
)) {
1544 pr_info("Unable to enable hotkeys\n");
1546 goto err_remove_filter
;
1549 error
= input_register_device(dev
->hotkey_dev
);
1551 pr_info("Unable to register input device\n");
1552 goto err_remove_filter
;
1555 hci_write1(dev
, HCI_HOTKEY_EVENT
, HCI_HOTKEY_ENABLE
, &hci_result
);
1559 if (dev
->ntfy_supported
)
1560 i8042_remove_filter(toshiba_acpi_i8042_filter
);
1562 sparse_keymap_free(dev
->hotkey_dev
);
1564 input_free_device(dev
->hotkey_dev
);
1565 dev
->hotkey_dev
= NULL
;
1569 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev
*dev
)
1571 struct backlight_properties props
;
1577 * Some machines don't support the backlight methods at all, and
1578 * others support it read-only. Either of these is pretty useless,
1579 * so only register the backlight device if the backlight method
1580 * supports both reads and writes.
1582 brightness
= __get_lcd_brightness(dev
);
1585 ret
= set_lcd_brightness(dev
, brightness
);
1587 pr_debug("Backlight method is read-only, disabling backlight support\n");
1591 /* Determine whether or not BIOS supports transflective backlight */
1592 ret
= get_tr_backlight_status(dev
, &enabled
);
1593 dev
->tr_backlight_supported
= !ret
;
1595 memset(&props
, 0, sizeof(props
));
1596 props
.type
= BACKLIGHT_PLATFORM
;
1597 props
.max_brightness
= HCI_LCD_BRIGHTNESS_LEVELS
- 1;
1599 /* adding an extra level and having 0 change to transflective mode */
1600 if (dev
->tr_backlight_supported
)
1601 props
.max_brightness
++;
1603 dev
->backlight_dev
= backlight_device_register("toshiba",
1604 &dev
->acpi_dev
->dev
,
1606 &toshiba_backlight_data
,
1608 if (IS_ERR(dev
->backlight_dev
)) {
1609 ret
= PTR_ERR(dev
->backlight_dev
);
1610 pr_err("Could not register toshiba backlight device\n");
1611 dev
->backlight_dev
= NULL
;
1615 dev
->backlight_dev
->props
.brightness
= brightness
;
1619 static int toshiba_acpi_remove(struct acpi_device
*acpi_dev
)
1621 struct toshiba_acpi_dev
*dev
= acpi_driver_data(acpi_dev
);
1623 remove_toshiba_proc_entries(dev
);
1625 if (dev
->sysfs_created
)
1626 sysfs_remove_group(&dev
->acpi_dev
->dev
.kobj
,
1627 &toshiba_attr_group
);
1629 if (dev
->ntfy_supported
) {
1630 i8042_remove_filter(toshiba_acpi_i8042_filter
);
1631 cancel_work_sync(&dev
->hotkey_work
);
1634 if (dev
->hotkey_dev
) {
1635 input_unregister_device(dev
->hotkey_dev
);
1636 sparse_keymap_free(dev
->hotkey_dev
);
1640 rfkill_unregister(dev
->bt_rfk
);
1641 rfkill_destroy(dev
->bt_rfk
);
1644 if (dev
->backlight_dev
)
1645 backlight_device_unregister(dev
->backlight_dev
);
1647 if (dev
->illumination_supported
)
1648 led_classdev_unregister(&dev
->led_dev
);
1650 if (dev
->kbd_led_registered
)
1651 led_classdev_unregister(&dev
->kbd_led
);
1653 if (dev
->eco_supported
)
1654 led_classdev_unregister(&dev
->eco_led
);
1657 toshiba_acpi
= NULL
;
1664 static const char *find_hci_method(acpi_handle handle
)
1666 if (acpi_has_method(handle
, "GHCI"))
1669 if (acpi_has_method(handle
, "SPFC"))
1675 static int toshiba_acpi_add(struct acpi_device
*acpi_dev
)
1677 struct toshiba_acpi_dev
*dev
;
1678 const char *hci_method
;
1686 pr_info("Toshiba Laptop ACPI Extras version %s\n",
1687 TOSHIBA_ACPI_VERSION
);
1689 hci_method
= find_hci_method(acpi_dev
->handle
);
1691 pr_err("HCI interface not found\n");
1695 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1698 dev
->acpi_dev
= acpi_dev
;
1699 dev
->method_hci
= hci_method
;
1700 acpi_dev
->driver_data
= dev
;
1701 dev_set_drvdata(&acpi_dev
->dev
, dev
);
1703 if (toshiba_acpi_setup_keyboard(dev
))
1704 pr_info("Unable to activate hotkeys\n");
1706 mutex_init(&dev
->mutex
);
1708 ret
= toshiba_acpi_setup_backlight(dev
);
1712 /* Register rfkill switch for Bluetooth */
1713 if (hci_get_bt_present(dev
, &bt_present
) == HCI_SUCCESS
&& bt_present
) {
1714 dev
->bt_rfk
= rfkill_alloc("Toshiba Bluetooth",
1716 RFKILL_TYPE_BLUETOOTH
,
1720 pr_err("unable to allocate rfkill device\n");
1725 ret
= rfkill_register(dev
->bt_rfk
);
1727 pr_err("unable to register rfkill device\n");
1728 rfkill_destroy(dev
->bt_rfk
);
1733 if (toshiba_illumination_available(dev
)) {
1734 dev
->led_dev
.name
= "toshiba::illumination";
1735 dev
->led_dev
.max_brightness
= 1;
1736 dev
->led_dev
.brightness_set
= toshiba_illumination_set
;
1737 dev
->led_dev
.brightness_get
= toshiba_illumination_get
;
1738 if (!led_classdev_register(&acpi_dev
->dev
, &dev
->led_dev
))
1739 dev
->illumination_supported
= 1;
1742 if (toshiba_eco_mode_available(dev
)) {
1743 dev
->eco_led
.name
= "toshiba::eco_mode";
1744 dev
->eco_led
.max_brightness
= 1;
1745 dev
->eco_led
.brightness_set
= toshiba_eco_mode_set_status
;
1746 dev
->eco_led
.brightness_get
= toshiba_eco_mode_get_status
;
1747 if (!led_classdev_register(&dev
->acpi_dev
->dev
, &dev
->eco_led
))
1748 dev
->eco_supported
= 1;
1751 ret
= toshiba_kbd_illum_status_get(dev
, &dummy
);
1753 dev
->kbd_time
= dummy
>> HCI_MISC_SHIFT
;
1754 dev
->kbd_mode
= dummy
& 0x07;
1756 dev
->kbd_illum_supported
= !ret
;
1758 * Only register the LED if KBD illumination is supported
1759 * and the keyboard backlight operation mode is set to FN-Z
1761 if (dev
->kbd_illum_supported
&& dev
->kbd_mode
== SCI_KBD_MODE_FNZ
) {
1762 dev
->kbd_led
.name
= "toshiba::kbd_backlight";
1763 dev
->kbd_led
.max_brightness
= 1;
1764 dev
->kbd_led
.brightness_set
= toshiba_kbd_backlight_set
;
1765 dev
->kbd_led
.brightness_get
= toshiba_kbd_backlight_get
;
1766 if (!led_classdev_register(&dev
->acpi_dev
->dev
, &dev
->kbd_led
))
1767 dev
->kbd_led_registered
= 1;
1770 ret
= toshiba_touchpad_get(dev
, &dummy
);
1771 dev
->touchpad_supported
= !ret
;
1773 ret
= toshiba_accelerometer_supported(dev
);
1774 dev
->accelerometer_supported
= !ret
;
1776 /* Determine whether or not BIOS supports fan and video interfaces */
1778 ret
= get_video_status(dev
, &dummy
);
1779 dev
->video_supported
= !ret
;
1781 ret
= get_fan_status(dev
, &dummy
);
1782 dev
->fan_supported
= !ret
;
1784 ret
= sysfs_create_group(&dev
->acpi_dev
->dev
.kobj
,
1785 &toshiba_attr_group
);
1787 dev
->sysfs_created
= 0;
1790 dev
->sysfs_created
= !ret
;
1792 create_toshiba_proc_entries(dev
);
1799 toshiba_acpi_remove(acpi_dev
);
1803 static void toshiba_acpi_notify(struct acpi_device
*acpi_dev
, u32 event
)
1805 struct toshiba_acpi_dev
*dev
= acpi_driver_data(acpi_dev
);
1806 u32 hci_result
, value
;
1813 if (dev
->info_supported
) {
1814 scancode
= toshiba_acpi_query_hotkey(dev
);
1816 pr_err("Failed to query hotkey event\n");
1817 else if (scancode
!= 0)
1818 toshiba_acpi_report_hotkey(dev
, scancode
);
1819 } else if (dev
->system_event_supported
) {
1821 hci_read1(dev
, HCI_SYSTEM_EVENT
, &value
, &hci_result
);
1822 switch (hci_result
) {
1824 toshiba_acpi_report_hotkey(dev
, (int)value
);
1826 case HCI_NOT_SUPPORTED
:
1828 * This is a workaround for an unresolved
1829 * issue on some machines where system events
1830 * sporadically become disabled.
1832 hci_write1(dev
, HCI_SYSTEM_EVENT
, 1,
1834 pr_notice("Re-enabled hotkeys\n");
1840 } while (retries
&& hci_result
!= HCI_EMPTY
);
1844 #ifdef CONFIG_PM_SLEEP
1845 static int toshiba_acpi_suspend(struct device
*device
)
1847 struct toshiba_acpi_dev
*dev
= acpi_driver_data(to_acpi_device(device
));
1850 if (dev
->hotkey_dev
)
1851 hci_write1(dev
, HCI_HOTKEY_EVENT
, HCI_HOTKEY_DISABLE
, &result
);
1856 static int toshiba_acpi_resume(struct device
*device
)
1858 struct toshiba_acpi_dev
*dev
= acpi_driver_data(to_acpi_device(device
));
1861 if (dev
->hotkey_dev
)
1862 hci_write1(dev
, HCI_HOTKEY_EVENT
, HCI_HOTKEY_ENABLE
, &result
);
1868 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm
,
1869 toshiba_acpi_suspend
, toshiba_acpi_resume
);
1871 static struct acpi_driver toshiba_acpi_driver
= {
1872 .name
= "Toshiba ACPI driver",
1873 .owner
= THIS_MODULE
,
1874 .ids
= toshiba_device_ids
,
1875 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
1877 .add
= toshiba_acpi_add
,
1878 .remove
= toshiba_acpi_remove
,
1879 .notify
= toshiba_acpi_notify
,
1881 .drv
.pm
= &toshiba_acpi_pm
,
1884 static int __init
toshiba_acpi_init(void)
1889 * Machines with this WMI guid aren't supported due to bugs in
1890 * their AML. This check relies on wmi initializing before
1891 * toshiba_acpi to guarantee guids have been identified.
1893 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID
))
1896 toshiba_proc_dir
= proc_mkdir(PROC_TOSHIBA
, acpi_root_dir
);
1897 if (!toshiba_proc_dir
) {
1898 pr_err("Unable to create proc dir " PROC_TOSHIBA
"\n");
1902 ret
= acpi_bus_register_driver(&toshiba_acpi_driver
);
1904 pr_err("Failed to register ACPI driver: %d\n", ret
);
1905 remove_proc_entry(PROC_TOSHIBA
, acpi_root_dir
);
1911 static void __exit
toshiba_acpi_exit(void)
1913 acpi_bus_unregister_driver(&toshiba_acpi_driver
);
1914 if (toshiba_proc_dir
)
1915 remove_proc_entry(PROC_TOSHIBA
, acpi_root_dir
);
1918 module_init(toshiba_acpi_init
);
1919 module_exit(toshiba_acpi_exit
);