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