1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
4  *
5  *  Copyright (C) 2002-2004 John Belmonte
6  *  Copyright (C) 2008 Philip Langdale
7  *  Copyright (C) 2010 Pierre Ducroquet
8  *  Copyright (C) 2014-2016 Azael Avalos
9  *
10  *  The devolpment page for this driver is located at
11  *  http://memebeam.org/toys/ToshibaAcpiDriver.
12  *
13  *  Credits:
14  *	Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
15  *		engineering the Windows drivers
16  *	Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
17  *	Rob Miller - TV out and hotkeys help
18  */
19 
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 
22 #define TOSHIBA_ACPI_VERSION	"0.24"
23 #define PROC_INTERFACE_VERSION	1
24 
25 #include <linux/compiler.h>
26 #include <linux/dmi.h>
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/init.h>
31 #include <linux/types.h>
32 #include <linux/proc_fs.h>
33 #include <linux/seq_file.h>
34 #include <linux/backlight.h>
35 #include <linux/input.h>
36 #include <linux/input/sparse-keymap.h>
37 #include <linux/leds.h>
38 #include <linux/slab.h>
39 #include <linux/workqueue.h>
40 #include <linux/i8042.h>
41 #include <linux/acpi.h>
42 #include <linux/uaccess.h>
43 #include <linux/miscdevice.h>
44 #include <linux/rfkill.h>
45 #include <linux/hwmon.h>
46 #include <linux/iio/iio.h>
47 #include <linux/toshiba.h>
48 #include <acpi/battery.h>
49 #include <acpi/video.h>
50 
51 MODULE_AUTHOR("John Belmonte");
52 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
53 MODULE_LICENSE("GPL");
54 
55 static int turn_on_panel_on_resume = -1;
56 module_param(turn_on_panel_on_resume, int, 0644);
57 MODULE_PARM_DESC(turn_on_panel_on_resume,
58 	"Call HCI_PANEL_POWER_ON on resume (-1 = auto, 0 = no, 1 = yes");
59 
60 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
61 
62 /* Scan code for Fn key on TOS1900 models */
63 #define TOS1900_FN_SCAN		0x6e
64 
65 /* Toshiba ACPI method paths */
66 #define METHOD_VIDEO_OUT	"\\_SB_.VALX.DSSX"
67 
68 /*
69  * The Toshiba configuration interface is composed of the HCI and the SCI,
70  * which are defined as follows:
71  *
72  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
73  * be uniform across all their models.  Ideally we would just call
74  * dedicated ACPI methods instead of using this primitive interface.
75  * However the ACPI methods seem to be incomplete in some areas (for
76  * example they allow setting, but not reading, the LCD brightness value),
77  * so this is still useful.
78  *
79  * SCI stands for "System Configuration Interface" which aim is to
80  * conceal differences in hardware between different models.
81  */
82 
83 #define TCI_WORDS			6
84 
85 /* Operations */
86 #define HCI_SET				0xff00
87 #define HCI_GET				0xfe00
88 #define SCI_OPEN			0xf100
89 #define SCI_CLOSE			0xf200
90 #define SCI_GET				0xf300
91 #define SCI_SET				0xf400
92 
93 /* Return codes */
94 #define TOS_SUCCESS			0x0000
95 #define TOS_SUCCESS2			0x0001
96 #define TOS_OPEN_CLOSE_OK		0x0044
97 #define TOS_FAILURE			0x1000
98 #define TOS_NOT_SUPPORTED		0x8000
99 #define TOS_ALREADY_OPEN		0x8100
100 #define TOS_NOT_OPENED			0x8200
101 #define TOS_INPUT_DATA_ERROR		0x8300
102 #define TOS_WRITE_PROTECTED		0x8400
103 #define TOS_NOT_PRESENT			0x8600
104 #define TOS_FIFO_EMPTY			0x8c00
105 #define TOS_DATA_NOT_AVAILABLE		0x8d20
106 #define TOS_NOT_INITIALIZED		0x8d50
107 #define TOS_NOT_INSTALLED		0x8e00
108 
109 /* Registers */
110 #define HCI_PANEL_POWER_ON		0x0002
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_FAN_RPM			0x0045
118 #define HCI_WIRELESS			0x0056
119 #define HCI_ACCELEROMETER		0x006d
120 #define HCI_COOLING_METHOD		0x007f
121 #define HCI_KBD_ILLUMINATION		0x0095
122 #define HCI_ECO_MODE			0x0097
123 #define HCI_ACCELEROMETER2		0x00a6
124 #define HCI_BATTERY_CHARGE_MODE		0x00ba
125 #define HCI_SYSTEM_INFO			0xc000
126 #define SCI_PANEL_POWER_ON		0x010d
127 #define SCI_ILLUMINATION		0x014e
128 #define SCI_USB_SLEEP_CHARGE		0x0150
129 #define SCI_KBD_ILLUM_STATUS		0x015c
130 #define SCI_USB_SLEEP_MUSIC		0x015e
131 #define SCI_USB_THREE			0x0169
132 #define SCI_TOUCHPAD			0x050e
133 #define SCI_KBD_FUNCTION_KEYS		0x0522
134 
135 /* Field definitions */
136 #define HCI_ACCEL_MASK			0x7fff
137 #define HCI_ACCEL_DIRECTION_MASK	0x8000
138 #define HCI_HOTKEY_DISABLE		0x0b
139 #define HCI_HOTKEY_ENABLE		0x09
140 #define HCI_HOTKEY_SPECIAL_FUNCTIONS	0x10
141 #define HCI_LCD_BRIGHTNESS_BITS		3
142 #define HCI_LCD_BRIGHTNESS_SHIFT	(16-HCI_LCD_BRIGHTNESS_BITS)
143 #define HCI_LCD_BRIGHTNESS_LEVELS	(1 << HCI_LCD_BRIGHTNESS_BITS)
144 #define HCI_MISC_SHIFT			0x10
145 #define HCI_SYSTEM_TYPE1		0x10
146 #define HCI_SYSTEM_TYPE2		0x11
147 #define HCI_VIDEO_OUT_LCD		0x1
148 #define HCI_VIDEO_OUT_CRT		0x2
149 #define HCI_VIDEO_OUT_TV		0x4
150 #define SCI_KBD_MODE_MASK		0x1f
151 #define SCI_KBD_MODE_FNZ		0x1
152 #define SCI_KBD_MODE_AUTO		0x2
153 #define SCI_KBD_MODE_ON			0x8
154 #define SCI_KBD_MODE_OFF		0x10
155 #define SCI_KBD_TIME_MAX		0x3c001a
156 #define HCI_WIRELESS_STATUS		0x1
157 #define HCI_WIRELESS_WWAN		0x3
158 #define HCI_WIRELESS_WWAN_STATUS	0x2000
159 #define HCI_WIRELESS_WWAN_POWER		0x4000
160 #define SCI_USB_CHARGE_MODE_MASK	0xff
161 #define SCI_USB_CHARGE_DISABLED		0x00
162 #define SCI_USB_CHARGE_ALTERNATE	0x09
163 #define SCI_USB_CHARGE_TYPICAL		0x11
164 #define SCI_USB_CHARGE_AUTO		0x21
165 #define SCI_USB_CHARGE_BAT_MASK		0x7
166 #define SCI_USB_CHARGE_BAT_LVL_OFF	0x1
167 #define SCI_USB_CHARGE_BAT_LVL_ON	0x4
168 #define SCI_USB_CHARGE_BAT_LVL		0x0200
169 #define SCI_USB_CHARGE_RAPID_DSP	0x0300
170 
171 struct toshiba_acpi_dev {
172 	struct acpi_device *acpi_dev;
173 	const char *method_hci;
174 	struct input_dev *hotkey_dev;
175 	struct work_struct hotkey_work;
176 	struct backlight_device *backlight_dev;
177 	struct led_classdev led_dev;
178 	struct led_classdev kbd_led;
179 	struct led_classdev eco_led;
180 	struct miscdevice miscdev;
181 	struct rfkill *wwan_rfk;
182 	struct iio_dev *indio_dev;
183 #if IS_ENABLED(CONFIG_HWMON)
184 	struct device *hwmon_device;
185 #endif
186 
187 	int force_fan;
188 	int last_key_event;
189 	int key_event_valid;
190 	int kbd_type;
191 	int kbd_mode;
192 	int kbd_time;
193 	int usbsc_bat_level;
194 	int usbsc_mode_base;
195 	int hotkey_event_type;
196 	int max_cooling_method;
197 
198 	unsigned int illumination_supported:1;
199 	unsigned int video_supported:1;
200 	unsigned int fan_supported:1;
201 	unsigned int fan_rpm_supported:1;
202 	unsigned int system_event_supported:1;
203 	unsigned int ntfy_supported:1;
204 	unsigned int info_supported:1;
205 	unsigned int tr_backlight_supported:1;
206 	unsigned int kbd_illum_supported:1;
207 	unsigned int touchpad_supported:1;
208 	unsigned int eco_supported:1;
209 	unsigned int accelerometer_supported:1;
210 	unsigned int usb_sleep_charge_supported:1;
211 	unsigned int usb_rapid_charge_supported:1;
212 	unsigned int usb_sleep_music_supported:1;
213 	unsigned int kbd_function_keys_supported:1;
214 	unsigned int panel_power_on_supported:1;
215 	unsigned int usb_three_supported:1;
216 	unsigned int wwan_supported:1;
217 	unsigned int cooling_method_supported:1;
218 	unsigned int battery_charge_mode_supported:1;
219 	unsigned int sysfs_created:1;
220 	unsigned int special_functions;
221 
222 	bool kbd_event_generated;
223 	bool killswitch;
224 };
225 
226 static struct toshiba_acpi_dev *toshiba_acpi;
227 
228 static bool disable_hotkeys;
229 module_param(disable_hotkeys, bool, 0444);
230 MODULE_PARM_DESC(disable_hotkeys, "Disables the hotkeys activation");
231 
232 static const struct acpi_device_id toshiba_device_ids[] = {
233 	{"TOS6200", 0},
234 	{"TOS6207", 0},
235 	{"TOS6208", 0},
236 	{"TOS1900", 0},
237 	{"", 0},
238 };
239 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
240 
241 static const struct key_entry toshiba_acpi_keymap[] = {
242 	{ KE_KEY, 0x9e, { KEY_RFKILL } },
243 	{ KE_KEY, 0x101, { KEY_MUTE } },
244 	{ KE_KEY, 0x102, { KEY_ZOOMOUT } },
245 	{ KE_KEY, 0x103, { KEY_ZOOMIN } },
246 	{ KE_KEY, 0x10f, { KEY_TAB } },
247 	{ KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
248 	{ KE_KEY, 0x139, { KEY_ZOOMRESET } },
249 	{ KE_KEY, 0x13b, { KEY_COFFEE } },
250 	{ KE_KEY, 0x13c, { KEY_BATTERY } },
251 	{ KE_KEY, 0x13d, { KEY_SLEEP } },
252 	{ KE_KEY, 0x13e, { KEY_SUSPEND } },
253 	{ KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
254 	{ KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
255 	{ KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
256 	{ KE_KEY, 0x142, { KEY_WLAN } },
257 	{ KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } },
258 	{ KE_KEY, 0x17f, { KEY_FN } },
259 	{ KE_KEY, 0xb05, { KEY_PROG2 } },
260 	{ KE_KEY, 0xb06, { KEY_WWW } },
261 	{ KE_KEY, 0xb07, { KEY_MAIL } },
262 	{ KE_KEY, 0xb30, { KEY_STOP } },
263 	{ KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
264 	{ KE_KEY, 0xb32, { KEY_NEXTSONG } },
265 	{ KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
266 	{ KE_KEY, 0xb5a, { KEY_MEDIA } },
267 	{ KE_IGNORE, 0x1430, { KEY_RESERVED } }, /* Wake from sleep */
268 	{ KE_IGNORE, 0x1501, { KEY_RESERVED } }, /* Output changed */
269 	{ KE_IGNORE, 0x1502, { KEY_RESERVED } }, /* HDMI plugged/unplugged */
270 	{ KE_IGNORE, 0x1ABE, { KEY_RESERVED } }, /* Protection level set */
271 	{ KE_IGNORE, 0x1ABF, { KEY_RESERVED } }, /* Protection level off */
272 	{ KE_END, 0 },
273 };
274 
275 static const struct key_entry toshiba_acpi_alt_keymap[] = {
276 	{ KE_KEY, 0x102, { KEY_ZOOMOUT } },
277 	{ KE_KEY, 0x103, { KEY_ZOOMIN } },
278 	{ KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
279 	{ KE_KEY, 0x139, { KEY_ZOOMRESET } },
280 	{ KE_KEY, 0x13c, { KEY_BRIGHTNESSDOWN } },
281 	{ KE_KEY, 0x13d, { KEY_BRIGHTNESSUP } },
282 	{ KE_KEY, 0x13e, { KEY_SWITCHVIDEOMODE } },
283 	{ KE_KEY, 0x13f, { KEY_TOUCHPAD_TOGGLE } },
284 	{ KE_KEY, 0x157, { KEY_MUTE } },
285 	{ KE_KEY, 0x158, { KEY_WLAN } },
286 	{ KE_END, 0 },
287 };
288 
289 /*
290  * Utility
291  */
292 
293 static inline void _set_bit(u32 *word, u32 mask, int value)
294 {
295 	*word = (*word & ~mask) | (mask * value);
296 }
297 
298 /*
299  * ACPI interface wrappers
300  */
301 
302 static int write_acpi_int(const char *methodName, int val)
303 {
304 	acpi_status status;
305 
306 	status = acpi_execute_simple_method(NULL, (char *)methodName, val);
307 	return (status == AE_OK) ? 0 : -EIO;
308 }
309 
310 /*
311  * Perform a raw configuration call.  Here we don't care about input or output
312  * buffer format.
313  */
314 static acpi_status tci_raw(struct toshiba_acpi_dev *dev,
315 			   const u32 in[TCI_WORDS], u32 out[TCI_WORDS])
316 {
317 	union acpi_object in_objs[TCI_WORDS], out_objs[TCI_WORDS + 1];
318 	struct acpi_object_list params;
319 	struct acpi_buffer results;
320 	acpi_status status;
321 	int i;
322 
323 	params.count = TCI_WORDS;
324 	params.pointer = in_objs;
325 	for (i = 0; i < TCI_WORDS; ++i) {
326 		in_objs[i].type = ACPI_TYPE_INTEGER;
327 		in_objs[i].integer.value = in[i];
328 	}
329 
330 	results.length = sizeof(out_objs);
331 	results.pointer = out_objs;
332 
333 	status = acpi_evaluate_object(dev->acpi_dev->handle,
334 				      (char *)dev->method_hci, &params,
335 				      &results);
336 	if ((status == AE_OK) && (out_objs->package.count <= TCI_WORDS)) {
337 		for (i = 0; i < out_objs->package.count; ++i)
338 			out[i] = out_objs->package.elements[i].integer.value;
339 	}
340 
341 	return status;
342 }
343 
344 /*
345  * Common hci tasks
346  *
347  * In addition to the ACPI status, the HCI system returns a result which
348  * may be useful (such as "not supported").
349  */
350 
351 static u32 hci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1)
352 {
353 	u32 in[TCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
354 	u32 out[TCI_WORDS];
355 	acpi_status status = tci_raw(dev, in, out);
356 
357 	return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
358 }
359 
360 static u32 hci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
361 {
362 	u32 in[TCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
363 	u32 out[TCI_WORDS];
364 	acpi_status status = tci_raw(dev, in, out);
365 
366 	if (ACPI_FAILURE(status))
367 		return TOS_FAILURE;
368 
369 	*out1 = out[2];
370 
371 	return out[0];
372 }
373 
374 /*
375  * Common sci tasks
376  */
377 
378 static int sci_open(struct toshiba_acpi_dev *dev)
379 {
380 	u32 in[TCI_WORDS] = { SCI_OPEN, 0, 0, 0, 0, 0 };
381 	u32 out[TCI_WORDS];
382 	acpi_status status = tci_raw(dev, in, out);
383 
384 	if  (ACPI_FAILURE(status)) {
385 		pr_err("ACPI call to open SCI failed\n");
386 		return 0;
387 	}
388 
389 	if (out[0] == TOS_OPEN_CLOSE_OK) {
390 		return 1;
391 	} else if (out[0] == TOS_ALREADY_OPEN) {
392 		pr_info("Toshiba SCI already opened\n");
393 		return 1;
394 	} else if (out[0] == TOS_NOT_SUPPORTED) {
395 		/*
396 		 * Some BIOSes do not have the SCI open/close functions
397 		 * implemented and return 0x8000 (Not Supported), failing to
398 		 * register some supported features.
399 		 *
400 		 * Simply return 1 if we hit those affected laptops to make the
401 		 * supported features work.
402 		 *
403 		 * In the case that some laptops really do not support the SCI,
404 		 * all the SCI dependent functions check for TOS_NOT_SUPPORTED,
405 		 * and thus, not registering support for the queried feature.
406 		 */
407 		return 1;
408 	} else if (out[0] == TOS_NOT_PRESENT) {
409 		pr_info("Toshiba SCI is not present\n");
410 	}
411 
412 	return 0;
413 }
414 
415 static void sci_close(struct toshiba_acpi_dev *dev)
416 {
417 	u32 in[TCI_WORDS] = { SCI_CLOSE, 0, 0, 0, 0, 0 };
418 	u32 out[TCI_WORDS];
419 	acpi_status status = tci_raw(dev, in, out);
420 
421 	if (ACPI_FAILURE(status)) {
422 		pr_err("ACPI call to close SCI failed\n");
423 		return;
424 	}
425 
426 	if (out[0] == TOS_OPEN_CLOSE_OK)
427 		return;
428 	else if (out[0] == TOS_NOT_OPENED)
429 		pr_info("Toshiba SCI not opened\n");
430 	else if (out[0] == TOS_NOT_PRESENT)
431 		pr_info("Toshiba SCI is not present\n");
432 }
433 
434 static u32 sci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
435 {
436 	u32 in[TCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 };
437 	u32 out[TCI_WORDS];
438 	acpi_status status = tci_raw(dev, in, out);
439 
440 	if (ACPI_FAILURE(status))
441 		return TOS_FAILURE;
442 
443 	*out1 = out[2];
444 
445 	return out[0];
446 }
447 
448 static u32 sci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1)
449 {
450 	u32 in[TCI_WORDS] = { SCI_SET, reg, in1, 0, 0, 0 };
451 	u32 out[TCI_WORDS];
452 	acpi_status status = tci_raw(dev, in, out);
453 
454 	return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
455 }
456 
457 /* Illumination support */
458 static void toshiba_illumination_available(struct toshiba_acpi_dev *dev)
459 {
460 	u32 in[TCI_WORDS] = { SCI_GET, SCI_ILLUMINATION, 0, 0, 0, 0 };
461 	u32 out[TCI_WORDS];
462 	acpi_status status;
463 
464 	dev->illumination_supported = 0;
465 
466 	if (!sci_open(dev))
467 		return;
468 
469 	status = tci_raw(dev, in, out);
470 	sci_close(dev);
471 	if (ACPI_FAILURE(status)) {
472 		pr_err("ACPI call to query Illumination support failed\n");
473 		return;
474 	}
475 
476 	if (out[0] != TOS_SUCCESS)
477 		return;
478 
479 	dev->illumination_supported = 1;
480 }
481 
482 static void toshiba_illumination_set(struct led_classdev *cdev,
483 				     enum led_brightness brightness)
484 {
485 	struct toshiba_acpi_dev *dev = container_of(cdev,
486 			struct toshiba_acpi_dev, led_dev);
487 	u32 result;
488 	u32 state;
489 
490 	/* First request : initialize communication. */
491 	if (!sci_open(dev))
492 		return;
493 
494 	/* Switch the illumination on/off */
495 	state = brightness ? 1 : 0;
496 	result = sci_write(dev, SCI_ILLUMINATION, state);
497 	sci_close(dev);
498 	if (result == TOS_FAILURE)
499 		pr_err("ACPI call for illumination failed\n");
500 }
501 
502 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
503 {
504 	struct toshiba_acpi_dev *dev = container_of(cdev,
505 			struct toshiba_acpi_dev, led_dev);
506 	u32 result;
507 	u32 state;
508 
509 	/* First request : initialize communication. */
510 	if (!sci_open(dev))
511 		return LED_OFF;
512 
513 	/* Check the illumination */
514 	result = sci_read(dev, SCI_ILLUMINATION, &state);
515 	sci_close(dev);
516 	if (result == TOS_FAILURE) {
517 		pr_err("ACPI call for illumination failed\n");
518 		return LED_OFF;
519 	} else if (result != TOS_SUCCESS) {
520 		return LED_OFF;
521 	}
522 
523 	return state ? LED_FULL : LED_OFF;
524 }
525 
526 /* KBD Illumination */
527 static void toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev)
528 {
529 	u32 in[TCI_WORDS] = { SCI_GET, SCI_KBD_ILLUM_STATUS, 0, 0, 0, 0 };
530 	u32 out[TCI_WORDS];
531 	acpi_status status;
532 
533 	dev->kbd_illum_supported = 0;
534 	dev->kbd_event_generated = false;
535 
536 	if (!sci_open(dev))
537 		return;
538 
539 	status = tci_raw(dev, in, out);
540 	sci_close(dev);
541 	if (ACPI_FAILURE(status)) {
542 		pr_err("ACPI call to query kbd illumination support failed\n");
543 		return;
544 	}
545 
546 	if (out[0] != TOS_SUCCESS)
547 		return;
548 
549 	/*
550 	 * Check for keyboard backlight timeout max value,
551 	 * previous kbd backlight implementation set this to
552 	 * 0x3c0003, and now the new implementation set this
553 	 * to 0x3c001a, use this to distinguish between them.
554 	 */
555 	if (out[3] == SCI_KBD_TIME_MAX)
556 		dev->kbd_type = 2;
557 	else
558 		dev->kbd_type = 1;
559 	/* Get the current keyboard backlight mode */
560 	dev->kbd_mode = out[2] & SCI_KBD_MODE_MASK;
561 	/* Get the current time (1-60 seconds) */
562 	dev->kbd_time = out[2] >> HCI_MISC_SHIFT;
563 	/* Flag as supported */
564 	dev->kbd_illum_supported = 1;
565 }
566 
567 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time)
568 {
569 	u32 result;
570 
571 	if (!sci_open(dev))
572 		return -EIO;
573 
574 	result = sci_write(dev, SCI_KBD_ILLUM_STATUS, time);
575 	sci_close(dev);
576 	if (result == TOS_FAILURE)
577 		pr_err("ACPI call to set KBD backlight status failed\n");
578 	else if (result == TOS_NOT_SUPPORTED)
579 		return -ENODEV;
580 
581 	return result == TOS_SUCCESS ? 0 : -EIO;
582 }
583 
584 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time)
585 {
586 	u32 result;
587 
588 	if (!sci_open(dev))
589 		return -EIO;
590 
591 	result = sci_read(dev, SCI_KBD_ILLUM_STATUS, time);
592 	sci_close(dev);
593 	if (result == TOS_FAILURE)
594 		pr_err("ACPI call to get KBD backlight status failed\n");
595 	else if (result == TOS_NOT_SUPPORTED)
596 		return -ENODEV;
597 
598 	return result == TOS_SUCCESS ? 0 : -EIO;
599 }
600 
601 static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev)
602 {
603 	struct toshiba_acpi_dev *dev = container_of(cdev,
604 			struct toshiba_acpi_dev, kbd_led);
605 	u32 result;
606 	u32 state;
607 
608 	/* Check the keyboard backlight state */
609 	result = hci_read(dev, HCI_KBD_ILLUMINATION, &state);
610 	if (result == TOS_FAILURE) {
611 		pr_err("ACPI call to get the keyboard backlight failed\n");
612 		return LED_OFF;
613 	} else if (result != TOS_SUCCESS) {
614 		return LED_OFF;
615 	}
616 
617 	return state ? LED_FULL : LED_OFF;
618 }
619 
620 static void toshiba_kbd_backlight_set(struct led_classdev *cdev,
621 				     enum led_brightness brightness)
622 {
623 	struct toshiba_acpi_dev *dev = container_of(cdev,
624 			struct toshiba_acpi_dev, kbd_led);
625 	u32 result;
626 	u32 state;
627 
628 	/* Set the keyboard backlight state */
629 	state = brightness ? 1 : 0;
630 	result = hci_write(dev, HCI_KBD_ILLUMINATION, state);
631 	if (result == TOS_FAILURE)
632 		pr_err("ACPI call to set KBD Illumination mode failed\n");
633 }
634 
635 /* TouchPad support */
636 static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state)
637 {
638 	u32 result;
639 
640 	if (!sci_open(dev))
641 		return -EIO;
642 
643 	result = sci_write(dev, SCI_TOUCHPAD, state);
644 	sci_close(dev);
645 	if (result == TOS_FAILURE)
646 		pr_err("ACPI call to set the touchpad failed\n");
647 	else if (result == TOS_NOT_SUPPORTED)
648 		return -ENODEV;
649 
650 	return result == TOS_SUCCESS ? 0 : -EIO;
651 }
652 
653 static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state)
654 {
655 	u32 result;
656 
657 	if (!sci_open(dev))
658 		return -EIO;
659 
660 	result = sci_read(dev, SCI_TOUCHPAD, state);
661 	sci_close(dev);
662 	if (result == TOS_FAILURE)
663 		pr_err("ACPI call to query the touchpad failed\n");
664 	else if (result == TOS_NOT_SUPPORTED)
665 		return -ENODEV;
666 
667 	return result == TOS_SUCCESS ? 0 : -EIO;
668 }
669 
670 /* Eco Mode support */
671 static void toshiba_eco_mode_available(struct toshiba_acpi_dev *dev)
672 {
673 	u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 };
674 	u32 out[TCI_WORDS];
675 	acpi_status status;
676 
677 	dev->eco_supported = 0;
678 
679 	status = tci_raw(dev, in, out);
680 	if (ACPI_FAILURE(status)) {
681 		pr_err("ACPI call to get ECO led failed\n");
682 		return;
683 	}
684 
685 	if (out[0] == TOS_INPUT_DATA_ERROR || out[0] == TOS_NOT_SUPPORTED) {
686 		/*
687 		 * If we receive 0x8300 (Input Data Error), it means that the
688 		 * LED device is present, but that we just screwed the input
689 		 * parameters.
690 		 *
691 		 * On some laptops 0x8000 (Not supported) is also returned in
692 		 * this case, so we need to allow for that as well.
693 		 *
694 		 * Let's query the status of the LED to see if we really have a
695 		 * success response, indicating the actual presense of the LED,
696 		 * bail out otherwise.
697 		 */
698 		in[3] = 1;
699 		status = tci_raw(dev, in, out);
700 		if (ACPI_FAILURE(status)) {
701 			pr_err("ACPI call to get ECO led failed\n");
702 			return;
703 		}
704 
705 		if (out[0] != TOS_SUCCESS)
706 			return;
707 
708 		dev->eco_supported = 1;
709 	}
710 }
711 
712 static enum led_brightness
713 toshiba_eco_mode_get_status(struct led_classdev *cdev)
714 {
715 	struct toshiba_acpi_dev *dev = container_of(cdev,
716 			struct toshiba_acpi_dev, eco_led);
717 	u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 };
718 	u32 out[TCI_WORDS];
719 	acpi_status status;
720 
721 	status = tci_raw(dev, in, out);
722 	if (ACPI_FAILURE(status)) {
723 		pr_err("ACPI call to get ECO led failed\n");
724 		return LED_OFF;
725 	}
726 
727 	if (out[0] != TOS_SUCCESS)
728 		return LED_OFF;
729 
730 	return out[2] ? LED_FULL : LED_OFF;
731 }
732 
733 static void toshiba_eco_mode_set_status(struct led_classdev *cdev,
734 				     enum led_brightness brightness)
735 {
736 	struct toshiba_acpi_dev *dev = container_of(cdev,
737 			struct toshiba_acpi_dev, eco_led);
738 	u32 in[TCI_WORDS] = { HCI_SET, HCI_ECO_MODE, 0, 1, 0, 0 };
739 	u32 out[TCI_WORDS];
740 	acpi_status status;
741 
742 	/* Switch the Eco Mode led on/off */
743 	in[2] = (brightness) ? 1 : 0;
744 	status = tci_raw(dev, in, out);
745 	if (ACPI_FAILURE(status))
746 		pr_err("ACPI call to set ECO led failed\n");
747 }
748 
749 /* Accelerometer support */
750 static void toshiba_accelerometer_available(struct toshiba_acpi_dev *dev)
751 {
752 	u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER2, 0, 0, 0, 0 };
753 	u32 out[TCI_WORDS];
754 	acpi_status status;
755 
756 	dev->accelerometer_supported = 0;
757 
758 	/*
759 	 * Check if the accelerometer call exists,
760 	 * this call also serves as initialization
761 	 */
762 	status = tci_raw(dev, in, out);
763 	if (ACPI_FAILURE(status)) {
764 		pr_err("ACPI call to query the accelerometer failed\n");
765 		return;
766 	}
767 
768 	if (out[0] != TOS_SUCCESS)
769 		return;
770 
771 	dev->accelerometer_supported = 1;
772 }
773 
774 static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev,
775 				     u32 *xy, u32 *z)
776 {
777 	u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER, 0, 1, 0, 0 };
778 	u32 out[TCI_WORDS];
779 	acpi_status status;
780 
781 	/* Check the Accelerometer status */
782 	status = tci_raw(dev, in, out);
783 	if (ACPI_FAILURE(status)) {
784 		pr_err("ACPI call to query the accelerometer failed\n");
785 		return -EIO;
786 	}
787 
788 	if (out[0] == TOS_NOT_SUPPORTED)
789 		return -ENODEV;
790 
791 	if (out[0] != TOS_SUCCESS)
792 		return -EIO;
793 
794 	*xy = out[2];
795 	*z = out[4];
796 
797 	return 0;
798 }
799 
800 /* Sleep (Charge and Music) utilities support */
801 static void toshiba_usb_sleep_charge_available(struct toshiba_acpi_dev *dev)
802 {
803 	u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
804 	u32 out[TCI_WORDS];
805 	acpi_status status;
806 
807 	dev->usb_sleep_charge_supported = 0;
808 
809 	if (!sci_open(dev))
810 		return;
811 
812 	status = tci_raw(dev, in, out);
813 	if (ACPI_FAILURE(status)) {
814 		pr_err("ACPI call to get USB Sleep and Charge mode failed\n");
815 		sci_close(dev);
816 		return;
817 	}
818 
819 	if (out[0] != TOS_SUCCESS) {
820 		sci_close(dev);
821 		return;
822 	}
823 
824 	dev->usbsc_mode_base = out[4];
825 
826 	in[5] = SCI_USB_CHARGE_BAT_LVL;
827 	status = tci_raw(dev, in, out);
828 	sci_close(dev);
829 	if (ACPI_FAILURE(status)) {
830 		pr_err("ACPI call to get USB Sleep and Charge mode failed\n");
831 		return;
832 	}
833 
834 	if (out[0] != TOS_SUCCESS)
835 		return;
836 
837 	dev->usbsc_bat_level = out[2];
838 	/* Flag as supported */
839 	dev->usb_sleep_charge_supported = 1;
840 }
841 
842 static int toshiba_usb_sleep_charge_get(struct toshiba_acpi_dev *dev,
843 					u32 *mode)
844 {
845 	u32 result;
846 
847 	if (!sci_open(dev))
848 		return -EIO;
849 
850 	result = sci_read(dev, SCI_USB_SLEEP_CHARGE, mode);
851 	sci_close(dev);
852 	if (result == TOS_FAILURE)
853 		pr_err("ACPI call to set USB S&C mode failed\n");
854 	else if (result == TOS_NOT_SUPPORTED)
855 		return -ENODEV;
856 
857 	return result == TOS_SUCCESS ? 0 : -EIO;
858 }
859 
860 static int toshiba_usb_sleep_charge_set(struct toshiba_acpi_dev *dev,
861 					u32 mode)
862 {
863 	u32 result;
864 
865 	if (!sci_open(dev))
866 		return -EIO;
867 
868 	result = sci_write(dev, SCI_USB_SLEEP_CHARGE, mode);
869 	sci_close(dev);
870 	if (result == TOS_FAILURE)
871 		pr_err("ACPI call to set USB S&C mode failed\n");
872 	else if (result == TOS_NOT_SUPPORTED)
873 		return -ENODEV;
874 
875 	return result == TOS_SUCCESS ? 0 : -EIO;
876 }
877 
878 static int toshiba_sleep_functions_status_get(struct toshiba_acpi_dev *dev,
879 					      u32 *mode)
880 {
881 	u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
882 	u32 out[TCI_WORDS];
883 	acpi_status status;
884 
885 	if (!sci_open(dev))
886 		return -EIO;
887 
888 	in[5] = SCI_USB_CHARGE_BAT_LVL;
889 	status = tci_raw(dev, in, out);
890 	sci_close(dev);
891 	if (ACPI_FAILURE(status)) {
892 		pr_err("ACPI call to get USB S&C battery level failed\n");
893 		return -EIO;
894 	}
895 
896 	if (out[0] == TOS_NOT_SUPPORTED)
897 		return -ENODEV;
898 
899 	if (out[0] != TOS_SUCCESS)
900 		return -EIO;
901 
902 	*mode = out[2];
903 
904 	return 0;
905 
906 }
907 
908 static int toshiba_sleep_functions_status_set(struct toshiba_acpi_dev *dev,
909 					      u32 mode)
910 {
911 	u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
912 	u32 out[TCI_WORDS];
913 	acpi_status status;
914 
915 	if (!sci_open(dev))
916 		return -EIO;
917 
918 	in[2] = mode;
919 	in[5] = SCI_USB_CHARGE_BAT_LVL;
920 	status = tci_raw(dev, in, out);
921 	sci_close(dev);
922 	if (ACPI_FAILURE(status)) {
923 		pr_err("ACPI call to set USB S&C battery level failed\n");
924 		return -EIO;
925 	}
926 
927 	if (out[0] == TOS_NOT_SUPPORTED)
928 		return -ENODEV;
929 
930 	return out[0] == TOS_SUCCESS ? 0 : -EIO;
931 }
932 
933 static int toshiba_usb_rapid_charge_get(struct toshiba_acpi_dev *dev,
934 					u32 *state)
935 {
936 	u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
937 	u32 out[TCI_WORDS];
938 	acpi_status status;
939 
940 	if (!sci_open(dev))
941 		return -EIO;
942 
943 	in[5] = SCI_USB_CHARGE_RAPID_DSP;
944 	status = tci_raw(dev, in, out);
945 	sci_close(dev);
946 	if (ACPI_FAILURE(status)) {
947 		pr_err("ACPI call to get USB Rapid Charge failed\n");
948 		return -EIO;
949 	}
950 
951 	if (out[0] == TOS_NOT_SUPPORTED)
952 		return -ENODEV;
953 
954 	if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2)
955 		return -EIO;
956 
957 	*state = out[2];
958 
959 	return 0;
960 }
961 
962 static int toshiba_usb_rapid_charge_set(struct toshiba_acpi_dev *dev,
963 					u32 state)
964 {
965 	u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
966 	u32 out[TCI_WORDS];
967 	acpi_status status;
968 
969 	if (!sci_open(dev))
970 		return -EIO;
971 
972 	in[2] = state;
973 	in[5] = SCI_USB_CHARGE_RAPID_DSP;
974 	status = tci_raw(dev, in, out);
975 	sci_close(dev);
976 	if (ACPI_FAILURE(status)) {
977 		pr_err("ACPI call to set USB Rapid Charge failed\n");
978 		return -EIO;
979 	}
980 
981 	if (out[0] == TOS_NOT_SUPPORTED)
982 		return -ENODEV;
983 
984 	return (out[0] == TOS_SUCCESS || out[0] == TOS_SUCCESS2) ? 0 : -EIO;
985 }
986 
987 static int toshiba_usb_sleep_music_get(struct toshiba_acpi_dev *dev, u32 *state)
988 {
989 	u32 result;
990 
991 	if (!sci_open(dev))
992 		return -EIO;
993 
994 	result = sci_read(dev, SCI_USB_SLEEP_MUSIC, state);
995 	sci_close(dev);
996 	if (result == TOS_FAILURE)
997 		pr_err("ACPI call to get Sleep and Music failed\n");
998 	else if (result == TOS_NOT_SUPPORTED)
999 		return -ENODEV;
1000 
1001 	return result == TOS_SUCCESS ? 0 : -EIO;
1002 }
1003 
1004 static int toshiba_usb_sleep_music_set(struct toshiba_acpi_dev *dev, u32 state)
1005 {
1006 	u32 result;
1007 
1008 	if (!sci_open(dev))
1009 		return -EIO;
1010 
1011 	result = sci_write(dev, SCI_USB_SLEEP_MUSIC, state);
1012 	sci_close(dev);
1013 	if (result == TOS_FAILURE)
1014 		pr_err("ACPI call to set Sleep and Music failed\n");
1015 	else if (result == TOS_NOT_SUPPORTED)
1016 		return -ENODEV;
1017 
1018 	return result == TOS_SUCCESS ? 0 : -EIO;
1019 }
1020 
1021 /* Keyboard function keys */
1022 static int toshiba_function_keys_get(struct toshiba_acpi_dev *dev, u32 *mode)
1023 {
1024 	u32 result;
1025 
1026 	if (!sci_open(dev))
1027 		return -EIO;
1028 
1029 	result = sci_read(dev, SCI_KBD_FUNCTION_KEYS, mode);
1030 	sci_close(dev);
1031 	if (result == TOS_FAILURE)
1032 		pr_err("ACPI call to get KBD function keys failed\n");
1033 	else if (result == TOS_NOT_SUPPORTED)
1034 		return -ENODEV;
1035 
1036 	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
1037 }
1038 
1039 static int toshiba_function_keys_set(struct toshiba_acpi_dev *dev, u32 mode)
1040 {
1041 	u32 result;
1042 
1043 	if (!sci_open(dev))
1044 		return -EIO;
1045 
1046 	result = sci_write(dev, SCI_KBD_FUNCTION_KEYS, mode);
1047 	sci_close(dev);
1048 	if (result == TOS_FAILURE)
1049 		pr_err("ACPI call to set KBD function keys failed\n");
1050 	else if (result == TOS_NOT_SUPPORTED)
1051 		return -ENODEV;
1052 
1053 	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
1054 }
1055 
1056 /* Panel Power ON */
1057 static int toshiba_panel_power_on_get(struct toshiba_acpi_dev *dev, u32 *state)
1058 {
1059 	u32 result;
1060 
1061 	if (!sci_open(dev))
1062 		return -EIO;
1063 
1064 	result = sci_read(dev, SCI_PANEL_POWER_ON, state);
1065 	sci_close(dev);
1066 	if (result == TOS_FAILURE)
1067 		pr_err("ACPI call to get Panel Power ON failed\n");
1068 	else if (result == TOS_NOT_SUPPORTED)
1069 		return -ENODEV;
1070 
1071 	return result == TOS_SUCCESS ? 0 : -EIO;
1072 }
1073 
1074 static int toshiba_panel_power_on_set(struct toshiba_acpi_dev *dev, u32 state)
1075 {
1076 	u32 result;
1077 
1078 	if (!sci_open(dev))
1079 		return -EIO;
1080 
1081 	result = sci_write(dev, SCI_PANEL_POWER_ON, state);
1082 	sci_close(dev);
1083 	if (result == TOS_FAILURE)
1084 		pr_err("ACPI call to set Panel Power ON failed\n");
1085 	else if (result == TOS_NOT_SUPPORTED)
1086 		return -ENODEV;
1087 
1088 	return result == TOS_SUCCESS ? 0 : -EIO;
1089 }
1090 
1091 /* USB Three */
1092 static int toshiba_usb_three_get(struct toshiba_acpi_dev *dev, u32 *state)
1093 {
1094 	u32 result;
1095 
1096 	if (!sci_open(dev))
1097 		return -EIO;
1098 
1099 	result = sci_read(dev, SCI_USB_THREE, state);
1100 	sci_close(dev);
1101 	if (result == TOS_FAILURE)
1102 		pr_err("ACPI call to get USB 3 failed\n");
1103 	else if (result == TOS_NOT_SUPPORTED)
1104 		return -ENODEV;
1105 
1106 	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
1107 }
1108 
1109 static int toshiba_usb_three_set(struct toshiba_acpi_dev *dev, u32 state)
1110 {
1111 	u32 result;
1112 
1113 	if (!sci_open(dev))
1114 		return -EIO;
1115 
1116 	result = sci_write(dev, SCI_USB_THREE, state);
1117 	sci_close(dev);
1118 	if (result == TOS_FAILURE)
1119 		pr_err("ACPI call to set USB 3 failed\n");
1120 	else if (result == TOS_NOT_SUPPORTED)
1121 		return -ENODEV;
1122 
1123 	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
1124 }
1125 
1126 /* Hotkey Event type */
1127 static int toshiba_hotkey_event_type_get(struct toshiba_acpi_dev *dev,
1128 					 u32 *type)
1129 {
1130 	u32 in[TCI_WORDS] = { HCI_GET, HCI_SYSTEM_INFO, 0x03, 0, 0, 0 };
1131 	u32 out[TCI_WORDS];
1132 	acpi_status status;
1133 
1134 	status = tci_raw(dev, in, out);
1135 	if (ACPI_FAILURE(status)) {
1136 		pr_err("ACPI call to get System type failed\n");
1137 		return -EIO;
1138 	}
1139 
1140 	if (out[0] == TOS_NOT_SUPPORTED)
1141 		return -ENODEV;
1142 
1143 	if (out[0] != TOS_SUCCESS)
1144 		return -EIO;
1145 
1146 	*type = out[3];
1147 
1148 	return 0;
1149 }
1150 
1151 /* Wireless status (RFKill, WLAN, BT, WWAN) */
1152 static int toshiba_wireless_status(struct toshiba_acpi_dev *dev)
1153 {
1154 	u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 };
1155 	u32 out[TCI_WORDS];
1156 	acpi_status status;
1157 
1158 	in[3] = HCI_WIRELESS_STATUS;
1159 	status = tci_raw(dev, in, out);
1160 
1161 	if (ACPI_FAILURE(status)) {
1162 		pr_err("ACPI call to get Wireless status failed\n");
1163 		return -EIO;
1164 	}
1165 
1166 	if (out[0] == TOS_NOT_SUPPORTED)
1167 		return -ENODEV;
1168 
1169 	if (out[0] != TOS_SUCCESS)
1170 		return -EIO;
1171 
1172 	dev->killswitch = !!(out[2] & HCI_WIRELESS_STATUS);
1173 
1174 	return 0;
1175 }
1176 
1177 /* WWAN */
1178 static void toshiba_wwan_available(struct toshiba_acpi_dev *dev)
1179 {
1180 	u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 };
1181 	u32 out[TCI_WORDS];
1182 	acpi_status status;
1183 
1184 	dev->wwan_supported = 0;
1185 
1186 	/*
1187 	 * WWAN support can be queried by setting the in[3] value to
1188 	 * HCI_WIRELESS_WWAN (0x03).
1189 	 *
1190 	 * If supported, out[0] contains TOS_SUCCESS and out[2] contains
1191 	 * HCI_WIRELESS_WWAN_STATUS (0x2000).
1192 	 *
1193 	 * If not supported, out[0] contains TOS_INPUT_DATA_ERROR (0x8300)
1194 	 * or TOS_NOT_SUPPORTED (0x8000).
1195 	 */
1196 	in[3] = HCI_WIRELESS_WWAN;
1197 	status = tci_raw(dev, in, out);
1198 	if (ACPI_FAILURE(status)) {
1199 		pr_err("ACPI call to get WWAN status failed\n");
1200 		return;
1201 	}
1202 
1203 	if (out[0] != TOS_SUCCESS)
1204 		return;
1205 
1206 	dev->wwan_supported = (out[2] == HCI_WIRELESS_WWAN_STATUS);
1207 }
1208 
1209 static int toshiba_wwan_set(struct toshiba_acpi_dev *dev, u32 state)
1210 {
1211 	u32 in[TCI_WORDS] = { HCI_SET, HCI_WIRELESS, state, 0, 0, 0 };
1212 	u32 out[TCI_WORDS];
1213 	acpi_status status;
1214 
1215 	in[3] = HCI_WIRELESS_WWAN_STATUS;
1216 	status = tci_raw(dev, in, out);
1217 	if (ACPI_FAILURE(status)) {
1218 		pr_err("ACPI call to set WWAN status failed\n");
1219 		return -EIO;
1220 	}
1221 
1222 	if (out[0] == TOS_NOT_SUPPORTED)
1223 		return -ENODEV;
1224 
1225 	if (out[0] != TOS_SUCCESS)
1226 		return -EIO;
1227 
1228 	/*
1229 	 * Some devices only need to call HCI_WIRELESS_WWAN_STATUS to
1230 	 * (de)activate the device, but some others need the
1231 	 * HCI_WIRELESS_WWAN_POWER call as well.
1232 	 */
1233 	in[3] = HCI_WIRELESS_WWAN_POWER;
1234 	status = tci_raw(dev, in, out);
1235 	if (ACPI_FAILURE(status)) {
1236 		pr_err("ACPI call to set WWAN power failed\n");
1237 		return -EIO;
1238 	}
1239 
1240 	if (out[0] == TOS_NOT_SUPPORTED)
1241 		return -ENODEV;
1242 
1243 	return out[0] == TOS_SUCCESS ? 0 : -EIO;
1244 }
1245 
1246 /* Cooling Method */
1247 static void toshiba_cooling_method_available(struct toshiba_acpi_dev *dev)
1248 {
1249 	u32 in[TCI_WORDS] = { HCI_GET, HCI_COOLING_METHOD, 0, 0, 0, 0 };
1250 	u32 out[TCI_WORDS];
1251 	acpi_status status;
1252 
1253 	dev->cooling_method_supported = 0;
1254 	dev->max_cooling_method = 0;
1255 
1256 	status = tci_raw(dev, in, out);
1257 	if (ACPI_FAILURE(status)) {
1258 		pr_err("ACPI call to get Cooling Method failed\n");
1259 		return;
1260 	}
1261 
1262 	if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2)
1263 		return;
1264 
1265 	dev->cooling_method_supported = 1;
1266 	dev->max_cooling_method = out[3];
1267 }
1268 
1269 static int toshiba_cooling_method_get(struct toshiba_acpi_dev *dev, u32 *state)
1270 {
1271 	u32 result = hci_read(dev, HCI_COOLING_METHOD, state);
1272 
1273 	if (result == TOS_FAILURE)
1274 		pr_err("ACPI call to get Cooling Method failed\n");
1275 
1276 	if (result == TOS_NOT_SUPPORTED)
1277 		return -ENODEV;
1278 
1279 	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
1280 }
1281 
1282 static int toshiba_cooling_method_set(struct toshiba_acpi_dev *dev, u32 state)
1283 {
1284 	u32 result = hci_write(dev, HCI_COOLING_METHOD, state);
1285 
1286 	if (result == TOS_FAILURE)
1287 		pr_err("ACPI call to set Cooling Method failed\n");
1288 
1289 	if (result == TOS_NOT_SUPPORTED)
1290 		return -ENODEV;
1291 
1292 	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
1293 }
1294 
1295 /* Battery charge control */
1296 static void toshiba_battery_charge_mode_available(struct toshiba_acpi_dev *dev)
1297 {
1298 	u32 in[TCI_WORDS] = { HCI_GET, HCI_BATTERY_CHARGE_MODE, 0, 0, 0, 0 };
1299 	u32 out[TCI_WORDS];
1300 	acpi_status status;
1301 
1302 	dev->battery_charge_mode_supported = 0;
1303 
1304 	status = tci_raw(dev, in, out);
1305 	if (ACPI_FAILURE(status)) {
1306 		pr_err("ACPI call to get Battery Charge Mode failed\n");
1307 		return;
1308 	}
1309 
1310 	if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2)
1311 		return;
1312 
1313 	dev->battery_charge_mode_supported = 1;
1314 }
1315 
1316 static int toshiba_battery_charge_mode_get(struct toshiba_acpi_dev *dev, u32 *state)
1317 {
1318 	u32 in[TCI_WORDS] = { HCI_GET, HCI_BATTERY_CHARGE_MODE, 0, 0, 0, 0x1 };
1319 	u32 out[TCI_WORDS];
1320 	int retries = 3;
1321 
1322 	do {
1323 		acpi_status status = tci_raw(dev, in, out);
1324 
1325 		if (ACPI_FAILURE(status))
1326 			pr_err("ACPI call to get Battery Charge Mode failed\n");
1327 		switch (out[0]) {
1328 		case TOS_SUCCESS:
1329 		case TOS_SUCCESS2:
1330 			*state = out[2];
1331 			return 0;
1332 		case TOS_NOT_SUPPORTED:
1333 			return -ENODEV;
1334 		case TOS_DATA_NOT_AVAILABLE:
1335 			retries--;
1336 			break;
1337 		default:
1338 			return -EIO;
1339 		}
1340 	} while (retries);
1341 
1342 	return -EIO;
1343 }
1344 
1345 static int toshiba_battery_charge_mode_set(struct toshiba_acpi_dev *dev, u32 state)
1346 {
1347 	u32 result = hci_write(dev, HCI_BATTERY_CHARGE_MODE, state);
1348 
1349 	if (result == TOS_FAILURE)
1350 		pr_err("ACPI call to set Battery Charge Mode failed\n");
1351 
1352 	if (result == TOS_NOT_SUPPORTED)
1353 		return -ENODEV;
1354 
1355 	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
1356 }
1357 
1358 /* Transflective Backlight */
1359 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 *status)
1360 {
1361 	u32 result = hci_read(dev, HCI_TR_BACKLIGHT, status);
1362 
1363 	if (result == TOS_FAILURE)
1364 		pr_err("ACPI call to get Transflective Backlight failed\n");
1365 	else if (result == TOS_NOT_SUPPORTED)
1366 		return -ENODEV;
1367 
1368 	return result == TOS_SUCCESS ? 0 : -EIO;
1369 }
1370 
1371 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 status)
1372 {
1373 	u32 result = hci_write(dev, HCI_TR_BACKLIGHT, !status);
1374 
1375 	if (result == TOS_FAILURE)
1376 		pr_err("ACPI call to set Transflective Backlight failed\n");
1377 	else if (result == TOS_NOT_SUPPORTED)
1378 		return -ENODEV;
1379 
1380 	return result == TOS_SUCCESS ? 0 : -EIO;
1381 }
1382 
1383 static struct proc_dir_entry *toshiba_proc_dir;
1384 
1385 /* LCD Brightness */
1386 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
1387 {
1388 	int brightness = 0;
1389 	u32 result;
1390 	u32 value;
1391 
1392 	if (dev->tr_backlight_supported) {
1393 		int ret = get_tr_backlight_status(dev, &value);
1394 
1395 		if (ret)
1396 			return ret;
1397 		if (value)
1398 			return 0;
1399 		brightness++;
1400 	}
1401 
1402 	result = hci_read(dev, HCI_LCD_BRIGHTNESS, &value);
1403 	if (result == TOS_FAILURE)
1404 		pr_err("ACPI call to get LCD Brightness failed\n");
1405 	else if (result == TOS_NOT_SUPPORTED)
1406 		return -ENODEV;
1407 
1408 	return result == TOS_SUCCESS ?
1409 			brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT) :
1410 			-EIO;
1411 }
1412 
1413 static int get_lcd_brightness(struct backlight_device *bd)
1414 {
1415 	struct toshiba_acpi_dev *dev = bl_get_data(bd);
1416 
1417 	return __get_lcd_brightness(dev);
1418 }
1419 
1420 static int lcd_proc_show(struct seq_file *m, void *v)
1421 {
1422 	struct toshiba_acpi_dev *dev = m->private;
1423 	int levels;
1424 	int value;
1425 
1426 	if (!dev->backlight_dev)
1427 		return -ENODEV;
1428 
1429 	levels = dev->backlight_dev->props.max_brightness + 1;
1430 	value = get_lcd_brightness(dev->backlight_dev);
1431 	if (value < 0) {
1432 		pr_err("Error reading LCD brightness\n");
1433 		return value;
1434 	}
1435 
1436 	seq_printf(m, "brightness:              %d\n", value);
1437 	seq_printf(m, "brightness_levels:       %d\n", levels);
1438 
1439 	return 0;
1440 }
1441 
1442 static int lcd_proc_open(struct inode *inode, struct file *file)
1443 {
1444 	return single_open(file, lcd_proc_show, pde_data(inode));
1445 }
1446 
1447 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
1448 {
1449 	u32 result;
1450 
1451 	if (dev->tr_backlight_supported) {
1452 		int ret = set_tr_backlight_status(dev, !value);
1453 
1454 		if (ret)
1455 			return ret;
1456 		if (value)
1457 			value--;
1458 	}
1459 
1460 	value = value << HCI_LCD_BRIGHTNESS_SHIFT;
1461 	result = hci_write(dev, HCI_LCD_BRIGHTNESS, value);
1462 	if (result == TOS_FAILURE)
1463 		pr_err("ACPI call to set LCD Brightness failed\n");
1464 	else if (result == TOS_NOT_SUPPORTED)
1465 		return -ENODEV;
1466 
1467 	return result == TOS_SUCCESS ? 0 : -EIO;
1468 }
1469 
1470 static int set_lcd_status(struct backlight_device *bd)
1471 {
1472 	struct toshiba_acpi_dev *dev = bl_get_data(bd);
1473 
1474 	return set_lcd_brightness(dev, bd->props.brightness);
1475 }
1476 
1477 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
1478 			      size_t count, loff_t *pos)
1479 {
1480 	struct toshiba_acpi_dev *dev = pde_data(file_inode(file));
1481 	char cmd[42];
1482 	size_t len;
1483 	int levels;
1484 	int value;
1485 
1486 	len = min(count, sizeof(cmd) - 1);
1487 	if (copy_from_user(cmd, buf, len))
1488 		return -EFAULT;
1489 	cmd[len] = '\0';
1490 
1491 	levels = dev->backlight_dev->props.max_brightness + 1;
1492 	if (sscanf(cmd, " brightness : %i", &value) != 1 &&
1493 	    value < 0 && value > levels)
1494 		return -EINVAL;
1495 
1496 	if (set_lcd_brightness(dev, value))
1497 		return -EIO;
1498 
1499 	return count;
1500 }
1501 
1502 static const struct proc_ops lcd_proc_ops = {
1503 	.proc_open	= lcd_proc_open,
1504 	.proc_read	= seq_read,
1505 	.proc_lseek	= seq_lseek,
1506 	.proc_release	= single_release,
1507 	.proc_write	= lcd_proc_write,
1508 };
1509 
1510 /* Video-Out */
1511 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
1512 {
1513 	u32 result = hci_read(dev, HCI_VIDEO_OUT, status);
1514 
1515 	if (result == TOS_FAILURE)
1516 		pr_err("ACPI call to get Video-Out failed\n");
1517 	else if (result == TOS_NOT_SUPPORTED)
1518 		return -ENODEV;
1519 
1520 	return result == TOS_SUCCESS ? 0 : -EIO;
1521 }
1522 
1523 static int video_proc_show(struct seq_file *m, void *v)
1524 {
1525 	struct toshiba_acpi_dev *dev = m->private;
1526 	int is_lcd, is_crt, is_tv;
1527 	u32 value;
1528 
1529 	if (get_video_status(dev, &value))
1530 		return -EIO;
1531 
1532 	is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
1533 	is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
1534 	is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
1535 
1536 	seq_printf(m, "lcd_out:                 %d\n", is_lcd);
1537 	seq_printf(m, "crt_out:                 %d\n", is_crt);
1538 	seq_printf(m, "tv_out:                  %d\n", is_tv);
1539 
1540 	return 0;
1541 }
1542 
1543 static int video_proc_open(struct inode *inode, struct file *file)
1544 {
1545 	return single_open(file, video_proc_show, pde_data(inode));
1546 }
1547 
1548 static ssize_t video_proc_write(struct file *file, const char __user *buf,
1549 				size_t count, loff_t *pos)
1550 {
1551 	struct toshiba_acpi_dev *dev = pde_data(file_inode(file));
1552 	char *buffer;
1553 	char *cmd;
1554 	int lcd_out = -1, crt_out = -1, tv_out = -1;
1555 	int remain = count;
1556 	int value;
1557 	int ret;
1558 	u32 video_out;
1559 
1560 	cmd = memdup_user_nul(buf, count);
1561 	if (IS_ERR(cmd))
1562 		return PTR_ERR(cmd);
1563 
1564 	buffer = cmd;
1565 
1566 	/*
1567 	 * Scan expression.  Multiple expressions may be delimited with ;
1568 	 * NOTE: To keep scanning simple, invalid fields are ignored.
1569 	 */
1570 	while (remain) {
1571 		if (sscanf(buffer, " lcd_out : %i", &value) == 1)
1572 			lcd_out = value & 1;
1573 		else if (sscanf(buffer, " crt_out : %i", &value) == 1)
1574 			crt_out = value & 1;
1575 		else if (sscanf(buffer, " tv_out : %i", &value) == 1)
1576 			tv_out = value & 1;
1577 		/* Advance to one character past the next ; */
1578 		do {
1579 			++buffer;
1580 			--remain;
1581 		} while (remain && *(buffer - 1) != ';');
1582 	}
1583 
1584 	kfree(cmd);
1585 
1586 	ret = get_video_status(dev, &video_out);
1587 	if (!ret) {
1588 		unsigned int new_video_out = video_out;
1589 
1590 		if (lcd_out != -1)
1591 			_set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
1592 		if (crt_out != -1)
1593 			_set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
1594 		if (tv_out != -1)
1595 			_set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
1596 		/*
1597 		 * To avoid unnecessary video disruption, only write the new
1598 		 * video setting if something changed.
1599 		 */
1600 		if (new_video_out != video_out)
1601 			ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
1602 	}
1603 
1604 	return ret ? -EIO : count;
1605 }
1606 
1607 static const struct proc_ops video_proc_ops = {
1608 	.proc_open	= video_proc_open,
1609 	.proc_read	= seq_read,
1610 	.proc_lseek	= seq_lseek,
1611 	.proc_release	= single_release,
1612 	.proc_write	= video_proc_write,
1613 };
1614 
1615 /* Fan status */
1616 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
1617 {
1618 	u32 result = hci_read(dev, HCI_FAN, status);
1619 
1620 	if (result == TOS_FAILURE)
1621 		pr_err("ACPI call to get Fan status failed\n");
1622 	else if (result == TOS_NOT_SUPPORTED)
1623 		return -ENODEV;
1624 
1625 	return result == TOS_SUCCESS ? 0 : -EIO;
1626 }
1627 
1628 static int set_fan_status(struct toshiba_acpi_dev *dev, u32 status)
1629 {
1630 	u32 result = hci_write(dev, HCI_FAN, status);
1631 
1632 	if (result == TOS_FAILURE)
1633 		pr_err("ACPI call to set Fan status failed\n");
1634 	else if (result == TOS_NOT_SUPPORTED)
1635 		return -ENODEV;
1636 
1637 	return result == TOS_SUCCESS ? 0 : -EIO;
1638 }
1639 
1640 static int fan_proc_show(struct seq_file *m, void *v)
1641 {
1642 	struct toshiba_acpi_dev *dev = m->private;
1643 	u32 value;
1644 
1645 	if (get_fan_status(dev, &value))
1646 		return -EIO;
1647 
1648 	seq_printf(m, "running:                 %d\n", (value > 0));
1649 	seq_printf(m, "force_on:                %d\n", dev->force_fan);
1650 
1651 	return 0;
1652 }
1653 
1654 static int fan_proc_open(struct inode *inode, struct file *file)
1655 {
1656 	return single_open(file, fan_proc_show, pde_data(inode));
1657 }
1658 
1659 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
1660 			      size_t count, loff_t *pos)
1661 {
1662 	struct toshiba_acpi_dev *dev = pde_data(file_inode(file));
1663 	char cmd[42];
1664 	size_t len;
1665 	int value;
1666 
1667 	len = min(count, sizeof(cmd) - 1);
1668 	if (copy_from_user(cmd, buf, len))
1669 		return -EFAULT;
1670 	cmd[len] = '\0';
1671 
1672 	if (sscanf(cmd, " force_on : %i", &value) != 1 &&
1673 	    value != 0 && value != 1)
1674 		return -EINVAL;
1675 
1676 	if (set_fan_status(dev, value))
1677 		return -EIO;
1678 
1679 	dev->force_fan = value;
1680 
1681 	return count;
1682 }
1683 
1684 static const struct proc_ops fan_proc_ops = {
1685 	.proc_open	= fan_proc_open,
1686 	.proc_read	= seq_read,
1687 	.proc_lseek	= seq_lseek,
1688 	.proc_release	= single_release,
1689 	.proc_write	= fan_proc_write,
1690 };
1691 
1692 /* Fan RPM */
1693 static int get_fan_rpm(struct toshiba_acpi_dev *dev, u32 *rpm)
1694 {
1695 	u32 in[TCI_WORDS] = { HCI_GET, HCI_FAN_RPM, 0, 1, 0, 0 };
1696 	u32 out[TCI_WORDS];
1697 	acpi_status status = tci_raw(dev, in, out);
1698 
1699 	if (ACPI_FAILURE(status)) {
1700 		pr_err("ACPI call to get Fan speed failed\n");
1701 		return -EIO;
1702 	}
1703 
1704 	if (out[0] == TOS_NOT_SUPPORTED)
1705 		return -ENODEV;
1706 
1707 	if (out[0] == TOS_SUCCESS) {
1708 		*rpm = out[2];
1709 		return 0;
1710 	}
1711 
1712 	return -EIO;
1713 }
1714 
1715 static int keys_proc_show(struct seq_file *m, void *v)
1716 {
1717 	struct toshiba_acpi_dev *dev = m->private;
1718 
1719 	seq_printf(m, "hotkey_ready:            %d\n", dev->key_event_valid);
1720 	seq_printf(m, "hotkey:                  0x%04x\n", dev->last_key_event);
1721 
1722 	return 0;
1723 }
1724 
1725 static int keys_proc_open(struct inode *inode, struct file *file)
1726 {
1727 	return single_open(file, keys_proc_show, pde_data(inode));
1728 }
1729 
1730 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
1731 			       size_t count, loff_t *pos)
1732 {
1733 	struct toshiba_acpi_dev *dev = pde_data(file_inode(file));
1734 	char cmd[42];
1735 	size_t len;
1736 	int value;
1737 
1738 	len = min(count, sizeof(cmd) - 1);
1739 	if (copy_from_user(cmd, buf, len))
1740 		return -EFAULT;
1741 	cmd[len] = '\0';
1742 
1743 	if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0)
1744 		dev->key_event_valid = 0;
1745 	else
1746 		return -EINVAL;
1747 
1748 	return count;
1749 }
1750 
1751 static const struct proc_ops keys_proc_ops = {
1752 	.proc_open	= keys_proc_open,
1753 	.proc_read	= seq_read,
1754 	.proc_lseek	= seq_lseek,
1755 	.proc_release	= single_release,
1756 	.proc_write	= keys_proc_write,
1757 };
1758 
1759 static int __maybe_unused version_proc_show(struct seq_file *m, void *v)
1760 {
1761 	seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
1762 	seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
1763 	return 0;
1764 }
1765 
1766 /*
1767  * Proc and module init
1768  */
1769 
1770 #define PROC_TOSHIBA		"toshiba"
1771 
1772 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
1773 {
1774 	if (dev->backlight_dev)
1775 		proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1776 				 &lcd_proc_ops, dev);
1777 	if (dev->video_supported)
1778 		proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1779 				 &video_proc_ops, dev);
1780 	if (dev->fan_supported)
1781 		proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1782 				 &fan_proc_ops, dev);
1783 	if (dev->hotkey_dev)
1784 		proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1785 				 &keys_proc_ops, dev);
1786 	proc_create_single_data("version", S_IRUGO, toshiba_proc_dir,
1787 			version_proc_show, dev);
1788 }
1789 
1790 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
1791 {
1792 	if (dev->backlight_dev)
1793 		remove_proc_entry("lcd", toshiba_proc_dir);
1794 	if (dev->video_supported)
1795 		remove_proc_entry("video", toshiba_proc_dir);
1796 	if (dev->fan_supported)
1797 		remove_proc_entry("fan", toshiba_proc_dir);
1798 	if (dev->hotkey_dev)
1799 		remove_proc_entry("keys", toshiba_proc_dir);
1800 	remove_proc_entry("version", toshiba_proc_dir);
1801 }
1802 
1803 static const struct backlight_ops toshiba_backlight_data = {
1804 	.options = BL_CORE_SUSPENDRESUME,
1805 	.get_brightness = get_lcd_brightness,
1806 	.update_status  = set_lcd_status,
1807 };
1808 
1809 /* Keyboard backlight work */
1810 static void toshiba_acpi_kbd_bl_work(struct work_struct *work);
1811 
1812 static DECLARE_WORK(kbd_bl_work, toshiba_acpi_kbd_bl_work);
1813 
1814 /*
1815  * Sysfs files
1816  */
1817 static ssize_t version_show(struct device *dev,
1818 			    struct device_attribute *attr, char *buf)
1819 {
1820 	return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION);
1821 }
1822 static DEVICE_ATTR_RO(version);
1823 
1824 static ssize_t fan_store(struct device *dev,
1825 			 struct device_attribute *attr,
1826 			 const char *buf, size_t count)
1827 {
1828 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1829 	int state;
1830 	int ret;
1831 
1832 	ret = kstrtoint(buf, 0, &state);
1833 	if (ret)
1834 		return ret;
1835 
1836 	if (state != 0 && state != 1)
1837 		return -EINVAL;
1838 
1839 	ret = set_fan_status(toshiba, state);
1840 	if (ret)
1841 		return ret;
1842 
1843 	return count;
1844 }
1845 
1846 static ssize_t fan_show(struct device *dev,
1847 			struct device_attribute *attr, char *buf)
1848 {
1849 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1850 	u32 value;
1851 	int ret;
1852 
1853 	ret = get_fan_status(toshiba, &value);
1854 	if (ret)
1855 		return ret;
1856 
1857 	return sprintf(buf, "%d\n", value);
1858 }
1859 static DEVICE_ATTR_RW(fan);
1860 
1861 static ssize_t kbd_backlight_mode_store(struct device *dev,
1862 					struct device_attribute *attr,
1863 					const char *buf, size_t count)
1864 {
1865 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1866 	int mode;
1867 	int ret;
1868 
1869 
1870 	ret = kstrtoint(buf, 0, &mode);
1871 	if (ret)
1872 		return ret;
1873 
1874 	/* Check for supported modes depending on keyboard backlight type */
1875 	if (toshiba->kbd_type == 1) {
1876 		/* Type 1 supports SCI_KBD_MODE_FNZ and SCI_KBD_MODE_AUTO */
1877 		if (mode != SCI_KBD_MODE_FNZ && mode != SCI_KBD_MODE_AUTO)
1878 			return -EINVAL;
1879 	} else if (toshiba->kbd_type == 2) {
1880 		/* Type 2 doesn't support SCI_KBD_MODE_FNZ */
1881 		if (mode != SCI_KBD_MODE_AUTO && mode != SCI_KBD_MODE_ON &&
1882 		    mode != SCI_KBD_MODE_OFF)
1883 			return -EINVAL;
1884 	}
1885 
1886 	/*
1887 	 * Set the Keyboard Backlight Mode where:
1888 	 *	Auto - KBD backlight turns off automatically in given time
1889 	 *	FN-Z - KBD backlight "toggles" when hotkey pressed
1890 	 *	ON   - KBD backlight is always on
1891 	 *	OFF  - KBD backlight is always off
1892 	 */
1893 
1894 	/* Only make a change if the actual mode has changed */
1895 	if (toshiba->kbd_mode != mode) {
1896 		/* Shift the time to "base time" (0x3c0000 == 60 seconds) */
1897 		int time = toshiba->kbd_time << HCI_MISC_SHIFT;
1898 
1899 		/* OR the "base time" to the actual method format */
1900 		if (toshiba->kbd_type == 1) {
1901 			/* Type 1 requires the current mode */
1902 			time |= toshiba->kbd_mode;
1903 		} else if (toshiba->kbd_type == 2) {
1904 			/* Type 2 requires the desired mode */
1905 			time |= mode;
1906 		}
1907 
1908 		ret = toshiba_kbd_illum_status_set(toshiba, time);
1909 		if (ret)
1910 			return ret;
1911 
1912 		toshiba->kbd_mode = mode;
1913 		toshiba_acpi->kbd_mode = mode;
1914 
1915 		/*
1916 		 * Some laptop models with the second generation backlit
1917 		 * keyboard (type 2) do not generate the keyboard backlight
1918 		 * changed event (0x92), and thus, the driver will never update
1919 		 * the sysfs entries.
1920 		 *
1921 		 * The event is generated right when changing the keyboard
1922 		 * backlight mode and the *notify function will set the
1923 		 * kbd_event_generated to true.
1924 		 *
1925 		 * In case the event is not generated, schedule the keyboard
1926 		 * backlight work to update the sysfs entries and emulate the
1927 		 * event via genetlink.
1928 		 */
1929 		if (toshiba->kbd_type == 2 &&
1930 		    !toshiba->kbd_event_generated)
1931 			schedule_work(&kbd_bl_work);
1932 	}
1933 
1934 	return count;
1935 }
1936 
1937 static ssize_t kbd_backlight_mode_show(struct device *dev,
1938 				       struct device_attribute *attr,
1939 				       char *buf)
1940 {
1941 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1942 	u32 time;
1943 
1944 	if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
1945 		return -EIO;
1946 
1947 	return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK);
1948 }
1949 static DEVICE_ATTR_RW(kbd_backlight_mode);
1950 
1951 static ssize_t kbd_type_show(struct device *dev,
1952 			     struct device_attribute *attr, char *buf)
1953 {
1954 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1955 
1956 	return sprintf(buf, "%d\n", toshiba->kbd_type);
1957 }
1958 static DEVICE_ATTR_RO(kbd_type);
1959 
1960 static ssize_t available_kbd_modes_show(struct device *dev,
1961 					struct device_attribute *attr,
1962 					char *buf)
1963 {
1964 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1965 
1966 	if (toshiba->kbd_type == 1)
1967 		return sprintf(buf, "0x%x 0x%x\n",
1968 			       SCI_KBD_MODE_FNZ, SCI_KBD_MODE_AUTO);
1969 
1970 	return sprintf(buf, "0x%x 0x%x 0x%x\n",
1971 		       SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF);
1972 }
1973 static DEVICE_ATTR_RO(available_kbd_modes);
1974 
1975 static ssize_t kbd_backlight_timeout_store(struct device *dev,
1976 					   struct device_attribute *attr,
1977 					   const char *buf, size_t count)
1978 {
1979 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1980 	int time;
1981 	int ret;
1982 
1983 	ret = kstrtoint(buf, 0, &time);
1984 	if (ret)
1985 		return ret;
1986 
1987 	/* Check for supported values depending on kbd_type */
1988 	if (toshiba->kbd_type == 1) {
1989 		if (time < 0 || time > 60)
1990 			return -EINVAL;
1991 	} else if (toshiba->kbd_type == 2) {
1992 		if (time < 1 || time > 60)
1993 			return -EINVAL;
1994 	}
1995 
1996 	/* Set the Keyboard Backlight Timeout */
1997 
1998 	/* Only make a change if the actual timeout has changed */
1999 	if (toshiba->kbd_time != time) {
2000 		/* Shift the time to "base time" (0x3c0000 == 60 seconds) */
2001 		time = time << HCI_MISC_SHIFT;
2002 		/* OR the "base time" to the actual method format */
2003 		if (toshiba->kbd_type == 1)
2004 			time |= SCI_KBD_MODE_FNZ;
2005 		else if (toshiba->kbd_type == 2)
2006 			time |= SCI_KBD_MODE_AUTO;
2007 
2008 		ret = toshiba_kbd_illum_status_set(toshiba, time);
2009 		if (ret)
2010 			return ret;
2011 
2012 		toshiba->kbd_time = time >> HCI_MISC_SHIFT;
2013 	}
2014 
2015 	return count;
2016 }
2017 
2018 static ssize_t kbd_backlight_timeout_show(struct device *dev,
2019 					  struct device_attribute *attr,
2020 					  char *buf)
2021 {
2022 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2023 	u32 time;
2024 
2025 	if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
2026 		return -EIO;
2027 
2028 	return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT);
2029 }
2030 static DEVICE_ATTR_RW(kbd_backlight_timeout);
2031 
2032 static ssize_t touchpad_store(struct device *dev,
2033 			      struct device_attribute *attr,
2034 			      const char *buf, size_t count)
2035 {
2036 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2037 	int state;
2038 	int ret;
2039 
2040 	/* Set the TouchPad on/off, 0 - Disable | 1 - Enable */
2041 	ret = kstrtoint(buf, 0, &state);
2042 	if (ret)
2043 		return ret;
2044 	if (state != 0 && state != 1)
2045 		return -EINVAL;
2046 
2047 	ret = toshiba_touchpad_set(toshiba, state);
2048 	if (ret)
2049 		return ret;
2050 
2051 	return count;
2052 }
2053 
2054 static ssize_t touchpad_show(struct device *dev,
2055 			     struct device_attribute *attr, char *buf)
2056 {
2057 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2058 	u32 state;
2059 	int ret;
2060 
2061 	ret = toshiba_touchpad_get(toshiba, &state);
2062 	if (ret < 0)
2063 		return ret;
2064 
2065 	return sprintf(buf, "%i\n", state);
2066 }
2067 static DEVICE_ATTR_RW(touchpad);
2068 
2069 static ssize_t usb_sleep_charge_show(struct device *dev,
2070 				     struct device_attribute *attr, char *buf)
2071 {
2072 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2073 	u32 mode;
2074 	int ret;
2075 
2076 	ret = toshiba_usb_sleep_charge_get(toshiba, &mode);
2077 	if (ret < 0)
2078 		return ret;
2079 
2080 	return sprintf(buf, "%x\n", mode & SCI_USB_CHARGE_MODE_MASK);
2081 }
2082 
2083 static ssize_t usb_sleep_charge_store(struct device *dev,
2084 				      struct device_attribute *attr,
2085 				      const char *buf, size_t count)
2086 {
2087 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2088 	int state;
2089 	u32 mode;
2090 	int ret;
2091 
2092 	ret = kstrtoint(buf, 0, &state);
2093 	if (ret)
2094 		return ret;
2095 	/*
2096 	 * Check for supported values, where:
2097 	 * 0 - Disabled
2098 	 * 1 - Alternate (Non USB conformant devices that require more power)
2099 	 * 2 - Auto (USB conformant devices)
2100 	 * 3 - Typical
2101 	 */
2102 	if (state != 0 && state != 1 && state != 2 && state != 3)
2103 		return -EINVAL;
2104 
2105 	/* Set the USB charging mode to internal value */
2106 	mode = toshiba->usbsc_mode_base;
2107 	if (state == 0)
2108 		mode |= SCI_USB_CHARGE_DISABLED;
2109 	else if (state == 1)
2110 		mode |= SCI_USB_CHARGE_ALTERNATE;
2111 	else if (state == 2)
2112 		mode |= SCI_USB_CHARGE_AUTO;
2113 	else if (state == 3)
2114 		mode |= SCI_USB_CHARGE_TYPICAL;
2115 
2116 	ret = toshiba_usb_sleep_charge_set(toshiba, mode);
2117 	if (ret)
2118 		return ret;
2119 
2120 	return count;
2121 }
2122 static DEVICE_ATTR_RW(usb_sleep_charge);
2123 
2124 static ssize_t sleep_functions_on_battery_show(struct device *dev,
2125 					       struct device_attribute *attr,
2126 					       char *buf)
2127 {
2128 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2129 	int bat_lvl, status;
2130 	u32 state;
2131 	int ret;
2132 	int tmp;
2133 
2134 	ret = toshiba_sleep_functions_status_get(toshiba, &state);
2135 	if (ret < 0)
2136 		return ret;
2137 
2138 	/* Determine the status: 0x4 - Enabled | 0x1 - Disabled */
2139 	tmp = state & SCI_USB_CHARGE_BAT_MASK;
2140 	status = (tmp == 0x4) ? 1 : 0;
2141 	/* Determine the battery level set */
2142 	bat_lvl = state >> HCI_MISC_SHIFT;
2143 
2144 	return sprintf(buf, "%d %d\n", status, bat_lvl);
2145 }
2146 
2147 static ssize_t sleep_functions_on_battery_store(struct device *dev,
2148 						struct device_attribute *attr,
2149 						const char *buf, size_t count)
2150 {
2151 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2152 	u32 status;
2153 	int value;
2154 	int ret;
2155 	int tmp;
2156 
2157 	ret = kstrtoint(buf, 0, &value);
2158 	if (ret)
2159 		return ret;
2160 
2161 	/*
2162 	 * Set the status of the function:
2163 	 * 0 - Disabled
2164 	 * 1-100 - Enabled
2165 	 */
2166 	if (value < 0 || value > 100)
2167 		return -EINVAL;
2168 
2169 	if (value == 0) {
2170 		tmp = toshiba->usbsc_bat_level << HCI_MISC_SHIFT;
2171 		status = tmp | SCI_USB_CHARGE_BAT_LVL_OFF;
2172 	} else {
2173 		tmp = value << HCI_MISC_SHIFT;
2174 		status = tmp | SCI_USB_CHARGE_BAT_LVL_ON;
2175 	}
2176 	ret = toshiba_sleep_functions_status_set(toshiba, status);
2177 	if (ret < 0)
2178 		return ret;
2179 
2180 	toshiba->usbsc_bat_level = status >> HCI_MISC_SHIFT;
2181 
2182 	return count;
2183 }
2184 static DEVICE_ATTR_RW(sleep_functions_on_battery);
2185 
2186 static ssize_t usb_rapid_charge_show(struct device *dev,
2187 				     struct device_attribute *attr, char *buf)
2188 {
2189 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2190 	u32 state;
2191 	int ret;
2192 
2193 	ret = toshiba_usb_rapid_charge_get(toshiba, &state);
2194 	if (ret < 0)
2195 		return ret;
2196 
2197 	return sprintf(buf, "%d\n", state);
2198 }
2199 
2200 static ssize_t usb_rapid_charge_store(struct device *dev,
2201 				      struct device_attribute *attr,
2202 				      const char *buf, size_t count)
2203 {
2204 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2205 	int state;
2206 	int ret;
2207 
2208 	ret = kstrtoint(buf, 0, &state);
2209 	if (ret)
2210 		return ret;
2211 	if (state != 0 && state != 1)
2212 		return -EINVAL;
2213 
2214 	ret = toshiba_usb_rapid_charge_set(toshiba, state);
2215 	if (ret)
2216 		return ret;
2217 
2218 	return count;
2219 }
2220 static DEVICE_ATTR_RW(usb_rapid_charge);
2221 
2222 static ssize_t usb_sleep_music_show(struct device *dev,
2223 				    struct device_attribute *attr, char *buf)
2224 {
2225 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2226 	u32 state;
2227 	int ret;
2228 
2229 	ret = toshiba_usb_sleep_music_get(toshiba, &state);
2230 	if (ret < 0)
2231 		return ret;
2232 
2233 	return sprintf(buf, "%d\n", state);
2234 }
2235 
2236 static ssize_t usb_sleep_music_store(struct device *dev,
2237 				     struct device_attribute *attr,
2238 				     const char *buf, size_t count)
2239 {
2240 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2241 	int state;
2242 	int ret;
2243 
2244 	ret = kstrtoint(buf, 0, &state);
2245 	if (ret)
2246 		return ret;
2247 	if (state != 0 && state != 1)
2248 		return -EINVAL;
2249 
2250 	ret = toshiba_usb_sleep_music_set(toshiba, state);
2251 	if (ret)
2252 		return ret;
2253 
2254 	return count;
2255 }
2256 static DEVICE_ATTR_RW(usb_sleep_music);
2257 
2258 static ssize_t kbd_function_keys_show(struct device *dev,
2259 				      struct device_attribute *attr, char *buf)
2260 {
2261 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2262 	int mode;
2263 	int ret;
2264 
2265 	ret = toshiba_function_keys_get(toshiba, &mode);
2266 	if (ret < 0)
2267 		return ret;
2268 
2269 	return sprintf(buf, "%d\n", mode);
2270 }
2271 
2272 static ssize_t kbd_function_keys_store(struct device *dev,
2273 				       struct device_attribute *attr,
2274 				       const char *buf, size_t count)
2275 {
2276 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2277 	int mode;
2278 	int ret;
2279 
2280 	ret = kstrtoint(buf, 0, &mode);
2281 	if (ret)
2282 		return ret;
2283 	/*
2284 	 * Check for the function keys mode where:
2285 	 * 0 - Normal operation (F{1-12} as usual and hotkeys via FN-F{1-12})
2286 	 * 1 - Special functions (Opposite of the above setting)
2287 	 */
2288 	if (mode != 0 && mode != 1)
2289 		return -EINVAL;
2290 
2291 	ret = toshiba_function_keys_set(toshiba, mode);
2292 	if (ret)
2293 		return ret;
2294 
2295 	pr_info("Reboot for changes to KBD Function Keys to take effect");
2296 
2297 	return count;
2298 }
2299 static DEVICE_ATTR_RW(kbd_function_keys);
2300 
2301 static ssize_t panel_power_on_show(struct device *dev,
2302 				   struct device_attribute *attr, char *buf)
2303 {
2304 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2305 	u32 state;
2306 	int ret;
2307 
2308 	ret = toshiba_panel_power_on_get(toshiba, &state);
2309 	if (ret < 0)
2310 		return ret;
2311 
2312 	return sprintf(buf, "%d\n", state);
2313 }
2314 
2315 static ssize_t panel_power_on_store(struct device *dev,
2316 				    struct device_attribute *attr,
2317 				    const char *buf, size_t count)
2318 {
2319 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2320 	int state;
2321 	int ret;
2322 
2323 	ret = kstrtoint(buf, 0, &state);
2324 	if (ret)
2325 		return ret;
2326 	if (state != 0 && state != 1)
2327 		return -EINVAL;
2328 
2329 	ret = toshiba_panel_power_on_set(toshiba, state);
2330 	if (ret)
2331 		return ret;
2332 
2333 	pr_info("Reboot for changes to Panel Power ON to take effect");
2334 
2335 	return count;
2336 }
2337 static DEVICE_ATTR_RW(panel_power_on);
2338 
2339 static ssize_t usb_three_show(struct device *dev,
2340 			      struct device_attribute *attr, char *buf)
2341 {
2342 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2343 	u32 state;
2344 	int ret;
2345 
2346 	ret = toshiba_usb_three_get(toshiba, &state);
2347 	if (ret < 0)
2348 		return ret;
2349 
2350 	return sprintf(buf, "%d\n", state);
2351 }
2352 
2353 static ssize_t usb_three_store(struct device *dev,
2354 			       struct device_attribute *attr,
2355 			       const char *buf, size_t count)
2356 {
2357 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2358 	int state;
2359 	int ret;
2360 
2361 	ret = kstrtoint(buf, 0, &state);
2362 	if (ret)
2363 		return ret;
2364 	/*
2365 	 * Check for USB 3 mode where:
2366 	 * 0 - Disabled (Acts like a USB 2 port, saving power)
2367 	 * 1 - Enabled
2368 	 */
2369 	if (state != 0 && state != 1)
2370 		return -EINVAL;
2371 
2372 	ret = toshiba_usb_three_set(toshiba, state);
2373 	if (ret)
2374 		return ret;
2375 
2376 	pr_info("Reboot for changes to USB 3 to take effect");
2377 
2378 	return count;
2379 }
2380 static DEVICE_ATTR_RW(usb_three);
2381 
2382 static ssize_t cooling_method_show(struct device *dev,
2383 				   struct device_attribute *attr, char *buf)
2384 {
2385 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2386 	int state;
2387 	int ret;
2388 
2389 	ret = toshiba_cooling_method_get(toshiba, &state);
2390 	if (ret < 0)
2391 		return ret;
2392 
2393 	return sprintf(buf, "%d %d\n", state, toshiba->max_cooling_method);
2394 }
2395 
2396 static ssize_t cooling_method_store(struct device *dev,
2397 				    struct device_attribute *attr,
2398 				    const char *buf, size_t count)
2399 {
2400 	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2401 	int state;
2402 	int ret;
2403 
2404 	ret = kstrtoint(buf, 0, &state);
2405 	if (ret)
2406 		return ret;
2407 
2408 	/*
2409 	 * Check for supported values
2410 	 * Depending on the laptop model, some only support these two:
2411 	 * 0 - Maximum Performance
2412 	 * 1 - Battery Optimized
2413 	 *
2414 	 * While some others support all three methods:
2415 	 * 0 - Maximum Performance
2416 	 * 1 - Performance
2417 	 * 2 - Battery Optimized
2418 	 */
2419 	if (state < 0 || state > toshiba->max_cooling_method)
2420 		return -EINVAL;
2421 
2422 	ret = toshiba_cooling_method_set(toshiba, state);
2423 	if (ret)
2424 		return ret;
2425 
2426 	return count;
2427 }
2428 static DEVICE_ATTR_RW(cooling_method);
2429 
2430 static struct attribute *toshiba_attributes[] = {
2431 	&dev_attr_version.attr,
2432 	&dev_attr_fan.attr,
2433 	&dev_attr_kbd_backlight_mode.attr,
2434 	&dev_attr_kbd_type.attr,
2435 	&dev_attr_available_kbd_modes.attr,
2436 	&dev_attr_kbd_backlight_timeout.attr,
2437 	&dev_attr_touchpad.attr,
2438 	&dev_attr_usb_sleep_charge.attr,
2439 	&dev_attr_sleep_functions_on_battery.attr,
2440 	&dev_attr_usb_rapid_charge.attr,
2441 	&dev_attr_usb_sleep_music.attr,
2442 	&dev_attr_kbd_function_keys.attr,
2443 	&dev_attr_panel_power_on.attr,
2444 	&dev_attr_usb_three.attr,
2445 	&dev_attr_cooling_method.attr,
2446 	NULL,
2447 };
2448 
2449 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
2450 					struct attribute *attr, int idx)
2451 {
2452 	struct device *dev = kobj_to_dev(kobj);
2453 	struct toshiba_acpi_dev *drv = dev_get_drvdata(dev);
2454 	bool exists = true;
2455 
2456 	if (attr == &dev_attr_fan.attr)
2457 		exists = (drv->fan_supported) ? true : false;
2458 	else if (attr == &dev_attr_kbd_backlight_mode.attr)
2459 		exists = (drv->kbd_illum_supported) ? true : false;
2460 	else if (attr == &dev_attr_kbd_backlight_timeout.attr)
2461 		exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false;
2462 	else if (attr == &dev_attr_touchpad.attr)
2463 		exists = (drv->touchpad_supported) ? true : false;
2464 	else if (attr == &dev_attr_usb_sleep_charge.attr)
2465 		exists = (drv->usb_sleep_charge_supported) ? true : false;
2466 	else if (attr == &dev_attr_sleep_functions_on_battery.attr)
2467 		exists = (drv->usb_sleep_charge_supported) ? true : false;
2468 	else if (attr == &dev_attr_usb_rapid_charge.attr)
2469 		exists = (drv->usb_rapid_charge_supported) ? true : false;
2470 	else if (attr == &dev_attr_usb_sleep_music.attr)
2471 		exists = (drv->usb_sleep_music_supported) ? true : false;
2472 	else if (attr == &dev_attr_kbd_function_keys.attr)
2473 		exists = (drv->kbd_function_keys_supported) ? true : false;
2474 	else if (attr == &dev_attr_panel_power_on.attr)
2475 		exists = (drv->panel_power_on_supported) ? true : false;
2476 	else if (attr == &dev_attr_usb_three.attr)
2477 		exists = (drv->usb_three_supported) ? true : false;
2478 	else if (attr == &dev_attr_cooling_method.attr)
2479 		exists = (drv->cooling_method_supported) ? true : false;
2480 
2481 	return exists ? attr->mode : 0;
2482 }
2483 
2484 static const struct attribute_group toshiba_attr_group = {
2485 	.is_visible = toshiba_sysfs_is_visible,
2486 	.attrs = toshiba_attributes,
2487 };
2488 
2489 static void toshiba_acpi_kbd_bl_work(struct work_struct *work)
2490 {
2491 	/* Update the sysfs entries */
2492 	if (sysfs_update_group(&toshiba_acpi->acpi_dev->dev.kobj,
2493 			       &toshiba_attr_group))
2494 		pr_err("Unable to update sysfs entries\n");
2495 
2496 	/* Notify LED subsystem about keyboard backlight change */
2497 	if (toshiba_acpi->kbd_type == 2 &&
2498 	    toshiba_acpi->kbd_mode != SCI_KBD_MODE_AUTO)
2499 		led_classdev_notify_brightness_hw_changed(&toshiba_acpi->kbd_led,
2500 				(toshiba_acpi->kbd_mode == SCI_KBD_MODE_ON) ?
2501 				LED_FULL : LED_OFF);
2502 
2503 	/* Emulate the keyboard backlight event */
2504 	acpi_bus_generate_netlink_event(toshiba_acpi->acpi_dev->pnp.device_class,
2505 					dev_name(&toshiba_acpi->acpi_dev->dev),
2506 					0x92, 0);
2507 }
2508 
2509 /*
2510  * IIO device
2511  */
2512 
2513 enum toshiba_iio_accel_chan {
2514 	AXIS_X,
2515 	AXIS_Y,
2516 	AXIS_Z
2517 };
2518 
2519 static int toshiba_iio_accel_get_axis(enum toshiba_iio_accel_chan chan)
2520 {
2521 	u32 xyval, zval;
2522 	int ret;
2523 
2524 	ret = toshiba_accelerometer_get(toshiba_acpi, &xyval, &zval);
2525 	if (ret < 0)
2526 		return ret;
2527 
2528 	switch (chan) {
2529 	case AXIS_X:
2530 		return xyval & HCI_ACCEL_DIRECTION_MASK ?
2531 			-(xyval & HCI_ACCEL_MASK) : xyval & HCI_ACCEL_MASK;
2532 	case AXIS_Y:
2533 		return (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_DIRECTION_MASK ?
2534 			-((xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK) :
2535 			(xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK;
2536 	case AXIS_Z:
2537 		return zval & HCI_ACCEL_DIRECTION_MASK ?
2538 			-(zval & HCI_ACCEL_MASK) : zval & HCI_ACCEL_MASK;
2539 	}
2540 
2541 	return ret;
2542 }
2543 
2544 static int toshiba_iio_accel_read_raw(struct iio_dev *indio_dev,
2545 				      struct iio_chan_spec const *chan,
2546 				      int *val, int *val2, long mask)
2547 {
2548 	int ret;
2549 
2550 	switch (mask) {
2551 	case IIO_CHAN_INFO_RAW:
2552 		ret = toshiba_iio_accel_get_axis(chan->channel);
2553 		if (ret == -EIO || ret == -ENODEV)
2554 			return ret;
2555 
2556 		*val = ret;
2557 
2558 		return IIO_VAL_INT;
2559 	}
2560 
2561 	return -EINVAL;
2562 }
2563 
2564 #define TOSHIBA_IIO_ACCEL_CHANNEL(axis, chan) { \
2565 	.type = IIO_ACCEL, \
2566 	.modified = 1, \
2567 	.channel = chan, \
2568 	.channel2 = IIO_MOD_##axis, \
2569 	.output = 1, \
2570 	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
2571 }
2572 
2573 static const struct iio_chan_spec toshiba_iio_accel_channels[] = {
2574 	TOSHIBA_IIO_ACCEL_CHANNEL(X, AXIS_X),
2575 	TOSHIBA_IIO_ACCEL_CHANNEL(Y, AXIS_Y),
2576 	TOSHIBA_IIO_ACCEL_CHANNEL(Z, AXIS_Z),
2577 };
2578 
2579 static const struct iio_info toshiba_iio_accel_info = {
2580 	.read_raw = &toshiba_iio_accel_read_raw,
2581 };
2582 
2583 /*
2584  * Misc device
2585  */
2586 static int toshiba_acpi_smm_bridge(SMMRegisters *regs)
2587 {
2588 	u32 in[TCI_WORDS] = { regs->eax, regs->ebx, regs->ecx,
2589 			      regs->edx, regs->esi, regs->edi };
2590 	u32 out[TCI_WORDS];
2591 	acpi_status status;
2592 
2593 	status = tci_raw(toshiba_acpi, in, out);
2594 	if (ACPI_FAILURE(status)) {
2595 		pr_err("ACPI call to query SMM registers failed\n");
2596 		return -EIO;
2597 	}
2598 
2599 	/* Fillout the SMM struct with the TCI call results */
2600 	regs->eax = out[0];
2601 	regs->ebx = out[1];
2602 	regs->ecx = out[2];
2603 	regs->edx = out[3];
2604 	regs->esi = out[4];
2605 	regs->edi = out[5];
2606 
2607 	return 0;
2608 }
2609 
2610 static long toshiba_acpi_ioctl(struct file *fp, unsigned int cmd,
2611 			       unsigned long arg)
2612 {
2613 	SMMRegisters __user *argp = (SMMRegisters __user *)arg;
2614 	SMMRegisters regs;
2615 	int ret;
2616 
2617 	if (!argp)
2618 		return -EINVAL;
2619 
2620 	switch (cmd) {
2621 	case TOSH_SMM:
2622 		if (copy_from_user(&regs, argp, sizeof(SMMRegisters)))
2623 			return -EFAULT;
2624 		ret = toshiba_acpi_smm_bridge(&regs);
2625 		if (ret)
2626 			return ret;
2627 		if (copy_to_user(argp, &regs, sizeof(SMMRegisters)))
2628 			return -EFAULT;
2629 		break;
2630 	case TOSHIBA_ACPI_SCI:
2631 		if (copy_from_user(&regs, argp, sizeof(SMMRegisters)))
2632 			return -EFAULT;
2633 		/* Ensure we are being called with a SCI_{GET, SET} register */
2634 		if (regs.eax != SCI_GET && regs.eax != SCI_SET)
2635 			return -EINVAL;
2636 		if (!sci_open(toshiba_acpi))
2637 			return -EIO;
2638 		ret = toshiba_acpi_smm_bridge(&regs);
2639 		sci_close(toshiba_acpi);
2640 		if (ret)
2641 			return ret;
2642 		if (copy_to_user(argp, &regs, sizeof(SMMRegisters)))
2643 			return -EFAULT;
2644 		break;
2645 	default:
2646 		return -EINVAL;
2647 	}
2648 
2649 	return 0;
2650 }
2651 
2652 static const struct file_operations toshiba_acpi_fops = {
2653 	.owner		= THIS_MODULE,
2654 	.unlocked_ioctl = toshiba_acpi_ioctl,
2655 	.llseek		= noop_llseek,
2656 };
2657 
2658 /*
2659  * WWAN RFKill handlers
2660  */
2661 static int toshiba_acpi_wwan_set_block(void *data, bool blocked)
2662 {
2663 	struct toshiba_acpi_dev *dev = data;
2664 	int ret;
2665 
2666 	ret = toshiba_wireless_status(dev);
2667 	if (ret)
2668 		return ret;
2669 
2670 	if (!dev->killswitch)
2671 		return 0;
2672 
2673 	return toshiba_wwan_set(dev, !blocked);
2674 }
2675 
2676 static void toshiba_acpi_wwan_poll(struct rfkill *rfkill, void *data)
2677 {
2678 	struct toshiba_acpi_dev *dev = data;
2679 
2680 	if (toshiba_wireless_status(dev))
2681 		return;
2682 
2683 	rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch);
2684 }
2685 
2686 static const struct rfkill_ops wwan_rfk_ops = {
2687 	.set_block = toshiba_acpi_wwan_set_block,
2688 	.poll = toshiba_acpi_wwan_poll,
2689 };
2690 
2691 static int toshiba_acpi_setup_wwan_rfkill(struct toshiba_acpi_dev *dev)
2692 {
2693 	int ret = toshiba_wireless_status(dev);
2694 
2695 	if (ret)
2696 		return ret;
2697 
2698 	dev->wwan_rfk = rfkill_alloc("Toshiba WWAN",
2699 				     &dev->acpi_dev->dev,
2700 				     RFKILL_TYPE_WWAN,
2701 				     &wwan_rfk_ops,
2702 				     dev);
2703 	if (!dev->wwan_rfk) {
2704 		pr_err("Unable to allocate WWAN rfkill device\n");
2705 		return -ENOMEM;
2706 	}
2707 
2708 	rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch);
2709 
2710 	ret = rfkill_register(dev->wwan_rfk);
2711 	if (ret) {
2712 		pr_err("Unable to register WWAN rfkill device\n");
2713 		rfkill_destroy(dev->wwan_rfk);
2714 	}
2715 
2716 	return ret;
2717 }
2718 
2719 /*
2720  * Hotkeys
2721  */
2722 static int toshiba_acpi_enable_hotkeys(struct toshiba_acpi_dev *dev)
2723 {
2724 	acpi_status status;
2725 	u32 result;
2726 
2727 	status = acpi_evaluate_object(dev->acpi_dev->handle,
2728 				      "ENAB", NULL, NULL);
2729 	if (ACPI_FAILURE(status))
2730 		return -ENODEV;
2731 
2732 	/*
2733 	 * Enable the "Special Functions" mode only if they are
2734 	 * supported and if they are activated.
2735 	 */
2736 	if (dev->kbd_function_keys_supported && dev->special_functions)
2737 		result = hci_write(dev, HCI_HOTKEY_EVENT,
2738 				   HCI_HOTKEY_SPECIAL_FUNCTIONS);
2739 	else
2740 		result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE);
2741 
2742 	if (result == TOS_FAILURE)
2743 		return -EIO;
2744 	else if (result == TOS_NOT_SUPPORTED)
2745 		return -ENODEV;
2746 
2747 	return 0;
2748 }
2749 
2750 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str,
2751 				      struct serio *port)
2752 {
2753 	if (str & I8042_STR_AUXDATA)
2754 		return false;
2755 
2756 	if (unlikely(data == 0xe0))
2757 		return false;
2758 
2759 	if ((data & 0x7f) == TOS1900_FN_SCAN) {
2760 		schedule_work(&toshiba_acpi->hotkey_work);
2761 		return true;
2762 	}
2763 
2764 	return false;
2765 }
2766 
2767 static void toshiba_acpi_hotkey_work(struct work_struct *work)
2768 {
2769 	acpi_handle ec_handle = ec_get_handle();
2770 	acpi_status status;
2771 
2772 	if (!ec_handle)
2773 		return;
2774 
2775 	status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL);
2776 	if (ACPI_FAILURE(status))
2777 		pr_err("ACPI NTFY method execution failed\n");
2778 }
2779 
2780 /*
2781  * Returns hotkey scancode, or < 0 on failure.
2782  */
2783 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
2784 {
2785 	unsigned long long value;
2786 	acpi_status status;
2787 
2788 	status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO",
2789 				      NULL, &value);
2790 	if (ACPI_FAILURE(status)) {
2791 		pr_err("ACPI INFO method execution failed\n");
2792 		return -EIO;
2793 	}
2794 
2795 	return value;
2796 }
2797 
2798 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
2799 				       int scancode)
2800 {
2801 	if (scancode == 0x100)
2802 		return;
2803 
2804 	/* Act on key press; ignore key release */
2805 	if (scancode & 0x80)
2806 		return;
2807 
2808 	if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true))
2809 		pr_info("Unknown key %x\n", scancode);
2810 }
2811 
2812 static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev)
2813 {
2814 	if (dev->info_supported) {
2815 		int scancode = toshiba_acpi_query_hotkey(dev);
2816 
2817 		if (scancode < 0) {
2818 			pr_err("Failed to query hotkey event\n");
2819 		} else if (scancode != 0) {
2820 			toshiba_acpi_report_hotkey(dev, scancode);
2821 			dev->key_event_valid = 1;
2822 			dev->last_key_event = scancode;
2823 		}
2824 	} else if (dev->system_event_supported) {
2825 		u32 result;
2826 		u32 value;
2827 		int retries = 3;
2828 
2829 		do {
2830 			result = hci_read(dev, HCI_SYSTEM_EVENT, &value);
2831 			switch (result) {
2832 			case TOS_SUCCESS:
2833 				toshiba_acpi_report_hotkey(dev, (int)value);
2834 				dev->key_event_valid = 1;
2835 				dev->last_key_event = value;
2836 				break;
2837 			case TOS_NOT_SUPPORTED:
2838 				/*
2839 				 * This is a workaround for an unresolved
2840 				 * issue on some machines where system events
2841 				 * sporadically become disabled.
2842 				 */
2843 				result = hci_write(dev, HCI_SYSTEM_EVENT, 1);
2844 				if (result == TOS_SUCCESS)
2845 					pr_notice("Re-enabled hotkeys\n");
2846 				fallthrough;
2847 			default:
2848 				retries--;
2849 				break;
2850 			}
2851 		} while (retries && result != TOS_FIFO_EMPTY);
2852 	}
2853 }
2854 
2855 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
2856 {
2857 	const struct key_entry *keymap = toshiba_acpi_keymap;
2858 	acpi_handle ec_handle;
2859 	int error;
2860 
2861 	if (disable_hotkeys) {
2862 		pr_info("Hotkeys disabled by module parameter\n");
2863 		return 0;
2864 	}
2865 
2866 	if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) {
2867 		pr_info("WMI event detected, hotkeys will not be monitored\n");
2868 		return 0;
2869 	}
2870 
2871 	error = toshiba_acpi_enable_hotkeys(dev);
2872 	if (error)
2873 		return error;
2874 
2875 	if (toshiba_hotkey_event_type_get(dev, &dev->hotkey_event_type))
2876 		pr_notice("Unable to query Hotkey Event Type\n");
2877 
2878 	dev->hotkey_dev = input_allocate_device();
2879 	if (!dev->hotkey_dev)
2880 		return -ENOMEM;
2881 
2882 	dev->hotkey_dev->name = "Toshiba input device";
2883 	dev->hotkey_dev->phys = "toshiba_acpi/input0";
2884 	dev->hotkey_dev->id.bustype = BUS_HOST;
2885 	dev->hotkey_dev->dev.parent = &dev->acpi_dev->dev;
2886 
2887 	if (dev->hotkey_event_type == HCI_SYSTEM_TYPE1 ||
2888 	    !dev->kbd_function_keys_supported)
2889 		keymap = toshiba_acpi_keymap;
2890 	else if (dev->hotkey_event_type == HCI_SYSTEM_TYPE2 ||
2891 		 dev->kbd_function_keys_supported)
2892 		keymap = toshiba_acpi_alt_keymap;
2893 	else
2894 		pr_info("Unknown event type received %x\n",
2895 			dev->hotkey_event_type);
2896 	error = sparse_keymap_setup(dev->hotkey_dev, keymap, NULL);
2897 	if (error)
2898 		goto err_free_dev;
2899 
2900 	/*
2901 	 * For some machines the SCI responsible for providing hotkey
2902 	 * notification doesn't fire. We can trigger the notification
2903 	 * whenever the Fn key is pressed using the NTFY method, if
2904 	 * supported, so if it's present set up an i8042 key filter
2905 	 * for this purpose.
2906 	 */
2907 	ec_handle = ec_get_handle();
2908 	if (ec_handle && acpi_has_method(ec_handle, "NTFY")) {
2909 		INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);
2910 
2911 		error = i8042_install_filter(toshiba_acpi_i8042_filter);
2912 		if (error) {
2913 			pr_err("Error installing key filter\n");
2914 			goto err_free_dev;
2915 		}
2916 
2917 		dev->ntfy_supported = 1;
2918 	}
2919 
2920 	/*
2921 	 * Determine hotkey query interface. Prefer using the INFO
2922 	 * method when it is available.
2923 	 */
2924 	if (acpi_has_method(dev->acpi_dev->handle, "INFO"))
2925 		dev->info_supported = 1;
2926 	else if (hci_write(dev, HCI_SYSTEM_EVENT, 1) == TOS_SUCCESS)
2927 		dev->system_event_supported = 1;
2928 
2929 	if (!dev->info_supported && !dev->system_event_supported) {
2930 		pr_warn("No hotkey query interface found\n");
2931 		error = -EINVAL;
2932 		goto err_remove_filter;
2933 	}
2934 
2935 	error = input_register_device(dev->hotkey_dev);
2936 	if (error) {
2937 		pr_info("Unable to register input device\n");
2938 		goto err_remove_filter;
2939 	}
2940 
2941 	return 0;
2942 
2943  err_remove_filter:
2944 	if (dev->ntfy_supported)
2945 		i8042_remove_filter(toshiba_acpi_i8042_filter);
2946  err_free_dev:
2947 	input_free_device(dev->hotkey_dev);
2948 	dev->hotkey_dev = NULL;
2949 	return error;
2950 }
2951 
2952 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
2953 {
2954 	struct backlight_properties props;
2955 	int brightness;
2956 	int ret;
2957 
2958 	/*
2959 	 * Some machines don't support the backlight methods at all, and
2960 	 * others support it read-only. Either of these is pretty useless,
2961 	 * so only register the backlight device if the backlight method
2962 	 * supports both reads and writes.
2963 	 */
2964 	brightness = __get_lcd_brightness(dev);
2965 	if (brightness < 0)
2966 		return 0;
2967 	/*
2968 	 * If transflective backlight is supported and the brightness is zero
2969 	 * (lowest brightness level), the set_lcd_brightness function will
2970 	 * activate the transflective backlight, making the LCD appear to be
2971 	 * turned off, simply increment the brightness level to avoid that.
2972 	 */
2973 	if (dev->tr_backlight_supported && brightness == 0)
2974 		brightness++;
2975 	ret = set_lcd_brightness(dev, brightness);
2976 	if (ret) {
2977 		pr_debug("Backlight method is read-only, disabling backlight support\n");
2978 		return 0;
2979 	}
2980 
2981 	if (acpi_video_get_backlight_type() != acpi_backlight_vendor)
2982 		return 0;
2983 
2984 	memset(&props, 0, sizeof(props));
2985 	props.type = BACKLIGHT_PLATFORM;
2986 	props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
2987 
2988 	/* Adding an extra level and having 0 change to transflective mode */
2989 	if (dev->tr_backlight_supported)
2990 		props.max_brightness++;
2991 
2992 	dev->backlight_dev = backlight_device_register("toshiba",
2993 						       &dev->acpi_dev->dev,
2994 						       dev,
2995 						       &toshiba_backlight_data,
2996 						       &props);
2997 	if (IS_ERR(dev->backlight_dev)) {
2998 		ret = PTR_ERR(dev->backlight_dev);
2999 		pr_err("Could not register toshiba backlight device\n");
3000 		dev->backlight_dev = NULL;
3001 		return ret;
3002 	}
3003 
3004 	dev->backlight_dev->props.brightness = brightness;
3005 	return 0;
3006 }
3007 
3008 /* HWMON support for fan */
3009 #if IS_ENABLED(CONFIG_HWMON)
3010 static umode_t toshiba_acpi_hwmon_is_visible(const void *drvdata,
3011 					     enum hwmon_sensor_types type,
3012 					     u32 attr, int channel)
3013 {
3014 	return 0444;
3015 }
3016 
3017 static int toshiba_acpi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
3018 				   u32 attr, int channel, long *val)
3019 {
3020 	/*
3021 	 * There is only a single channel and single attribute (for the
3022 	 * fan) at this point.
3023 	 * This can be replaced with more advanced logic in the future,
3024 	 * should the need arise.
3025 	 */
3026 	if (type == hwmon_fan && channel == 0 && attr == hwmon_fan_input) {
3027 		u32 value;
3028 		int ret;
3029 
3030 		ret = get_fan_rpm(toshiba_acpi, &value);
3031 		if (ret)
3032 			return ret;
3033 
3034 		*val = value;
3035 		return 0;
3036 	}
3037 	return -EOPNOTSUPP;
3038 }
3039 
3040 static const struct hwmon_channel_info *toshiba_acpi_hwmon_info[] = {
3041 	HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT),
3042 	NULL
3043 };
3044 
3045 static const struct hwmon_ops toshiba_acpi_hwmon_ops = {
3046 	.is_visible = toshiba_acpi_hwmon_is_visible,
3047 	.read = toshiba_acpi_hwmon_read,
3048 };
3049 
3050 static const struct hwmon_chip_info toshiba_acpi_hwmon_chip_info = {
3051 	.ops = &toshiba_acpi_hwmon_ops,
3052 	.info = toshiba_acpi_hwmon_info,
3053 };
3054 #endif
3055 
3056 /* ACPI battery hooking */
3057 static ssize_t charge_control_end_threshold_show(struct device *device,
3058 						 struct device_attribute *attr,
3059 						 char *buf)
3060 {
3061 	u32 state;
3062 	int status;
3063 
3064 	if (toshiba_acpi == NULL) {
3065 		pr_err("Toshiba ACPI object invalid\n");
3066 		return -ENODEV;
3067 	}
3068 
3069 	status = toshiba_battery_charge_mode_get(toshiba_acpi, &state);
3070 
3071 	if (status != 0)
3072 		return status;
3073 
3074 	if (state == 1)
3075 		return sprintf(buf, "80\n");
3076 	else
3077 		return sprintf(buf, "100\n");
3078 }
3079 
3080 static ssize_t charge_control_end_threshold_store(struct device *dev,
3081 						  struct device_attribute *attr,
3082 						  const char *buf,
3083 						  size_t count)
3084 {
3085 	u32 value;
3086 	int rval;
3087 
3088 	if (toshiba_acpi == NULL) {
3089 		pr_err("Toshiba ACPI object invalid\n");
3090 		return -ENODEV;
3091 	}
3092 
3093 	rval = kstrtou32(buf, 10, &value);
3094 	if (rval)
3095 		return rval;
3096 
3097 	if (value < 1 || value > 100)
3098 		return -EINVAL;
3099 	rval = toshiba_battery_charge_mode_set(toshiba_acpi,
3100 					       (value < 90) ? 1 : 0);
3101 	if (rval < 0)
3102 		return rval;
3103 	else
3104 		return count;
3105 }
3106 
3107 static DEVICE_ATTR_RW(charge_control_end_threshold);
3108 
3109 static struct attribute *toshiba_acpi_battery_attrs[] = {
3110 	&dev_attr_charge_control_end_threshold.attr,
3111 	NULL,
3112 };
3113 
3114 ATTRIBUTE_GROUPS(toshiba_acpi_battery);
3115 
3116 static int toshiba_acpi_battery_add(struct power_supply *battery)
3117 {
3118 	if (toshiba_acpi == NULL) {
3119 		pr_err("Init order issue\n");
3120 		return -ENODEV;
3121 	}
3122 	if (!toshiba_acpi->battery_charge_mode_supported)
3123 		return -ENODEV;
3124 	if (device_add_groups(&battery->dev, toshiba_acpi_battery_groups))
3125 		return -ENODEV;
3126 	return 0;
3127 }
3128 
3129 static int toshiba_acpi_battery_remove(struct power_supply *battery)
3130 {
3131 	device_remove_groups(&battery->dev, toshiba_acpi_battery_groups);
3132 	return 0;
3133 }
3134 
3135 static struct acpi_battery_hook battery_hook = {
3136 	.add_battery = toshiba_acpi_battery_add,
3137 	.remove_battery = toshiba_acpi_battery_remove,
3138 	.name = "Toshiba Battery Extension",
3139 };
3140 
3141 static void print_supported_features(struct toshiba_acpi_dev *dev)
3142 {
3143 	pr_info("Supported laptop features:");
3144 
3145 	if (dev->hotkey_dev)
3146 		pr_cont(" hotkeys");
3147 	if (dev->backlight_dev)
3148 		pr_cont(" backlight");
3149 	if (dev->video_supported)
3150 		pr_cont(" video-out");
3151 	if (dev->fan_supported)
3152 		pr_cont(" fan");
3153 	if (dev->fan_rpm_supported)
3154 		pr_cont(" fan-rpm");
3155 	if (dev->tr_backlight_supported)
3156 		pr_cont(" transflective-backlight");
3157 	if (dev->illumination_supported)
3158 		pr_cont(" illumination");
3159 	if (dev->kbd_illum_supported)
3160 		pr_cont(" keyboard-backlight");
3161 	if (dev->touchpad_supported)
3162 		pr_cont(" touchpad");
3163 	if (dev->eco_supported)
3164 		pr_cont(" eco-led");
3165 	if (dev->accelerometer_supported)
3166 		pr_cont(" accelerometer-axes");
3167 	if (dev->usb_sleep_charge_supported)
3168 		pr_cont(" usb-sleep-charge");
3169 	if (dev->usb_rapid_charge_supported)
3170 		pr_cont(" usb-rapid-charge");
3171 	if (dev->usb_sleep_music_supported)
3172 		pr_cont(" usb-sleep-music");
3173 	if (dev->kbd_function_keys_supported)
3174 		pr_cont(" special-function-keys");
3175 	if (dev->panel_power_on_supported)
3176 		pr_cont(" panel-power-on");
3177 	if (dev->usb_three_supported)
3178 		pr_cont(" usb3");
3179 	if (dev->wwan_supported)
3180 		pr_cont(" wwan");
3181 	if (dev->cooling_method_supported)
3182 		pr_cont(" cooling-method");
3183 	if (dev->battery_charge_mode_supported)
3184 		pr_cont(" battery-charge-mode");
3185 
3186 	pr_cont("\n");
3187 }
3188 
3189 static int toshiba_acpi_remove(struct acpi_device *acpi_dev)
3190 {
3191 	struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
3192 
3193 	misc_deregister(&dev->miscdev);
3194 
3195 	remove_toshiba_proc_entries(dev);
3196 
3197 #if IS_ENABLED(CONFIG_HWMON)
3198 	if (dev->hwmon_device)
3199 		hwmon_device_unregister(dev->hwmon_device);
3200 #endif
3201 
3202 	if (dev->accelerometer_supported && dev->indio_dev) {
3203 		iio_device_unregister(dev->indio_dev);
3204 		iio_device_free(dev->indio_dev);
3205 	}
3206 
3207 	if (dev->sysfs_created)
3208 		sysfs_remove_group(&dev->acpi_dev->dev.kobj,
3209 				   &toshiba_attr_group);
3210 
3211 	if (dev->ntfy_supported) {
3212 		i8042_remove_filter(toshiba_acpi_i8042_filter);
3213 		cancel_work_sync(&dev->hotkey_work);
3214 	}
3215 
3216 	if (dev->hotkey_dev)
3217 		input_unregister_device(dev->hotkey_dev);
3218 
3219 	backlight_device_unregister(dev->backlight_dev);
3220 
3221 	led_classdev_unregister(&dev->led_dev);
3222 	led_classdev_unregister(&dev->kbd_led);
3223 	led_classdev_unregister(&dev->eco_led);
3224 
3225 	if (dev->wwan_rfk) {
3226 		rfkill_unregister(dev->wwan_rfk);
3227 		rfkill_destroy(dev->wwan_rfk);
3228 	}
3229 
3230 	if (dev->battery_charge_mode_supported)
3231 		battery_hook_unregister(&battery_hook);
3232 
3233 	if (toshiba_acpi)
3234 		toshiba_acpi = NULL;
3235 
3236 	kfree(dev);
3237 
3238 	return 0;
3239 }
3240 
3241 static const char *find_hci_method(acpi_handle handle)
3242 {
3243 	if (acpi_has_method(handle, "GHCI"))
3244 		return "GHCI";
3245 
3246 	if (acpi_has_method(handle, "SPFC"))
3247 		return "SPFC";
3248 
3249 	return NULL;
3250 }
3251 
3252 /*
3253  * Some Toshibas have a broken acpi-video interface for brightness control,
3254  * these are quirked in drivers/acpi/video_detect.c to use the GPU native
3255  * (/sys/class/backlight/intel_backlight) instead.
3256  * But these need a HCI_SET call to actually turn the panel back on at resume,
3257  * without this call the screen stays black at resume.
3258  * Either HCI_LCD_BRIGHTNESS (used by acpi_video's _BCM) or HCI_PANEL_POWER_ON
3259  * works. toshiba_acpi_resume() uses HCI_PANEL_POWER_ON to avoid changing
3260  * the configured brightness level.
3261  */
3262 static const struct dmi_system_id turn_on_panel_on_resume_dmi_ids[] = {
3263 	{
3264 	 /* Toshiba Portégé R700 */
3265 	 /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
3266 	 .matches = {
3267 		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
3268 		DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"),
3269 		},
3270 	},
3271 	{
3272 	 /* Toshiba Satellite/Portégé R830 */
3273 	 /* Portégé: https://bugs.freedesktop.org/show_bug.cgi?id=82634 */
3274 	 /* Satellite: https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
3275 	 .matches = {
3276 		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
3277 		DMI_MATCH(DMI_PRODUCT_NAME, "R830"),
3278 		},
3279 	},
3280 	{
3281 	 /* Toshiba Satellite/Portégé Z830 */
3282 	 .matches = {
3283 		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
3284 		DMI_MATCH(DMI_PRODUCT_NAME, "Z830"),
3285 		},
3286 	},
3287 };
3288 
3289 static int toshiba_acpi_add(struct acpi_device *acpi_dev)
3290 {
3291 	struct toshiba_acpi_dev *dev;
3292 	const char *hci_method;
3293 	u32 dummy;
3294 	int ret = 0;
3295 
3296 	if (toshiba_acpi)
3297 		return -EBUSY;
3298 
3299 	pr_info("Toshiba Laptop ACPI Extras version %s\n",
3300 	       TOSHIBA_ACPI_VERSION);
3301 
3302 	hci_method = find_hci_method(acpi_dev->handle);
3303 	if (!hci_method) {
3304 		pr_err("HCI interface not found\n");
3305 		return -ENODEV;
3306 	}
3307 
3308 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3309 	if (!dev)
3310 		return -ENOMEM;
3311 	dev->acpi_dev = acpi_dev;
3312 	dev->method_hci = hci_method;
3313 	dev->miscdev.minor = MISC_DYNAMIC_MINOR;
3314 	dev->miscdev.name = "toshiba_acpi";
3315 	dev->miscdev.fops = &toshiba_acpi_fops;
3316 
3317 	ret = misc_register(&dev->miscdev);
3318 	if (ret) {
3319 		pr_err("Failed to register miscdevice\n");
3320 		kfree(dev);
3321 		return ret;
3322 	}
3323 
3324 	acpi_dev->driver_data = dev;
3325 	dev_set_drvdata(&acpi_dev->dev, dev);
3326 
3327 	/* Query the BIOS for supported features */
3328 
3329 	/*
3330 	 * The "Special Functions" are always supported by the laptops
3331 	 * with the new keyboard layout, query for its presence to help
3332 	 * determine the keymap layout to use.
3333 	 */
3334 	ret = toshiba_function_keys_get(dev, &dev->special_functions);
3335 	dev->kbd_function_keys_supported = !ret;
3336 
3337 	dev->hotkey_event_type = 0;
3338 	if (toshiba_acpi_setup_keyboard(dev))
3339 		pr_info("Unable to activate hotkeys\n");
3340 
3341 	/* Determine whether or not BIOS supports transflective backlight */
3342 	ret = get_tr_backlight_status(dev, &dummy);
3343 	dev->tr_backlight_supported = !ret;
3344 
3345 	ret = toshiba_acpi_setup_backlight(dev);
3346 	if (ret)
3347 		goto error;
3348 
3349 	toshiba_illumination_available(dev);
3350 	if (dev->illumination_supported) {
3351 		dev->led_dev.name = "toshiba::illumination";
3352 		dev->led_dev.max_brightness = 1;
3353 		dev->led_dev.brightness_set = toshiba_illumination_set;
3354 		dev->led_dev.brightness_get = toshiba_illumination_get;
3355 		led_classdev_register(&acpi_dev->dev, &dev->led_dev);
3356 	}
3357 
3358 	toshiba_eco_mode_available(dev);
3359 	if (dev->eco_supported) {
3360 		dev->eco_led.name = "toshiba::eco_mode";
3361 		dev->eco_led.max_brightness = 1;
3362 		dev->eco_led.brightness_set = toshiba_eco_mode_set_status;
3363 		dev->eco_led.brightness_get = toshiba_eco_mode_get_status;
3364 		led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led);
3365 	}
3366 
3367 	toshiba_kbd_illum_available(dev);
3368 	/*
3369 	 * Only register the LED if KBD illumination is supported
3370 	 * and the keyboard backlight operation mode is set to FN-Z
3371 	 * or we detect a second gen keyboard backlight
3372 	 */
3373 	if (dev->kbd_illum_supported &&
3374 	    (dev->kbd_mode == SCI_KBD_MODE_FNZ || dev->kbd_type == 2)) {
3375 		dev->kbd_led.name = "toshiba::kbd_backlight";
3376 		dev->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
3377 		dev->kbd_led.max_brightness = 1;
3378 		dev->kbd_led.brightness_set = toshiba_kbd_backlight_set;
3379 		dev->kbd_led.brightness_get = toshiba_kbd_backlight_get;
3380 		led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led);
3381 	}
3382 
3383 	ret = toshiba_touchpad_get(dev, &dummy);
3384 	dev->touchpad_supported = !ret;
3385 
3386 	toshiba_accelerometer_available(dev);
3387 	if (dev->accelerometer_supported) {
3388 		dev->indio_dev = iio_device_alloc(&acpi_dev->dev, sizeof(*dev));
3389 		if (!dev->indio_dev) {
3390 			pr_err("Unable to allocate iio device\n");
3391 			goto iio_error;
3392 		}
3393 
3394 		pr_info("Registering Toshiba accelerometer iio device\n");
3395 
3396 		dev->indio_dev->info = &toshiba_iio_accel_info;
3397 		dev->indio_dev->name = "Toshiba accelerometer";
3398 		dev->indio_dev->modes = INDIO_DIRECT_MODE;
3399 		dev->indio_dev->channels = toshiba_iio_accel_channels;
3400 		dev->indio_dev->num_channels =
3401 					ARRAY_SIZE(toshiba_iio_accel_channels);
3402 
3403 		ret = iio_device_register(dev->indio_dev);
3404 		if (ret < 0) {
3405 			pr_err("Unable to register iio device\n");
3406 			iio_device_free(dev->indio_dev);
3407 		}
3408 	}
3409 iio_error:
3410 
3411 	toshiba_usb_sleep_charge_available(dev);
3412 
3413 	ret = toshiba_usb_rapid_charge_get(dev, &dummy);
3414 	dev->usb_rapid_charge_supported = !ret;
3415 
3416 	ret = toshiba_usb_sleep_music_get(dev, &dummy);
3417 	dev->usb_sleep_music_supported = !ret;
3418 
3419 	ret = toshiba_panel_power_on_get(dev, &dummy);
3420 	dev->panel_power_on_supported = !ret;
3421 
3422 	ret = toshiba_usb_three_get(dev, &dummy);
3423 	dev->usb_three_supported = !ret;
3424 
3425 	ret = get_video_status(dev, &dummy);
3426 	dev->video_supported = !ret;
3427 
3428 	ret = get_fan_status(dev, &dummy);
3429 	dev->fan_supported = !ret;
3430 
3431 	ret = get_fan_rpm(dev, &dummy);
3432 	dev->fan_rpm_supported = !ret;
3433 
3434 #if IS_ENABLED(CONFIG_HWMON)
3435 	if (dev->fan_rpm_supported) {
3436 		dev->hwmon_device = hwmon_device_register_with_info(
3437 			&dev->acpi_dev->dev, "toshiba_acpi_sensors", NULL,
3438 			&toshiba_acpi_hwmon_chip_info, NULL);
3439 		if (IS_ERR(dev->hwmon_device)) {
3440 			dev->hwmon_device = NULL;
3441 			pr_warn("unable to register hwmon device, skipping\n");
3442 		}
3443 	}
3444 #endif
3445 
3446 	if (turn_on_panel_on_resume == -1)
3447 		turn_on_panel_on_resume = dmi_check_system(turn_on_panel_on_resume_dmi_ids);
3448 
3449 	toshiba_wwan_available(dev);
3450 	if (dev->wwan_supported)
3451 		toshiba_acpi_setup_wwan_rfkill(dev);
3452 
3453 	toshiba_cooling_method_available(dev);
3454 
3455 	toshiba_battery_charge_mode_available(dev);
3456 
3457 	print_supported_features(dev);
3458 
3459 	ret = sysfs_create_group(&dev->acpi_dev->dev.kobj,
3460 				 &toshiba_attr_group);
3461 	if (ret) {
3462 		dev->sysfs_created = 0;
3463 		goto error;
3464 	}
3465 	dev->sysfs_created = !ret;
3466 
3467 	create_toshiba_proc_entries(dev);
3468 
3469 	toshiba_acpi = dev;
3470 
3471 	/*
3472 	 * As the battery hook relies on the static variable toshiba_acpi being
3473 	 * set, this must be done after toshiba_acpi is assigned.
3474 	 */
3475 	if (dev->battery_charge_mode_supported)
3476 		battery_hook_register(&battery_hook);
3477 
3478 	return 0;
3479 
3480 error:
3481 	toshiba_acpi_remove(acpi_dev);
3482 	return ret;
3483 }
3484 
3485 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
3486 {
3487 	struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
3488 
3489 	switch (event) {
3490 	case 0x80: /* Hotkeys and some system events */
3491 		/*
3492 		 * Machines with this WMI GUID aren't supported due to bugs in
3493 		 * their AML.
3494 		 *
3495 		 * Return silently to avoid triggering a netlink event.
3496 		 */
3497 		if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
3498 			return;
3499 		toshiba_acpi_process_hotkeys(dev);
3500 		break;
3501 	case 0x81: /* Dock events */
3502 	case 0x82:
3503 	case 0x83:
3504 		pr_info("Dock event received %x\n", event);
3505 		break;
3506 	case 0x88: /* Thermal events */
3507 		pr_info("Thermal event received\n");
3508 		break;
3509 	case 0x8f: /* LID closed */
3510 	case 0x90: /* LID is closed and Dock has been ejected */
3511 		break;
3512 	case 0x8c: /* SATA power events */
3513 	case 0x8b:
3514 		pr_info("SATA power event received %x\n", event);
3515 		break;
3516 	case 0x92: /* Keyboard backlight mode changed */
3517 		dev->kbd_event_generated = true;
3518 		/* Update sysfs entries */
3519 		if (sysfs_update_group(&acpi_dev->dev.kobj,
3520 				       &toshiba_attr_group))
3521 			pr_err("Unable to update sysfs entries\n");
3522 		/* Notify LED subsystem about keyboard backlight change */
3523 		if (dev->kbd_type == 2 && dev->kbd_mode != SCI_KBD_MODE_AUTO)
3524 			led_classdev_notify_brightness_hw_changed(&dev->kbd_led,
3525 					(dev->kbd_mode == SCI_KBD_MODE_ON) ?
3526 					LED_FULL : LED_OFF);
3527 		break;
3528 	case 0x85: /* Unknown */
3529 	case 0x8d: /* Unknown */
3530 	case 0x8e: /* Unknown */
3531 	case 0x94: /* Unknown */
3532 	case 0x95: /* Unknown */
3533 	default:
3534 		pr_info("Unknown event received %x\n", event);
3535 		break;
3536 	}
3537 
3538 	acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class,
3539 					dev_name(&acpi_dev->dev),
3540 					event, (event == 0x80) ?
3541 					dev->last_key_event : 0);
3542 }
3543 
3544 #ifdef CONFIG_PM_SLEEP
3545 static int toshiba_acpi_suspend(struct device *device)
3546 {
3547 	struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
3548 
3549 	if (dev->hotkey_dev) {
3550 		u32 result;
3551 
3552 		result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE);
3553 		if (result != TOS_SUCCESS)
3554 			pr_info("Unable to disable hotkeys\n");
3555 	}
3556 
3557 	return 0;
3558 }
3559 
3560 static int toshiba_acpi_resume(struct device *device)
3561 {
3562 	struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
3563 
3564 	if (dev->hotkey_dev) {
3565 		if (toshiba_acpi_enable_hotkeys(dev))
3566 			pr_info("Unable to re-enable hotkeys\n");
3567 	}
3568 
3569 	if (dev->wwan_rfk) {
3570 		if (!toshiba_wireless_status(dev))
3571 			rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch);
3572 	}
3573 
3574 	if (turn_on_panel_on_resume)
3575 		hci_write(dev, HCI_PANEL_POWER_ON, 1);
3576 
3577 	return 0;
3578 }
3579 #endif
3580 
3581 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
3582 			 toshiba_acpi_suspend, toshiba_acpi_resume);
3583 
3584 static struct acpi_driver toshiba_acpi_driver = {
3585 	.name	= "Toshiba ACPI driver",
3586 	.owner	= THIS_MODULE,
3587 	.ids	= toshiba_device_ids,
3588 	.flags	= ACPI_DRIVER_ALL_NOTIFY_EVENTS,
3589 	.ops	= {
3590 		.add		= toshiba_acpi_add,
3591 		.remove		= toshiba_acpi_remove,
3592 		.notify		= toshiba_acpi_notify,
3593 	},
3594 	.drv.pm	= &toshiba_acpi_pm,
3595 };
3596 
3597 static int __init toshiba_acpi_init(void)
3598 {
3599 	int ret;
3600 
3601 	toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
3602 	if (!toshiba_proc_dir) {
3603 		pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
3604 		return -ENODEV;
3605 	}
3606 
3607 	ret = acpi_bus_register_driver(&toshiba_acpi_driver);
3608 	if (ret) {
3609 		pr_err("Failed to register ACPI driver: %d\n", ret);
3610 		remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
3611 	}
3612 
3613 	return ret;
3614 }
3615 
3616 static void __exit toshiba_acpi_exit(void)
3617 {
3618 	acpi_bus_unregister_driver(&toshiba_acpi_driver);
3619 	if (toshiba_proc_dir)
3620 		remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
3621 }
3622 
3623 module_init(toshiba_acpi_init);
3624 module_exit(toshiba_acpi_exit);
3625