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