Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/platform/x86/toshiba_acpi.c

  1 /*
  2  *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
  3  *
  4  *  Copyright (C) 2002-2004 John Belmonte
  5  *  Copyright (C) 2008 Philip Langdale
  6  *  Copyright (C) 2010 Pierre Ducroquet
  7  *  Copyright (C) 2014-2015 Azael Avalos
  8  *
  9  *  This program is free software; you can redistribute it and/or modify
 10  *  it under the terms of the GNU General Public License as published by
 11  *  the Free Software Foundation; either version 2 of the License, or
 12  *  (at your option) any later version.
 13  *
 14  *  This program is distributed in the hope that it will be useful,
 15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17  *  GNU General Public License for more details.
 18  *
 19  *  The full GNU General Public License is included in this distribution in
 20  *  the file called "COPYING".
 21  *
 22  *  The devolpment page for this driver is located at
 23  *  http://memebeam.org/toys/ToshibaAcpiDriver.
 24  *
 25  *  Credits:
 26  *      Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
 27  *              engineering the Windows drivers
 28  *      Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
 29  *      Rob Miller - TV out and hotkeys help
 30  */
 31 
 32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 33 
 34 #define TOSHIBA_ACPI_VERSION    "0.21"
 35 #define PROC_INTERFACE_VERSION  1
 36 
 37 #include <linux/kernel.h>
 38 #include <linux/module.h>
 39 #include <linux/init.h>
 40 #include <linux/types.h>
 41 #include <linux/proc_fs.h>
 42 #include <linux/seq_file.h>
 43 #include <linux/backlight.h>
 44 #include <linux/rfkill.h>
 45 #include <linux/input.h>
 46 #include <linux/input/sparse-keymap.h>
 47 #include <linux/leds.h>
 48 #include <linux/slab.h>
 49 #include <linux/workqueue.h>
 50 #include <linux/i8042.h>
 51 #include <linux/acpi.h>
 52 #include <linux/dmi.h>
 53 #include <linux/uaccess.h>
 54 #include <acpi/video.h>
 55 
 56 MODULE_AUTHOR("John Belmonte");
 57 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
 58 MODULE_LICENSE("GPL");
 59 
 60 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
 61 
 62 /* Scan code for Fn key on TOS1900 models */
 63 #define TOS1900_FN_SCAN         0x6e
 64 
 65 /* Toshiba ACPI method paths */
 66 #define METHOD_VIDEO_OUT        "\\_SB_.VALX.DSSX"
 67 
 68 /*
 69  * The Toshiba configuration interface is composed of the HCI and the SCI,
 70  * which are defined as follows:
 71  *
 72  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
 73  * be uniform across all their models.  Ideally we would just call
 74  * dedicated ACPI methods instead of using this primitive interface.
 75  * However the ACPI methods seem to be incomplete in some areas (for
 76  * example they allow setting, but not reading, the LCD brightness value),
 77  * so this is still useful.
 78  *
 79  * SCI stands for "System Configuration Interface" which aim is to
 80  * conceal differences in hardware between different models.
 81  */
 82 
 83 #define TCI_WORDS                       6
 84 
 85 /* operations */
 86 #define HCI_SET                         0xff00
 87 #define HCI_GET                         0xfe00
 88 #define SCI_OPEN                        0xf100
 89 #define SCI_CLOSE                       0xf200
 90 #define SCI_GET                         0xf300
 91 #define SCI_SET                         0xf400
 92 
 93 /* return codes */
 94 #define TOS_SUCCESS                     0x0000
 95 #define TOS_OPEN_CLOSE_OK               0x0044
 96 #define TOS_FAILURE                     0x1000
 97 #define TOS_NOT_SUPPORTED               0x8000
 98 #define TOS_ALREADY_OPEN                0x8100
 99 #define TOS_NOT_OPENED                  0x8200
100 #define TOS_INPUT_DATA_ERROR            0x8300
101 #define TOS_WRITE_PROTECTED             0x8400
102 #define TOS_NOT_PRESENT                 0x8600
103 #define TOS_FIFO_EMPTY                  0x8c00
104 #define TOS_DATA_NOT_AVAILABLE          0x8d20
105 #define TOS_NOT_INITIALIZED             0x8d50
106 #define TOS_NOT_INSTALLED               0x8e00
107 
108 /* registers */
109 #define HCI_FAN                         0x0004
110 #define HCI_TR_BACKLIGHT                0x0005
111 #define HCI_SYSTEM_EVENT                0x0016
112 #define HCI_VIDEO_OUT                   0x001c
113 #define HCI_HOTKEY_EVENT                0x001e
114 #define HCI_LCD_BRIGHTNESS              0x002a
115 #define HCI_WIRELESS                    0x0056
116 #define HCI_ACCELEROMETER               0x006d
117 #define HCI_KBD_ILLUMINATION            0x0095
118 #define HCI_ECO_MODE                    0x0097
119 #define HCI_ACCELEROMETER2              0x00a6
120 #define HCI_SYSTEM_INFO                 0xc000
121 #define SCI_PANEL_POWER_ON              0x010d
122 #define SCI_ILLUMINATION                0x014e
123 #define SCI_USB_SLEEP_CHARGE            0x0150
124 #define SCI_KBD_ILLUM_STATUS            0x015c
125 #define SCI_USB_SLEEP_MUSIC             0x015e
126 #define SCI_USB_THREE                   0x0169
127 #define SCI_TOUCHPAD                    0x050e
128 #define SCI_KBD_FUNCTION_KEYS           0x0522
129 
130 /* field definitions */
131 #define HCI_ACCEL_MASK                  0x7fff
132 #define HCI_HOTKEY_DISABLE              0x0b
133 #define HCI_HOTKEY_ENABLE               0x09
134 #define HCI_HOTKEY_SPECIAL_FUNCTIONS    0x10
135 #define HCI_LCD_BRIGHTNESS_BITS         3
136 #define HCI_LCD_BRIGHTNESS_SHIFT        (16-HCI_LCD_BRIGHTNESS_BITS)
137 #define HCI_LCD_BRIGHTNESS_LEVELS       (1 << HCI_LCD_BRIGHTNESS_BITS)
138 #define HCI_MISC_SHIFT                  0x10
139 #define HCI_SYSTEM_TYPE1                0x10
140 #define HCI_SYSTEM_TYPE2                0x11
141 #define HCI_VIDEO_OUT_LCD               0x1
142 #define HCI_VIDEO_OUT_CRT               0x2
143 #define HCI_VIDEO_OUT_TV                0x4
144 #define HCI_WIRELESS_KILL_SWITCH        0x01
145 #define HCI_WIRELESS_BT_PRESENT         0x0f
146 #define HCI_WIRELESS_BT_ATTACH          0x40
147 #define HCI_WIRELESS_BT_POWER           0x80
148 #define SCI_KBD_MODE_MASK               0x1f
149 #define SCI_KBD_MODE_FNZ                0x1
150 #define SCI_KBD_MODE_AUTO               0x2
151 #define SCI_KBD_MODE_ON                 0x8
152 #define SCI_KBD_MODE_OFF                0x10
153 #define SCI_KBD_TIME_MAX                0x3c001a
154 #define SCI_USB_CHARGE_MODE_MASK        0xff
155 #define SCI_USB_CHARGE_DISABLED         0x00
156 #define SCI_USB_CHARGE_ALTERNATE        0x09
157 #define SCI_USB_CHARGE_TYPICAL          0x11
158 #define SCI_USB_CHARGE_AUTO             0x21
159 #define SCI_USB_CHARGE_BAT_MASK         0x7
160 #define SCI_USB_CHARGE_BAT_LVL_OFF      0x1
161 #define SCI_USB_CHARGE_BAT_LVL_ON       0x4
162 #define SCI_USB_CHARGE_BAT_LVL          0x0200
163 #define SCI_USB_CHARGE_RAPID_DSP        0x0300
164 
165 struct toshiba_acpi_dev {
166         struct acpi_device *acpi_dev;
167         const char *method_hci;
168         struct rfkill *bt_rfk;
169         struct input_dev *hotkey_dev;
170         struct work_struct hotkey_work;
171         struct backlight_device *backlight_dev;
172         struct led_classdev led_dev;
173         struct led_classdev kbd_led;
174         struct led_classdev eco_led;
175 
176         int force_fan;
177         int last_key_event;
178         int key_event_valid;
179         int kbd_type;
180         int kbd_mode;
181         int kbd_time;
182         int usbsc_bat_level;
183         int usbsc_mode_base;
184         int hotkey_event_type;
185 
186         unsigned int illumination_supported:1;
187         unsigned int video_supported:1;
188         unsigned int fan_supported:1;
189         unsigned int system_event_supported:1;
190         unsigned int ntfy_supported:1;
191         unsigned int info_supported:1;
192         unsigned int tr_backlight_supported:1;
193         unsigned int kbd_illum_supported:1;
194         unsigned int kbd_led_registered:1;
195         unsigned int touchpad_supported:1;
196         unsigned int eco_supported:1;
197         unsigned int accelerometer_supported:1;
198         unsigned int usb_sleep_charge_supported:1;
199         unsigned int usb_rapid_charge_supported:1;
200         unsigned int usb_sleep_music_supported:1;
201         unsigned int kbd_function_keys_supported:1;
202         unsigned int panel_power_on_supported:1;
203         unsigned int usb_three_supported:1;
204         unsigned int sysfs_created:1;
205 
206         struct mutex mutex;
207 };
208 
209 static struct toshiba_acpi_dev *toshiba_acpi;
210 
211 static const struct acpi_device_id toshiba_device_ids[] = {
212         {"TOS6200", 0},
213         {"TOS6207", 0},
214         {"TOS6208", 0},
215         {"TOS1900", 0},
216         {"", 0},
217 };
218 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
219 
220 static const struct key_entry toshiba_acpi_keymap[] = {
221         { KE_KEY, 0x9e, { KEY_RFKILL } },
222         { KE_KEY, 0x101, { KEY_MUTE } },
223         { KE_KEY, 0x102, { KEY_ZOOMOUT } },
224         { KE_KEY, 0x103, { KEY_ZOOMIN } },
225         { KE_KEY, 0x10f, { KEY_TAB } },
226         { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
227         { KE_KEY, 0x139, { KEY_ZOOMRESET } },
228         { KE_KEY, 0x13b, { KEY_COFFEE } },
229         { KE_KEY, 0x13c, { KEY_BATTERY } },
230         { KE_KEY, 0x13d, { KEY_SLEEP } },
231         { KE_KEY, 0x13e, { KEY_SUSPEND } },
232         { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
233         { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
234         { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
235         { KE_KEY, 0x142, { KEY_WLAN } },
236         { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } },
237         { KE_KEY, 0x17f, { KEY_FN } },
238         { KE_KEY, 0xb05, { KEY_PROG2 } },
239         { KE_KEY, 0xb06, { KEY_WWW } },
240         { KE_KEY, 0xb07, { KEY_MAIL } },
241         { KE_KEY, 0xb30, { KEY_STOP } },
242         { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
243         { KE_KEY, 0xb32, { KEY_NEXTSONG } },
244         { KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
245         { KE_KEY, 0xb5a, { KEY_MEDIA } },
246         { KE_IGNORE, 0x1430, { KEY_RESERVED } }, /* Wake from sleep */
247         { KE_IGNORE, 0x1501, { KEY_RESERVED } }, /* Output changed */
248         { KE_IGNORE, 0x1502, { KEY_RESERVED } }, /* HDMI plugged/unplugged */
249         { KE_IGNORE, 0x1ABE, { KEY_RESERVED } }, /* Protection level set */
250         { KE_IGNORE, 0x1ABF, { KEY_RESERVED } }, /* Protection level off */
251         { KE_END, 0 },
252 };
253 
254 static const struct key_entry toshiba_acpi_alt_keymap[] = {
255         { KE_KEY, 0x157, { KEY_MUTE } },
256         { KE_KEY, 0x102, { KEY_ZOOMOUT } },
257         { KE_KEY, 0x103, { KEY_ZOOMIN } },
258         { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
259         { KE_KEY, 0x139, { KEY_ZOOMRESET } },
260         { KE_KEY, 0x13e, { KEY_SWITCHVIDEOMODE } },
261         { KE_KEY, 0x13c, { KEY_BRIGHTNESSDOWN } },
262         { KE_KEY, 0x13d, { KEY_BRIGHTNESSUP } },
263         { KE_KEY, 0x158, { KEY_WLAN } },
264         { KE_KEY, 0x13f, { KEY_TOUCHPAD_TOGGLE } },
265         { KE_END, 0 },
266 };
267 
268 /*
269  * List of models which have a broken acpi-video backlight interface and thus
270  * need to use the toshiba (vendor) interface instead.
271  */
272 static const struct dmi_system_id toshiba_vendor_backlight_dmi[] = {
273         {}
274 };
275 
276 /*
277  * Utility
278  */
279 
280 static inline void _set_bit(u32 *word, u32 mask, int value)
281 {
282         *word = (*word & ~mask) | (mask * value);
283 }
284 
285 /*
286  * ACPI interface wrappers
287  */
288 
289 static int write_acpi_int(const char *methodName, int val)
290 {
291         acpi_status status;
292 
293         status = acpi_execute_simple_method(NULL, (char *)methodName, val);
294         return (status == AE_OK) ? 0 : -EIO;
295 }
296 
297 /*
298  * Perform a raw configuration call.  Here we don't care about input or output
299  * buffer format.
300  */
301 static acpi_status tci_raw(struct toshiba_acpi_dev *dev,
302                            const u32 in[TCI_WORDS], u32 out[TCI_WORDS])
303 {
304         struct acpi_object_list params;
305         union acpi_object in_objs[TCI_WORDS];
306         struct acpi_buffer results;
307         union acpi_object out_objs[TCI_WORDS + 1];
308         acpi_status status;
309         int i;
310 
311         params.count = TCI_WORDS;
312         params.pointer = in_objs;
313         for (i = 0; i < TCI_WORDS; ++i) {
314                 in_objs[i].type = ACPI_TYPE_INTEGER;
315                 in_objs[i].integer.value = in[i];
316         }
317 
318         results.length = sizeof(out_objs);
319         results.pointer = out_objs;
320 
321         status = acpi_evaluate_object(dev->acpi_dev->handle,
322                                       (char *)dev->method_hci, &params,
323                                       &results);
324         if ((status == AE_OK) && (out_objs->package.count <= TCI_WORDS)) {
325                 for (i = 0; i < out_objs->package.count; ++i)
326                         out[i] = out_objs->package.elements[i].integer.value;
327         }
328 
329         return status;
330 }
331 
332 /*
333  * Common hci tasks (get or set one or two value)
334  *
335  * In addition to the ACPI status, the HCI system returns a result which
336  * may be useful (such as "not supported").
337  */
338 
339 static u32 hci_write1(struct toshiba_acpi_dev *dev, u32 reg, u32 in1)
340 {
341         u32 in[TCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
342         u32 out[TCI_WORDS];
343         acpi_status status = tci_raw(dev, in, out);
344 
345         return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
346 }
347 
348 static u32 hci_read1(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
349 {
350         u32 in[TCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
351         u32 out[TCI_WORDS];
352         acpi_status status = tci_raw(dev, in, out);
353 
354         if (ACPI_FAILURE(status))
355                 return TOS_FAILURE;
356 
357         *out1 = out[2];
358 
359         return out[0];
360 }
361 
362 static u32 hci_write2(struct toshiba_acpi_dev *dev, u32 reg, u32 in1, u32 in2)
363 {
364         u32 in[TCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
365         u32 out[TCI_WORDS];
366         acpi_status status = tci_raw(dev, in, out);
367 
368         return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
369 }
370 
371 static u32 hci_read2(struct toshiba_acpi_dev *dev,
372                      u32 reg, u32 *out1, u32 *out2)
373 {
374         u32 in[TCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
375         u32 out[TCI_WORDS];
376         acpi_status status = tci_raw(dev, in, out);
377 
378         if (ACPI_FAILURE(status))
379                 return TOS_FAILURE;
380 
381         *out1 = out[2];
382         *out2 = out[3];
383 
384         return out[0];
385 }
386 
387 /*
388  * Common sci tasks
389  */
390 
391 static int sci_open(struct toshiba_acpi_dev *dev)
392 {
393         u32 in[TCI_WORDS] = { SCI_OPEN, 0, 0, 0, 0, 0 };
394         u32 out[TCI_WORDS];
395         acpi_status status;
396 
397         status = tci_raw(dev, in, out);
398         if  (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
399                 pr_err("ACPI call to open SCI failed\n");
400                 return 0;
401         }
402 
403         if (out[0] == TOS_OPEN_CLOSE_OK) {
404                 return 1;
405         } else if (out[0] == TOS_ALREADY_OPEN) {
406                 pr_info("Toshiba SCI already opened\n");
407                 return 1;
408         } else if (out[0] == TOS_NOT_SUPPORTED) {
409                 /*
410                  * Some BIOSes do not have the SCI open/close functions
411                  * implemented and return 0x8000 (Not Supported), failing to
412                  * register some supported features.
413                  *
414                  * Simply return 1 if we hit those affected laptops to make the
415                  * supported features work.
416                  *
417                  * In the case that some laptops really do not support the SCI,
418                  * all the SCI dependent functions check for TOS_NOT_SUPPORTED,
419                  * and thus, not registering support for the queried feature.
420                  */
421                 return 1;
422         } else if (out[0] == TOS_NOT_PRESENT) {
423                 pr_info("Toshiba SCI is not present\n");
424         }
425 
426         return 0;
427 }
428 
429 static void sci_close(struct toshiba_acpi_dev *dev)
430 {
431         u32 in[TCI_WORDS] = { SCI_CLOSE, 0, 0, 0, 0, 0 };
432         u32 out[TCI_WORDS];
433         acpi_status status;
434 
435         status = tci_raw(dev, in, out);
436         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
437                 pr_err("ACPI call to close SCI failed\n");
438                 return;
439         }
440 
441         if (out[0] == TOS_OPEN_CLOSE_OK)
442                 return;
443         else if (out[0] == TOS_NOT_OPENED)
444                 pr_info("Toshiba SCI not opened\n");
445         else if (out[0] == TOS_NOT_PRESENT)
446                 pr_info("Toshiba SCI is not present\n");
447 }
448 
449 static u32 sci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
450 {
451         u32 in[TCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 };
452         u32 out[TCI_WORDS];
453         acpi_status status = tci_raw(dev, in, out);
454 
455         if (ACPI_FAILURE(status))
456                 return TOS_FAILURE;
457 
458         *out1 = out[2];
459 
460         return out[0];
461 }
462 
463 static u32 sci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1)
464 {
465         u32 in[TCI_WORDS] = { SCI_SET, reg, in1, 0, 0, 0 };
466         u32 out[TCI_WORDS];
467         acpi_status status = tci_raw(dev, in, out);
468 
469         return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
470 }
471 
472 /* Illumination support */
473 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev)
474 {
475         u32 in[TCI_WORDS] = { SCI_GET, SCI_ILLUMINATION, 0, 0, 0, 0 };
476         u32 out[TCI_WORDS];
477         acpi_status status;
478 
479         if (!sci_open(dev))
480                 return 0;
481 
482         status = tci_raw(dev, in, out);
483         sci_close(dev);
484         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
485                 pr_err("ACPI call to query Illumination support failed\n");
486                 return 0;
487         } else if (out[0] == TOS_NOT_SUPPORTED) {
488                 pr_info("Illumination device not available\n");
489                 return 0;
490         }
491 
492         return 1;
493 }
494 
495 static void toshiba_illumination_set(struct led_classdev *cdev,
496                                      enum led_brightness brightness)
497 {
498         struct toshiba_acpi_dev *dev = container_of(cdev,
499                         struct toshiba_acpi_dev, led_dev);
500         u32 state, result;
501 
502         /* First request : initialize communication. */
503         if (!sci_open(dev))
504                 return;
505 
506         /* Switch the illumination on/off */
507         state = brightness ? 1 : 0;
508         result = sci_write(dev, SCI_ILLUMINATION, state);
509         sci_close(dev);
510         if (result == TOS_FAILURE) {
511                 pr_err("ACPI call for illumination failed\n");
512                 return;
513         } else if (result == TOS_NOT_SUPPORTED) {
514                 pr_info("Illumination not supported\n");
515                 return;
516         }
517 }
518 
519 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
520 {
521         struct toshiba_acpi_dev *dev = container_of(cdev,
522                         struct toshiba_acpi_dev, led_dev);
523         u32 state, result;
524 
525         /* First request : initialize communication. */
526         if (!sci_open(dev))
527                 return LED_OFF;
528 
529         /* Check the illumination */
530         result = sci_read(dev, SCI_ILLUMINATION, &state);
531         sci_close(dev);
532         if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
533                 pr_err("ACPI call for illumination failed\n");
534                 return LED_OFF;
535         } else if (result == TOS_NOT_SUPPORTED) {
536                 pr_info("Illumination not supported\n");
537                 return LED_OFF;
538         }
539 
540         return state ? LED_FULL : LED_OFF;
541 }
542 
543 /* KBD Illumination */
544 static int toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev)
545 {
546         u32 in[TCI_WORDS] = { SCI_GET, SCI_KBD_ILLUM_STATUS, 0, 0, 0, 0 };
547         u32 out[TCI_WORDS];
548         acpi_status status;
549 
550         if (!sci_open(dev))
551                 return 0;
552 
553         status = tci_raw(dev, in, out);
554         sci_close(dev);
555         if (ACPI_FAILURE(status) || out[0] == TOS_INPUT_DATA_ERROR) {
556                 pr_err("ACPI call to query kbd illumination support failed\n");
557                 return 0;
558         } else if (out[0] == TOS_NOT_SUPPORTED) {
559                 pr_info("Keyboard illumination not available\n");
560                 return 0;
561         }
562 
563         /*
564          * Check for keyboard backlight timeout max value,
565          * previous kbd backlight implementation set this to
566          * 0x3c0003, and now the new implementation set this
567          * to 0x3c001a, use this to distinguish between them.
568          */
569         if (out[3] == SCI_KBD_TIME_MAX)
570                 dev->kbd_type = 2;
571         else
572                 dev->kbd_type = 1;
573         /* Get the current keyboard backlight mode */
574         dev->kbd_mode = out[2] & SCI_KBD_MODE_MASK;
575         /* Get the current time (1-60 seconds) */
576         dev->kbd_time = out[2] >> HCI_MISC_SHIFT;
577 
578         return 1;
579 }
580 
581 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time)
582 {
583         u32 result;
584 
585         if (!sci_open(dev))
586                 return -EIO;
587 
588         result = sci_write(dev, SCI_KBD_ILLUM_STATUS, time);
589         sci_close(dev);
590         if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
591                 pr_err("ACPI call to set KBD backlight status failed\n");
592                 return -EIO;
593         } else if (result == TOS_NOT_SUPPORTED) {
594                 pr_info("Keyboard backlight status not supported\n");
595                 return -ENODEV;
596         }
597 
598         return 0;
599 }
600 
601 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time)
602 {
603         u32 result;
604 
605         if (!sci_open(dev))
606                 return -EIO;
607 
608         result = sci_read(dev, SCI_KBD_ILLUM_STATUS, time);
609         sci_close(dev);
610         if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
611                 pr_err("ACPI call to get KBD backlight status failed\n");
612                 return -EIO;
613         } else if (result == TOS_NOT_SUPPORTED) {
614                 pr_info("Keyboard backlight status not supported\n");
615                 return -ENODEV;
616         }
617 
618         return 0;
619 }
620 
621 static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev)
622 {
623         struct toshiba_acpi_dev *dev = container_of(cdev,
624                         struct toshiba_acpi_dev, kbd_led);
625         u32 state, result;
626 
627         /* Check the keyboard backlight state */
628         result = hci_read1(dev, HCI_KBD_ILLUMINATION, &state);
629         if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
630                 pr_err("ACPI call to get the keyboard backlight failed\n");
631                 return LED_OFF;
632         } else if (result == TOS_NOT_SUPPORTED) {
633                 pr_info("Keyboard backlight not supported\n");
634                 return LED_OFF;
635         }
636 
637         return state ? LED_FULL : LED_OFF;
638 }
639 
640 static void toshiba_kbd_backlight_set(struct led_classdev *cdev,
641                                      enum led_brightness brightness)
642 {
643         struct toshiba_acpi_dev *dev = container_of(cdev,
644                         struct toshiba_acpi_dev, kbd_led);
645         u32 state, result;
646 
647         /* Set the keyboard backlight state */
648         state = brightness ? 1 : 0;
649         result = hci_write1(dev, HCI_KBD_ILLUMINATION, state);
650         if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
651                 pr_err("ACPI call to set KBD Illumination mode failed\n");
652                 return;
653         } else if (result == TOS_NOT_SUPPORTED) {
654                 pr_info("Keyboard backlight not supported\n");
655                 return;
656         }
657 }
658 
659 /* TouchPad support */
660 static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state)
661 {
662         u32 result;
663 
664         if (!sci_open(dev))
665                 return -EIO;
666 
667         result = sci_write(dev, SCI_TOUCHPAD, state);
668         sci_close(dev);
669         if (result == TOS_FAILURE) {
670                 pr_err("ACPI call to set the touchpad failed\n");
671                 return -EIO;
672         } else if (result == TOS_NOT_SUPPORTED) {
673                 return -ENODEV;
674         }
675 
676         return 0;
677 }
678 
679 static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state)
680 {
681         u32 result;
682 
683         if (!sci_open(dev))
684                 return -EIO;
685 
686         result = sci_read(dev, SCI_TOUCHPAD, state);
687         sci_close(dev);
688         if (result == TOS_FAILURE) {
689                 pr_err("ACPI call to query the touchpad failed\n");
690                 return -EIO;
691         } else if (result == TOS_NOT_SUPPORTED) {
692                 return -ENODEV;
693         }
694 
695         return 0;
696 }
697 
698 /* Eco Mode support */
699 static int toshiba_eco_mode_available(struct toshiba_acpi_dev *dev)
700 {
701         acpi_status status;
702         u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 };
703         u32 out[TCI_WORDS];
704 
705         status = tci_raw(dev, in, out);
706         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
707                 pr_err("ACPI call to get ECO led failed\n");
708         } else if (out[0] == TOS_NOT_INSTALLED) {
709                 pr_info("ECO led not installed");
710         } else if (out[0] == TOS_INPUT_DATA_ERROR) {
711                 /*
712                  * If we receive 0x8300 (Input Data Error), it means that the
713                  * LED device is present, but that we just screwed the input
714                  * parameters.
715                  *
716                  * Let's query the status of the LED to see if we really have a
717                  * success response, indicating the actual presense of the LED,
718                  * bail out otherwise.
719                  */
720                 in[3] = 1;
721                 status = tci_raw(dev, in, out);
722                 if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE)
723                         pr_err("ACPI call to get ECO led failed\n");
724                 else if (out[0] == TOS_SUCCESS)
725                         return 1;
726         }
727 
728         return 0;
729 }
730 
731 static enum led_brightness
732 toshiba_eco_mode_get_status(struct led_classdev *cdev)
733 {
734         struct toshiba_acpi_dev *dev = container_of(cdev,
735                         struct toshiba_acpi_dev, eco_led);
736         u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 };
737         u32 out[TCI_WORDS];
738         acpi_status status;
739 
740         status = tci_raw(dev, in, out);
741         if (ACPI_FAILURE(status) || out[0] == TOS_INPUT_DATA_ERROR) {
742                 pr_err("ACPI call to get ECO led failed\n");
743                 return LED_OFF;
744         }
745 
746         return out[2] ? LED_FULL : LED_OFF;
747 }
748 
749 static void toshiba_eco_mode_set_status(struct led_classdev *cdev,
750                                      enum led_brightness brightness)
751 {
752         struct toshiba_acpi_dev *dev = container_of(cdev,
753                         struct toshiba_acpi_dev, eco_led);
754         u32 in[TCI_WORDS] = { HCI_SET, HCI_ECO_MODE, 0, 1, 0, 0 };
755         u32 out[TCI_WORDS];
756         acpi_status status;
757 
758         /* Switch the Eco Mode led on/off */
759         in[2] = (brightness) ? 1 : 0;
760         status = tci_raw(dev, in, out);
761         if (ACPI_FAILURE(status) || out[0] == TOS_INPUT_DATA_ERROR) {
762                 pr_err("ACPI call to set ECO led failed\n");
763                 return;
764         }
765 }
766 
767 /* Accelerometer support */
768 static int toshiba_accelerometer_supported(struct toshiba_acpi_dev *dev)
769 {
770         u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER2, 0, 0, 0, 0 };
771         u32 out[TCI_WORDS];
772         acpi_status status;
773 
774         /*
775          * Check if the accelerometer call exists,
776          * this call also serves as initialization
777          */
778         status = tci_raw(dev, in, out);
779         if (ACPI_FAILURE(status) || out[0] == TOS_INPUT_DATA_ERROR) {
780                 pr_err("ACPI call to query the accelerometer failed\n");
781                 return -EIO;
782         } else if (out[0] == TOS_DATA_NOT_AVAILABLE ||
783                    out[0] == TOS_NOT_INITIALIZED) {
784                 pr_err("Accelerometer not initialized\n");
785                 return -EIO;
786         } else if (out[0] == TOS_NOT_SUPPORTED) {
787                 pr_info("Accelerometer not supported\n");
788                 return -ENODEV;
789         }
790 
791         return 0;
792 }
793 
794 static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev,
795                                       u32 *xy, u32 *z)
796 {
797         u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER, 0, 1, 0, 0 };
798         u32 out[TCI_WORDS];
799         acpi_status status;
800 
801         /* Check the Accelerometer status */
802         status = tci_raw(dev, in, out);
803         if (ACPI_FAILURE(status) || out[0] == TOS_INPUT_DATA_ERROR) {
804                 pr_err("ACPI call to query the accelerometer failed\n");
805                 return -EIO;
806         }
807 
808         *xy = out[2];
809         *z = out[4];
810 
811         return 0;
812 }
813 
814 /* Sleep (Charge and Music) utilities support */
815 static void toshiba_usb_sleep_charge_available(struct toshiba_acpi_dev *dev)
816 {
817         u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
818         u32 out[TCI_WORDS];
819         acpi_status status;
820 
821         /* Set the feature to "not supported" in case of error */
822         dev->usb_sleep_charge_supported = 0;
823 
824         if (!sci_open(dev))
825                 return;
826 
827         status = tci_raw(dev, in, out);
828         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
829                 pr_err("ACPI call to get USB Sleep and Charge mode failed\n");
830                 sci_close(dev);
831                 return;
832         } else if (out[0] == TOS_NOT_SUPPORTED) {
833                 pr_info("USB Sleep and Charge not supported\n");
834                 sci_close(dev);
835                 return;
836         } else if (out[0] == TOS_SUCCESS) {
837                 dev->usbsc_mode_base = out[4];
838         }
839 
840         in[5] = SCI_USB_CHARGE_BAT_LVL;
841         status = tci_raw(dev, in, out);
842         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
843                 pr_err("ACPI call to get USB Sleep and Charge mode failed\n");
844                 sci_close(dev);
845                 return;
846         } else if (out[0] == TOS_NOT_SUPPORTED) {
847                 pr_info("USB Sleep and Charge not supported\n");
848                 sci_close(dev);
849                 return;
850         } else if (out[0] == TOS_SUCCESS) {
851                 dev->usbsc_bat_level = out[2];
852                 /*
853                  * If we reach this point, it means that the laptop has support
854                  * for this feature and all values are initialized.
855                  * Set it as supported.
856                  */
857                 dev->usb_sleep_charge_supported = 1;
858         }
859 
860         sci_close(dev);
861 }
862 
863 static int toshiba_usb_sleep_charge_get(struct toshiba_acpi_dev *dev,
864                                         u32 *mode)
865 {
866         u32 result;
867 
868         if (!sci_open(dev))
869                 return -EIO;
870 
871         result = sci_read(dev, SCI_USB_SLEEP_CHARGE, mode);
872         sci_close(dev);
873         if (result == TOS_FAILURE) {
874                 pr_err("ACPI call to set USB S&C mode failed\n");
875                 return -EIO;
876         } else if (result == TOS_NOT_SUPPORTED) {
877                 pr_info("USB Sleep and Charge not supported\n");
878                 return -ENODEV;
879         } else if (result == TOS_INPUT_DATA_ERROR) {
880                 return -EIO;
881         }
882 
883         return 0;
884 }
885 
886 static int toshiba_usb_sleep_charge_set(struct toshiba_acpi_dev *dev,
887                                         u32 mode)
888 {
889         u32 result;
890 
891         if (!sci_open(dev))
892                 return -EIO;
893 
894         result = sci_write(dev, SCI_USB_SLEEP_CHARGE, mode);
895         sci_close(dev);
896         if (result == TOS_FAILURE) {
897                 pr_err("ACPI call to set USB S&C mode failed\n");
898                 return -EIO;
899         } else if (result == TOS_NOT_SUPPORTED) {
900                 pr_info("USB Sleep and Charge not supported\n");
901                 return -ENODEV;
902         } else if (result == TOS_INPUT_DATA_ERROR) {
903                 return -EIO;
904         }
905 
906         return 0;
907 }
908 
909 static int toshiba_sleep_functions_status_get(struct toshiba_acpi_dev *dev,
910                                               u32 *mode)
911 {
912         u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
913         u32 out[TCI_WORDS];
914         acpi_status status;
915 
916         if (!sci_open(dev))
917                 return -EIO;
918 
919         in[5] = SCI_USB_CHARGE_BAT_LVL;
920         status = tci_raw(dev, in, out);
921         sci_close(dev);
922         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
923                 pr_err("ACPI call to get USB S&C battery level failed\n");
924                 return -EIO;
925         } else if (out[0] == TOS_NOT_SUPPORTED) {
926                 pr_info("USB Sleep and Charge not supported\n");
927                 return -ENODEV;
928         } else if (out[0] == TOS_INPUT_DATA_ERROR) {
929                 return -EIO;
930         }
931 
932         *mode = out[2];
933 
934         return 0;
935 }
936 
937 static int toshiba_sleep_functions_status_set(struct toshiba_acpi_dev *dev,
938                                               u32 mode)
939 {
940         u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
941         u32 out[TCI_WORDS];
942         acpi_status status;
943 
944         if (!sci_open(dev))
945                 return -EIO;
946 
947         in[2] = mode;
948         in[5] = SCI_USB_CHARGE_BAT_LVL;
949         status = tci_raw(dev, in, out);
950         sci_close(dev);
951         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
952                 pr_err("ACPI call to set USB S&C battery level failed\n");
953                 return -EIO;
954         } else if (out[0] == TOS_NOT_SUPPORTED) {
955                 pr_info("USB Sleep and Charge not supported\n");
956                 return -ENODEV;
957         } else if (out[0] == TOS_INPUT_DATA_ERROR) {
958                 return -EIO;
959         }
960 
961         return 0;
962 }
963 
964 static int toshiba_usb_rapid_charge_get(struct toshiba_acpi_dev *dev,
965                                         u32 *state)
966 {
967         u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
968         u32 out[TCI_WORDS];
969         acpi_status status;
970 
971         if (!sci_open(dev))
972                 return -EIO;
973 
974         in[5] = SCI_USB_CHARGE_RAPID_DSP;
975         status = tci_raw(dev, in, out);
976         sci_close(dev);
977         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
978                 pr_err("ACPI call to get USB Rapid Charge failed\n");
979                 return -EIO;
980         } else if (out[0] == TOS_NOT_SUPPORTED ||
981                    out[0] == TOS_INPUT_DATA_ERROR) {
982                 pr_info("USB Rapid Charge not supported\n");
983                 return -ENODEV;
984         }
985 
986         *state = out[2];
987 
988         return 0;
989 }
990 
991 static int toshiba_usb_rapid_charge_set(struct toshiba_acpi_dev *dev,
992                                         u32 state)
993 {
994         u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
995         u32 out[TCI_WORDS];
996         acpi_status status;
997 
998         if (!sci_open(dev))
999                 return -EIO;
1000 
1001         in[2] = state;
1002         in[5] = SCI_USB_CHARGE_RAPID_DSP;
1003         status = tci_raw(dev, in, out);
1004         sci_close(dev);
1005         if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
1006                 pr_err("ACPI call to set USB Rapid Charge failed\n");
1007                 return -EIO;
1008         } else if (out[0] == TOS_NOT_SUPPORTED) {
1009                 pr_info("USB Rapid Charge not supported\n");
1010                 return -ENODEV;
1011         } else if (out[0] == TOS_INPUT_DATA_ERROR) {
1012                 return -EIO;
1013         }
1014 
1015         return 0;
1016 }
1017 
1018 static int toshiba_usb_sleep_music_get(struct toshiba_acpi_dev *dev, u32 *state)
1019 {
1020         u32 result;
1021 
1022         if (!sci_open(dev))
1023                 return -EIO;
1024 
1025         result = sci_read(dev, SCI_USB_SLEEP_MUSIC, state);
1026         sci_close(dev);
1027         if (result == TOS_FAILURE) {
1028                 pr_err("ACPI call to get Sleep and Music failed\n");
1029                 return -EIO;
1030         } else if (result == TOS_NOT_SUPPORTED) {
1031                 pr_info("Sleep and Music not supported\n");
1032                 return -ENODEV;
1033         } else if (result == TOS_INPUT_DATA_ERROR) {
1034                 return -EIO;
1035         }
1036 
1037         return 0;
1038 }
1039 
1040 static int toshiba_usb_sleep_music_set(struct toshiba_acpi_dev *dev, u32 state)
1041 {
1042         u32 result;
1043 
1044         if (!sci_open(dev))
1045                 return -EIO;
1046 
1047         result = sci_write(dev, SCI_USB_SLEEP_MUSIC, state);
1048         sci_close(dev);
1049         if (result == TOS_FAILURE) {
1050                 pr_err("ACPI call to set Sleep and Music failed\n");
1051                 return -EIO;
1052         } else if (result == TOS_NOT_SUPPORTED) {
1053                 pr_info("Sleep and Music not supported\n");
1054                 return -ENODEV;
1055         } else if (result == TOS_INPUT_DATA_ERROR) {
1056                 return -EIO;
1057         }
1058 
1059         return 0;
1060 }
1061 
1062 /* Keyboard function keys */
1063 static int toshiba_function_keys_get(struct toshiba_acpi_dev *dev, u32 *mode)
1064 {
1065         u32 result;
1066 
1067         if (!sci_open(dev))
1068                 return -EIO;
1069 
1070         result = sci_read(dev, SCI_KBD_FUNCTION_KEYS, mode);
1071         sci_close(dev);
1072         if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
1073                 pr_err("ACPI call to get KBD function keys failed\n");
1074                 return -EIO;
1075         } else if (result == TOS_NOT_SUPPORTED) {
1076                 pr_info("KBD function keys not supported\n");
1077                 return -ENODEV;
1078         }
1079 
1080         return 0;
1081 }
1082 
1083 static int toshiba_function_keys_set(struct toshiba_acpi_dev *dev, u32 mode)
1084 {
1085         u32 result;
1086 
1087         if (!sci_open(dev))
1088                 return -EIO;
1089 
1090         result = sci_write(dev, SCI_KBD_FUNCTION_KEYS, mode);
1091         sci_close(dev);
1092         if (result == TOS_FAILURE || result == TOS_INPUT_DATA_ERROR) {
1093                 pr_err("ACPI call to set KBD function keys failed\n");
1094                 return -EIO;
1095         } else if (result == TOS_NOT_SUPPORTED) {
1096                 pr_info("KBD function keys not supported\n");
1097                 return -ENODEV;
1098         }
1099 
1100         return 0;
1101 }
1102 
1103 /* Panel Power ON */
1104 static int toshiba_panel_power_on_get(struct toshiba_acpi_dev *dev, u32 *state)
1105 {
1106         u32 result;
1107 
1108         if (!sci_open(dev))
1109                 return -EIO;
1110 
1111         result = sci_read(dev, SCI_PANEL_POWER_ON, state);
1112         sci_close(dev);
1113         if (result == TOS_FAILURE) {
1114                 pr_err("ACPI call to get Panel Power ON failed\n");
1115                 return -EIO;
1116         } else if (result == TOS_NOT_SUPPORTED) {
1117                 pr_info("Panel Power on not supported\n");
1118                 return -ENODEV;
1119         } else if (result == TOS_INPUT_DATA_ERROR) {
1120                 return -EIO;
1121         }
1122 
1123         return 0;
1124 }
1125 
1126 static int toshiba_panel_power_on_set(struct toshiba_acpi_dev *dev, u32 state)
1127 {
1128         u32 result;
1129 
1130         if (!sci_open(dev))
1131                 return -EIO;
1132 
1133         result = sci_write(dev, SCI_PANEL_POWER_ON, state);
1134         sci_close(dev);
1135         if (result == TOS_FAILURE) {
1136                 pr_err("ACPI call to set Panel Power ON failed\n");
1137                 return -EIO;
1138         } else if (result == TOS_NOT_SUPPORTED) {
1139                 pr_info("Panel Power ON not supported\n");
1140                 return -ENODEV;
1141         } else if (result == TOS_INPUT_DATA_ERROR) {
1142                 return -EIO;
1143         }
1144 
1145         return 0;
1146 }
1147 
1148 /* USB Three */
1149 static int toshiba_usb_three_get(struct toshiba_acpi_dev *dev, u32 *state)
1150 {
1151         u32 result;
1152 
1153         if (!sci_open(dev))
1154                 return -EIO;
1155 
1156         result = sci_read(dev, SCI_USB_THREE, state);
1157         sci_close(dev);
1158         if (result == TOS_FAILURE) {
1159                 pr_err("ACPI call to get USB 3 failed\n");
1160                 return -EIO;
1161         } else if (result == TOS_NOT_SUPPORTED) {
1162                 pr_info("USB 3 not supported\n");
1163                 return -ENODEV;
1164         } else if (result == TOS_INPUT_DATA_ERROR) {
1165                 return -EIO;
1166         }
1167 
1168         return 0;
1169 }
1170 
1171 static int toshiba_usb_three_set(struct toshiba_acpi_dev *dev, u32 state)
1172 {
1173         u32 result;
1174 
1175         if (!sci_open(dev))
1176                 return -EIO;
1177 
1178         result = sci_write(dev, SCI_USB_THREE, state);
1179         sci_close(dev);
1180         if (result == TOS_FAILURE) {
1181                 pr_err("ACPI call to set USB 3 failed\n");
1182                 return -EIO;
1183         } else if (result == TOS_NOT_SUPPORTED) {
1184                 pr_info("USB 3 not supported\n");
1185                 return -ENODEV;
1186         } else if (result == TOS_INPUT_DATA_ERROR) {
1187                 return -EIO;
1188         }
1189 
1190         return 0;
1191 }
1192 
1193 /* Hotkey Event type */
1194 static int toshiba_hotkey_event_type_get(struct toshiba_acpi_dev *dev,
1195                                          u32 *type)
1196 {
1197         u32 val1 = 0x03;
1198         u32 val2 = 0;
1199         u32 result;
1200 
1201         result = hci_read2(dev, HCI_SYSTEM_INFO, &val1, &val2);
1202         if (result == TOS_FAILURE) {
1203                 pr_err("ACPI call to get System type failed\n");
1204                 return -EIO;
1205         } else if (result == TOS_NOT_SUPPORTED) {
1206                 pr_info("System type not supported\n");
1207                 return -ENODEV;
1208         }
1209 
1210         *type = val2;
1211 
1212         return 0;
1213 }
1214 
1215 /* Bluetooth rfkill handlers */
1216 
1217 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
1218 {
1219         u32 hci_result;
1220         u32 value, value2;
1221 
1222         value = 0;
1223         value2 = 0;
1224         hci_result = hci_read2(dev, HCI_WIRELESS, &value, &value2);
1225         if (hci_result == TOS_SUCCESS)
1226                 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;
1227 
1228         return hci_result;
1229 }
1230 
1231 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state)
1232 {
1233         u32 hci_result;
1234         u32 value, value2;
1235 
1236         value = 0;
1237         value2 = 0x0001;
1238         hci_result = hci_read2(dev, HCI_WIRELESS, &value, &value2);
1239 
1240         *radio_state = value & HCI_WIRELESS_KILL_SWITCH;
1241         return hci_result;
1242 }
1243 
1244 static int bt_rfkill_set_block(void *data, bool blocked)
1245 {
1246         struct toshiba_acpi_dev *dev = data;
1247         u32 result1, result2;
1248         u32 value;
1249         int err;
1250         bool radio_state;
1251 
1252         value = (blocked == false);
1253 
1254         mutex_lock(&dev->mutex);
1255         if (hci_get_radio_state(dev, &radio_state) != TOS_SUCCESS) {
1256                 err = -EIO;
1257                 goto out;
1258         }
1259 
1260         if (!radio_state) {
1261                 err = 0;
1262                 goto out;
1263         }
1264 
1265         result1 = hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER);
1266         result2 = hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH);
1267 
1268         if (result1 != TOS_SUCCESS || result2 != TOS_SUCCESS)
1269                 err = -EIO;
1270         else
1271                 err = 0;
1272  out:
1273         mutex_unlock(&dev->mutex);
1274         return err;
1275 }
1276 
1277 static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
1278 {
1279         bool new_rfk_state;
1280         bool value;
1281         u32 hci_result;
1282         struct toshiba_acpi_dev *dev = data;
1283 
1284         mutex_lock(&dev->mutex);
1285 
1286         hci_result = hci_get_radio_state(dev, &value);
1287         if (hci_result != TOS_SUCCESS) {
1288                 /* Can't do anything useful */
1289                 mutex_unlock(&dev->mutex);
1290                 return;
1291         }
1292 
1293         new_rfk_state = value;
1294 
1295         mutex_unlock(&dev->mutex);
1296 
1297         if (rfkill_set_hw_state(rfkill, !new_rfk_state))
1298                 bt_rfkill_set_block(data, true);
1299 }
1300 
1301 static const struct rfkill_ops toshiba_rfk_ops = {
1302         .set_block = bt_rfkill_set_block,
1303         .poll = bt_rfkill_poll,
1304 };
1305 
1306 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, bool *enabled)
1307 {
1308         u32 hci_result;
1309         u32 status;
1310 
1311         hci_result = hci_read1(dev, HCI_TR_BACKLIGHT, &status);
1312         *enabled = !status;
1313         return hci_result == TOS_SUCCESS ? 0 : -EIO;
1314 }
1315 
1316 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable)
1317 {
1318         u32 hci_result;
1319         u32 value = !enable;
1320 
1321         hci_result = hci_write1(dev, HCI_TR_BACKLIGHT, value);
1322         return hci_result == TOS_SUCCESS ? 0 : -EIO;
1323 }
1324 
1325 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/;
1326 
1327 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
1328 {
1329         u32 hci_result;
1330         u32 value;
1331         int brightness = 0;
1332 
1333         if (dev->tr_backlight_supported) {
1334                 bool enabled;
1335                 int ret = get_tr_backlight_status(dev, &enabled);
1336 
1337                 if (ret)
1338                         return ret;
1339                 if (enabled)
1340                         return 0;
1341                 brightness++;
1342         }
1343 
1344         hci_result = hci_read1(dev, HCI_LCD_BRIGHTNESS, &value);
1345         if (hci_result == TOS_SUCCESS)
1346                 return brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT);
1347 
1348         return -EIO;
1349 }
1350 
1351 static int get_lcd_brightness(struct backlight_device *bd)
1352 {
1353         struct toshiba_acpi_dev *dev = bl_get_data(bd);
1354 
1355         return __get_lcd_brightness(dev);
1356 }
1357 
1358 static int lcd_proc_show(struct seq_file *m, void *v)
1359 {
1360         struct toshiba_acpi_dev *dev = m->private;
1361         int value;
1362         int levels;
1363 
1364         if (!dev->backlight_dev)
1365                 return -ENODEV;
1366 
1367         levels = dev->backlight_dev->props.max_brightness + 1;
1368         value = get_lcd_brightness(dev->backlight_dev);
1369         if (value >= 0) {
1370                 seq_printf(m, "brightness:              %d\n", value);
1371                 seq_printf(m, "brightness_levels:       %d\n", levels);
1372                 return 0;
1373         }
1374 
1375         pr_err("Error reading LCD brightness\n");
1376         return -EIO;
1377 }
1378 
1379 static int lcd_proc_open(struct inode *inode, struct file *file)
1380 {
1381         return single_open(file, lcd_proc_show, PDE_DATA(inode));
1382 }
1383 
1384 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
1385 {
1386         u32 hci_result;
1387 
1388         if (dev->tr_backlight_supported) {
1389                 bool enable = !value;
1390                 int ret = set_tr_backlight_status(dev, enable);
1391 
1392                 if (ret)
1393                         return ret;
1394                 if (value)
1395                         value--;
1396         }
1397 
1398         value = value << HCI_LCD_BRIGHTNESS_SHIFT;
1399         hci_result = hci_write1(dev, HCI_LCD_BRIGHTNESS, value);
1400         return hci_result == TOS_SUCCESS ? 0 : -EIO;
1401 }
1402 
1403 static int set_lcd_status(struct backlight_device *bd)
1404 {
1405         struct toshiba_acpi_dev *dev = bl_get_data(bd);
1406 
1407         return set_lcd_brightness(dev, bd->props.brightness);
1408 }
1409 
1410 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
1411                               size_t count, loff_t *pos)
1412 {
1413         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
1414         char cmd[42];
1415         size_t len;
1416         int value;
1417         int ret;
1418         int levels = dev->backlight_dev->props.max_brightness + 1;
1419 
1420         len = min(count, sizeof(cmd) - 1);
1421         if (copy_from_user(cmd, buf, len))
1422                 return -EFAULT;
1423         cmd[len] = '\0';
1424 
1425         if (sscanf(cmd, " brightness : %i", &value) == 1 &&
1426             value >= 0 && value < levels) {
1427                 ret = set_lcd_brightness(dev, value);
1428                 if (ret == 0)
1429                         ret = count;
1430         } else {
1431                 ret = -EINVAL;
1432         }
1433         return ret;
1434 }
1435 
1436 static const struct file_operations lcd_proc_fops = {
1437         .owner          = THIS_MODULE,
1438         .open           = lcd_proc_open,
1439         .read           = seq_read,
1440         .llseek         = seq_lseek,
1441         .release        = single_release,
1442         .write          = lcd_proc_write,
1443 };
1444 
1445 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
1446 {
1447         u32 hci_result;
1448 
1449         hci_result = hci_read1(dev, HCI_VIDEO_OUT, status);
1450         return hci_result == TOS_SUCCESS ? 0 : -EIO;
1451 }
1452 
1453 static int video_proc_show(struct seq_file *m, void *v)
1454 {
1455         struct toshiba_acpi_dev *dev = m->private;
1456         u32 value;
1457         int ret;
1458 
1459         ret = get_video_status(dev, &value);
1460         if (!ret) {
1461                 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
1462                 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
1463                 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
1464 
1465                 seq_printf(m, "lcd_out:                 %d\n", is_lcd);
1466                 seq_printf(m, "crt_out:                 %d\n", is_crt);
1467                 seq_printf(m, "tv_out:                  %d\n", is_tv);
1468         }
1469 
1470         return ret;
1471 }
1472 
1473 static int video_proc_open(struct inode *inode, struct file *file)
1474 {
1475         return single_open(file, video_proc_show, PDE_DATA(inode));
1476 }
1477 
1478 static ssize_t video_proc_write(struct file *file, const char __user *buf,
1479                                 size_t count, loff_t *pos)
1480 {
1481         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
1482         char *cmd, *buffer;
1483         int ret;
1484         int value;
1485         int remain = count;
1486         int lcd_out = -1;
1487         int crt_out = -1;
1488         int tv_out = -1;
1489         u32 video_out;
1490 
1491         cmd = kmalloc(count + 1, GFP_KERNEL);
1492         if (!cmd)
1493                 return -ENOMEM;
1494         if (copy_from_user(cmd, buf, count)) {
1495                 kfree(cmd);
1496                 return -EFAULT;
1497         }
1498         cmd[count] = '\0';
1499 
1500         buffer = cmd;
1501 
1502         /*
1503          * Scan expression.  Multiple expressions may be delimited with ;
1504          * NOTE: To keep scanning simple, invalid fields are ignored.
1505          */
1506         while (remain) {
1507                 if (sscanf(buffer, " lcd_out : %i", &value) == 1)
1508                         lcd_out = value & 1;
1509                 else if (sscanf(buffer, " crt_out : %i", &value) == 1)
1510                         crt_out = value & 1;
1511                 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
1512                         tv_out = value & 1;
1513                 /* Advance to one character past the next ; */
1514                 do {
1515                         ++buffer;
1516                         --remain;
1517                 } while (remain && *(buffer - 1) != ';');
1518         }
1519 
1520         kfree(cmd);
1521 
1522         ret = get_video_status(dev, &video_out);
1523         if (!ret) {
1524                 unsigned int new_video_out = video_out;
1525 
1526                 if (lcd_out != -1)
1527                         _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
1528                 if (crt_out != -1)
1529                         _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
1530                 if (tv_out != -1)
1531                         _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
1532                 /*
1533                  * To avoid unnecessary video disruption, only write the new
1534                  * video setting if something changed. */
1535                 if (new_video_out != video_out)
1536                         ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
1537         }
1538 
1539         return ret ? ret : count;
1540 }
1541 
1542 static const struct file_operations video_proc_fops = {
1543         .owner          = THIS_MODULE,
1544         .open           = video_proc_open,
1545         .read           = seq_read,
1546         .llseek         = seq_lseek,
1547         .release        = single_release,
1548         .write          = video_proc_write,
1549 };
1550 
1551 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
1552 {
1553         u32 hci_result;
1554 
1555         hci_result = hci_read1(dev, HCI_FAN, status);
1556         return hci_result == TOS_SUCCESS ? 0 : -EIO;
1557 }
1558 
1559 static int fan_proc_show(struct seq_file *m, void *v)
1560 {
1561         struct toshiba_acpi_dev *dev = m->private;
1562         int ret;
1563         u32 value;
1564 
1565         ret = get_fan_status(dev, &value);
1566         if (!ret) {
1567                 seq_printf(m, "running:                 %d\n", (value > 0));
1568                 seq_printf(m, "force_on:                %d\n", dev->force_fan);
1569         }
1570 
1571         return ret;
1572 }
1573 
1574 static int fan_proc_open(struct inode *inode, struct file *file)
1575 {
1576         return single_open(file, fan_proc_show, PDE_DATA(inode));
1577 }
1578 
1579 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
1580                               size_t count, loff_t *pos)
1581 {
1582         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
1583         char cmd[42];
1584         size_t len;
1585         int value;
1586         u32 hci_result;
1587 
1588         len = min(count, sizeof(cmd) - 1);
1589         if (copy_from_user(cmd, buf, len))
1590                 return -EFAULT;
1591         cmd[len] = '\0';
1592 
1593         if (sscanf(cmd, " force_on : %i", &value) == 1 &&
1594             value >= 0 && value <= 1) {
1595                 hci_result = hci_write1(dev, HCI_FAN, value);
1596                 if (hci_result == TOS_SUCCESS)
1597                         dev->force_fan = value;
1598                 else
1599                         return -EIO;
1600         } else {
1601                 return -EINVAL;
1602         }
1603 
1604         return count;
1605 }
1606 
1607 static const struct file_operations fan_proc_fops = {
1608         .owner          = THIS_MODULE,
1609         .open           = fan_proc_open,
1610         .read           = seq_read,
1611         .llseek         = seq_lseek,
1612         .release        = single_release,
1613         .write          = fan_proc_write,
1614 };
1615 
1616 static int keys_proc_show(struct seq_file *m, void *v)
1617 {
1618         struct toshiba_acpi_dev *dev = m->private;
1619         u32 hci_result;
1620         u32 value;
1621 
1622         if (!dev->key_event_valid && dev->system_event_supported) {
1623                 hci_result = hci_read1(dev, HCI_SYSTEM_EVENT, &value);
1624                 if (hci_result == TOS_SUCCESS) {
1625                         dev->key_event_valid = 1;
1626                         dev->last_key_event = value;
1627                 } else if (hci_result == TOS_FIFO_EMPTY) {
1628                         /* Better luck next time */
1629                 } else if (hci_result == TOS_NOT_SUPPORTED) {
1630                         /*
1631                          * This is a workaround for an unresolved issue on
1632                          * some machines where system events sporadically
1633                          * become disabled.
1634                          */
1635                         hci_result = hci_write1(dev, HCI_SYSTEM_EVENT, 1);
1636                         pr_notice("Re-enabled hotkeys\n");
1637                 } else {
1638                         pr_err("Error reading hotkey status\n");
1639                         return -EIO;
1640                 }
1641         }
1642 
1643         seq_printf(m, "hotkey_ready:            %d\n", dev->key_event_valid);
1644         seq_printf(m, "hotkey:                  0x%04x\n", dev->last_key_event);
1645         return 0;
1646 }
1647 
1648 static int keys_proc_open(struct inode *inode, struct file *file)
1649 {
1650         return single_open(file, keys_proc_show, PDE_DATA(inode));
1651 }
1652 
1653 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
1654                                size_t count, loff_t *pos)
1655 {
1656         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
1657         char cmd[42];
1658         size_t len;
1659         int value;
1660 
1661         len = min(count, sizeof(cmd) - 1);
1662         if (copy_from_user(cmd, buf, len))
1663                 return -EFAULT;
1664         cmd[len] = '\0';
1665 
1666         if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0)
1667                 dev->key_event_valid = 0;
1668         else
1669                 return -EINVAL;
1670 
1671         return count;
1672 }
1673 
1674 static const struct file_operations keys_proc_fops = {
1675         .owner          = THIS_MODULE,
1676         .open           = keys_proc_open,
1677         .read           = seq_read,
1678         .llseek         = seq_lseek,
1679         .release        = single_release,
1680         .write          = keys_proc_write,
1681 };
1682 
1683 static int version_proc_show(struct seq_file *m, void *v)
1684 {
1685         seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
1686         seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
1687         return 0;
1688 }
1689 
1690 static int version_proc_open(struct inode *inode, struct file *file)
1691 {
1692         return single_open(file, version_proc_show, PDE_DATA(inode));
1693 }
1694 
1695 static const struct file_operations version_proc_fops = {
1696         .owner          = THIS_MODULE,
1697         .open           = version_proc_open,
1698         .read           = seq_read,
1699         .llseek         = seq_lseek,
1700         .release        = single_release,
1701 };
1702 
1703 /*
1704  * Proc and module init
1705  */
1706 
1707 #define PROC_TOSHIBA            "toshiba"
1708 
1709 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
1710 {
1711         if (dev->backlight_dev)
1712                 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1713                                  &lcd_proc_fops, dev);
1714         if (dev->video_supported)
1715                 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1716                                  &video_proc_fops, dev);
1717         if (dev->fan_supported)
1718                 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1719                                  &fan_proc_fops, dev);
1720         if (dev->hotkey_dev)
1721                 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1722                                  &keys_proc_fops, dev);
1723         proc_create_data("version", S_IRUGO, toshiba_proc_dir,
1724                          &version_proc_fops, dev);
1725 }
1726 
1727 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
1728 {
1729         if (dev->backlight_dev)
1730                 remove_proc_entry("lcd", toshiba_proc_dir);
1731         if (dev->video_supported)
1732                 remove_proc_entry("video", toshiba_proc_dir);
1733         if (dev->fan_supported)
1734                 remove_proc_entry("fan", toshiba_proc_dir);
1735         if (dev->hotkey_dev)
1736                 remove_proc_entry("keys", toshiba_proc_dir);
1737         remove_proc_entry("version", toshiba_proc_dir);
1738 }
1739 
1740 static const struct backlight_ops toshiba_backlight_data = {
1741         .options = BL_CORE_SUSPENDRESUME,
1742         .get_brightness = get_lcd_brightness,
1743         .update_status  = set_lcd_status,
1744 };
1745 
1746 /*
1747  * Sysfs files
1748  */
1749 static ssize_t version_show(struct device *dev,
1750                             struct device_attribute *attr, char *buf)
1751 {
1752         return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION);
1753 }
1754 static DEVICE_ATTR_RO(version);
1755 
1756 static ssize_t fan_store(struct device *dev,
1757                          struct device_attribute *attr,
1758                          const char *buf, size_t count)
1759 {
1760         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1761         u32 result;
1762         int state;
1763         int ret;
1764 
1765         ret = kstrtoint(buf, 0, &state);
1766         if (ret)
1767                 return ret;
1768 
1769         if (state != 0 && state != 1)
1770                 return -EINVAL;
1771 
1772         result = hci_write1(toshiba, HCI_FAN, state);
1773         if (result == TOS_FAILURE)
1774                 return -EIO;
1775         else if (result == TOS_NOT_SUPPORTED)
1776                 return -ENODEV;
1777 
1778         return count;
1779 }
1780 
1781 static ssize_t fan_show(struct device *dev,
1782                         struct device_attribute *attr, char *buf)
1783 {
1784         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1785         u32 value;
1786         int ret;
1787 
1788         ret = get_fan_status(toshiba, &value);
1789         if (ret)
1790                 return ret;
1791 
1792         return sprintf(buf, "%d\n", value);
1793 }
1794 static DEVICE_ATTR_RW(fan);
1795 
1796 static ssize_t kbd_backlight_mode_store(struct device *dev,
1797                                         struct device_attribute *attr,
1798                                         const char *buf, size_t count)
1799 {
1800         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1801         int mode;
1802         int time;
1803         int ret;
1804 
1805 
1806         ret = kstrtoint(buf, 0, &mode);
1807         if (ret)
1808                 return ret;
1809 
1810         /* Check for supported modes depending on keyboard backlight type */
1811         if (toshiba->kbd_type == 1) {
1812                 /* Type 1 supports SCI_KBD_MODE_FNZ and SCI_KBD_MODE_AUTO */
1813                 if (mode != SCI_KBD_MODE_FNZ && mode != SCI_KBD_MODE_AUTO)
1814                         return -EINVAL;
1815         } else if (toshiba->kbd_type == 2) {
1816                 /* Type 2 doesn't support SCI_KBD_MODE_FNZ */
1817                 if (mode != SCI_KBD_MODE_AUTO && mode != SCI_KBD_MODE_ON &&
1818                     mode != SCI_KBD_MODE_OFF)
1819                         return -EINVAL;
1820         }
1821 
1822         /*
1823          * Set the Keyboard Backlight Mode where:
1824          *      Auto - KBD backlight turns off automatically in given time
1825          *      FN-Z - KBD backlight "toggles" when hotkey pressed
1826          *      ON   - KBD backlight is always on
1827          *      OFF  - KBD backlight is always off
1828          */
1829 
1830         /* Only make a change if the actual mode has changed */
1831         if (toshiba->kbd_mode != mode) {
1832                 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */
1833                 time = toshiba->kbd_time << HCI_MISC_SHIFT;
1834 
1835                 /* OR the "base time" to the actual method format */
1836                 if (toshiba->kbd_type == 1) {
1837                         /* Type 1 requires the current mode */
1838                         time |= toshiba->kbd_mode;
1839                 } else if (toshiba->kbd_type == 2) {
1840                         /* Type 2 requires the desired mode */
1841                         time |= mode;
1842                 }
1843 
1844                 ret = toshiba_kbd_illum_status_set(toshiba, time);
1845                 if (ret)
1846                         return ret;
1847 
1848                 toshiba->kbd_mode = mode;
1849         }
1850 
1851         return count;
1852 }
1853 
1854 static ssize_t kbd_backlight_mode_show(struct device *dev,
1855                                        struct device_attribute *attr,
1856                                        char *buf)
1857 {
1858         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1859         u32 time;
1860 
1861         if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
1862                 return -EIO;
1863 
1864         return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK);
1865 }
1866 static DEVICE_ATTR_RW(kbd_backlight_mode);
1867 
1868 static ssize_t kbd_type_show(struct device *dev,
1869                              struct device_attribute *attr, char *buf)
1870 {
1871         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1872 
1873         return sprintf(buf, "%d\n", toshiba->kbd_type);
1874 }
1875 static DEVICE_ATTR_RO(kbd_type);
1876 
1877 static ssize_t available_kbd_modes_show(struct device *dev,
1878                                         struct device_attribute *attr,
1879                                         char *buf)
1880 {
1881         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1882 
1883         if (toshiba->kbd_type == 1)
1884                 return sprintf(buf, "%x %x\n",
1885                                SCI_KBD_MODE_FNZ, SCI_KBD_MODE_AUTO);
1886 
1887         return sprintf(buf, "%x %x %x\n",
1888                        SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF);
1889 }
1890 static DEVICE_ATTR_RO(available_kbd_modes);
1891 
1892 static ssize_t kbd_backlight_timeout_store(struct device *dev,
1893                                            struct device_attribute *attr,
1894                                            const char *buf, size_t count)
1895 {
1896         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1897         int time;
1898         int ret;
1899 
1900         ret = kstrtoint(buf, 0, &time);
1901         if (ret)
1902                 return ret;
1903 
1904         /* Check for supported values depending on kbd_type */
1905         if (toshiba->kbd_type == 1) {
1906                 if (time < 0 || time > 60)
1907                         return -EINVAL;
1908         } else if (toshiba->kbd_type == 2) {
1909                 if (time < 1 || time > 60)
1910                         return -EINVAL;
1911         }
1912 
1913         /* Set the Keyboard Backlight Timeout */
1914 
1915         /* Only make a change if the actual timeout has changed */
1916         if (toshiba->kbd_time != time) {
1917                 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */
1918                 time = time << HCI_MISC_SHIFT;
1919                 /* OR the "base time" to the actual method format */
1920                 if (toshiba->kbd_type == 1)
1921                         time |= SCI_KBD_MODE_FNZ;
1922                 else if (toshiba->kbd_type == 2)
1923                         time |= SCI_KBD_MODE_AUTO;
1924 
1925                 ret = toshiba_kbd_illum_status_set(toshiba, time);
1926                 if (ret)
1927                         return ret;
1928 
1929                 toshiba->kbd_time = time >> HCI_MISC_SHIFT;
1930         }
1931 
1932         return count;
1933 }
1934 
1935 static ssize_t kbd_backlight_timeout_show(struct device *dev,
1936                                           struct device_attribute *attr,
1937                                           char *buf)
1938 {
1939         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1940         u32 time;
1941 
1942         if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
1943                 return -EIO;
1944 
1945         return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT);
1946 }
1947 static DEVICE_ATTR_RW(kbd_backlight_timeout);
1948 
1949 static ssize_t touchpad_store(struct device *dev,
1950                               struct device_attribute *attr,
1951                               const char *buf, size_t count)
1952 {
1953         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1954         int state;
1955         int ret;
1956 
1957         /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */
1958         ret = kstrtoint(buf, 0, &state);
1959         if (ret)
1960                 return ret;
1961         if (state != 0 && state != 1)
1962                 return -EINVAL;
1963 
1964         ret = toshiba_touchpad_set(toshiba, state);
1965         if (ret)
1966                 return ret;
1967 
1968         return count;
1969 }
1970 
1971 static ssize_t touchpad_show(struct device *dev,
1972                              struct device_attribute *attr, char *buf)
1973 {
1974         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1975         u32 state;
1976         int ret;
1977 
1978         ret = toshiba_touchpad_get(toshiba, &state);
1979         if (ret < 0)
1980                 return ret;
1981 
1982         return sprintf(buf, "%i\n", state);
1983 }
1984 static DEVICE_ATTR_RW(touchpad);
1985 
1986 static ssize_t position_show(struct device *dev,
1987                              struct device_attribute *attr, char *buf)
1988 {
1989         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1990         u32 xyval, zval, tmp;
1991         u16 x, y, z;
1992         int ret;
1993 
1994         xyval = zval = 0;
1995         ret = toshiba_accelerometer_get(toshiba, &xyval, &zval);
1996         if (ret < 0)
1997                 return ret;
1998 
1999         x = xyval & HCI_ACCEL_MASK;
2000         tmp = xyval >> HCI_MISC_SHIFT;
2001         y = tmp & HCI_ACCEL_MASK;
2002         z = zval & HCI_ACCEL_MASK;
2003 
2004         return sprintf(buf, "%d %d %d\n", x, y, z);
2005 }
2006 static DEVICE_ATTR_RO(position);
2007 
2008 static ssize_t usb_sleep_charge_show(struct device *dev,
2009                                      struct device_attribute *attr, char *buf)
2010 {
2011         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2012         u32 mode;
2013         int ret;
2014 
2015         ret = toshiba_usb_sleep_charge_get(toshiba, &mode);
2016         if (ret < 0)
2017                 return ret;
2018 
2019         return sprintf(buf, "%x\n", mode & SCI_USB_CHARGE_MODE_MASK);
2020 }
2021 
2022 static ssize_t usb_sleep_charge_store(struct device *dev,
2023                                       struct device_attribute *attr,
2024                                       const char *buf, size_t count)
2025 {
2026         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2027         u32 mode;
2028         int state;
2029         int ret;
2030 
2031         ret = kstrtoint(buf, 0, &state);
2032         if (ret)
2033                 return ret;
2034         /*
2035          * Check for supported values, where:
2036          * 0 - Disabled
2037          * 1 - Alternate (Non USB conformant devices that require more power)
2038          * 2 - Auto (USB conformant devices)
2039          * 3 - Typical
2040          */
2041         if (state != 0 && state != 1 && state != 2 && state != 3)
2042                 return -EINVAL;
2043 
2044         /* Set the USB charging mode to internal value */
2045         mode = toshiba->usbsc_mode_base;
2046         if (state == 0)
2047                 mode |= SCI_USB_CHARGE_DISABLED;
2048         else if (state == 1)
2049                 mode |= SCI_USB_CHARGE_ALTERNATE;
2050         else if (state == 2)
2051                 mode |= SCI_USB_CHARGE_AUTO;
2052         else if (state == 3)
2053                 mode |= SCI_USB_CHARGE_TYPICAL;
2054 
2055         ret = toshiba_usb_sleep_charge_set(toshiba, mode);
2056         if (ret)
2057                 return ret;
2058 
2059         return count;
2060 }
2061 static DEVICE_ATTR_RW(usb_sleep_charge);
2062 
2063 static ssize_t sleep_functions_on_battery_show(struct device *dev,
2064                                                struct device_attribute *attr,
2065                                                char *buf)
2066 {
2067         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2068         u32 state;
2069         int bat_lvl;
2070         int status;
2071         int ret;
2072         int tmp;
2073 
2074         ret = toshiba_sleep_functions_status_get(toshiba, &state);
2075         if (ret < 0)
2076                 return ret;
2077 
2078         /* Determine the status: 0x4 - Enabled | 0x1 - Disabled */
2079         tmp = state & SCI_USB_CHARGE_BAT_MASK;
2080         status = (tmp == 0x4) ? 1 : 0;
2081         /* Determine the battery level set */
2082         bat_lvl = state >> HCI_MISC_SHIFT;
2083 
2084         return sprintf(buf, "%d %d\n", status, bat_lvl);
2085 }
2086 
2087 static ssize_t sleep_functions_on_battery_store(struct device *dev,
2088                                                 struct device_attribute *attr,
2089                                                 const char *buf, size_t count)
2090 {
2091         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2092         u32 status;
2093         int value;
2094         int ret;
2095         int tmp;
2096 
2097         ret = kstrtoint(buf, 0, &value);
2098         if (ret)
2099                 return ret;
2100 
2101         /*
2102          * Set the status of the function:
2103          * 0 - Disabled
2104          * 1-100 - Enabled
2105          */
2106         if (value < 0 || value > 100)
2107                 return -EINVAL;
2108 
2109         if (value == 0) {
2110                 tmp = toshiba->usbsc_bat_level << HCI_MISC_SHIFT;
2111                 status = tmp | SCI_USB_CHARGE_BAT_LVL_OFF;
2112         } else {
2113                 tmp = value << HCI_MISC_SHIFT;
2114                 status = tmp | SCI_USB_CHARGE_BAT_LVL_ON;
2115         }
2116         ret = toshiba_sleep_functions_status_set(toshiba, status);
2117         if (ret < 0)
2118                 return ret;
2119 
2120         toshiba->usbsc_bat_level = status >> HCI_MISC_SHIFT;
2121 
2122         return count;
2123 }
2124 static DEVICE_ATTR_RW(sleep_functions_on_battery);
2125 
2126 static ssize_t usb_rapid_charge_show(struct device *dev,
2127                                      struct device_attribute *attr, char *buf)
2128 {
2129         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2130         u32 state;
2131         int ret;
2132 
2133         ret = toshiba_usb_rapid_charge_get(toshiba, &state);
2134         if (ret < 0)
2135                 return ret;
2136 
2137         return sprintf(buf, "%d\n", state);
2138 }
2139 
2140 static ssize_t usb_rapid_charge_store(struct device *dev,
2141                                       struct device_attribute *attr,
2142                                       const char *buf, size_t count)
2143 {
2144         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2145         int state;
2146         int ret;
2147 
2148         ret = kstrtoint(buf, 0, &state);
2149         if (ret)
2150                 return ret;
2151         if (state != 0 && state != 1)
2152                 return -EINVAL;
2153 
2154         ret = toshiba_usb_rapid_charge_set(toshiba, state);
2155         if (ret)
2156                 return ret;
2157 
2158         return count;
2159 }
2160 static DEVICE_ATTR_RW(usb_rapid_charge);
2161 
2162 static ssize_t usb_sleep_music_show(struct device *dev,
2163                                     struct device_attribute *attr, char *buf)
2164 {
2165         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2166         u32 state;
2167         int ret;
2168 
2169         ret = toshiba_usb_sleep_music_get(toshiba, &state);
2170         if (ret < 0)
2171                 return ret;
2172 
2173         return sprintf(buf, "%d\n", state);
2174 }
2175 
2176 static ssize_t usb_sleep_music_store(struct device *dev,
2177                                      struct device_attribute *attr,
2178                                      const char *buf, size_t count)
2179 {
2180         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2181         int state;
2182         int ret;
2183 
2184         ret = kstrtoint(buf, 0, &state);
2185         if (ret)
2186                 return ret;
2187         if (state != 0 && state != 1)
2188                 return -EINVAL;
2189 
2190         ret = toshiba_usb_sleep_music_set(toshiba, state);
2191         if (ret)
2192                 return ret;
2193 
2194         return count;
2195 }
2196 static DEVICE_ATTR_RW(usb_sleep_music);
2197 
2198 static ssize_t kbd_function_keys_show(struct device *dev,
2199                                       struct device_attribute *attr, char *buf)
2200 {
2201         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2202         int mode;
2203         int ret;
2204 
2205         ret = toshiba_function_keys_get(toshiba, &mode);
2206         if (ret < 0)
2207                 return ret;
2208 
2209         return sprintf(buf, "%d\n", mode);
2210 }
2211 
2212 static ssize_t kbd_function_keys_store(struct device *dev,
2213                                        struct device_attribute *attr,
2214                                        const char *buf, size_t count)
2215 {
2216         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2217         int mode;
2218         int ret;
2219 
2220         ret = kstrtoint(buf, 0, &mode);
2221         if (ret)
2222                 return ret;
2223         /*
2224          * Check for the function keys mode where:
2225          * 0 - Normal operation (F{1-12} as usual and hotkeys via FN-F{1-12})
2226          * 1 - Special functions (Opposite of the above setting)
2227          */
2228         if (mode != 0 && mode != 1)
2229                 return -EINVAL;
2230 
2231         ret = toshiba_function_keys_set(toshiba, mode);
2232         if (ret)
2233                 return ret;
2234 
2235         pr_info("Reboot for changes to KBD Function Keys to take effect");
2236 
2237         return count;
2238 }
2239 static DEVICE_ATTR_RW(kbd_function_keys);
2240 
2241 static ssize_t panel_power_on_show(struct device *dev,
2242                                    struct device_attribute *attr, char *buf)
2243 {
2244         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2245         u32 state;
2246         int ret;
2247 
2248         ret = toshiba_panel_power_on_get(toshiba, &state);
2249         if (ret < 0)
2250                 return ret;
2251 
2252         return sprintf(buf, "%d\n", state);
2253 }
2254 
2255 static ssize_t panel_power_on_store(struct device *dev,
2256                                     struct device_attribute *attr,
2257                                     const char *buf, size_t count)
2258 {
2259         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2260         int state;
2261         int ret;
2262 
2263         ret = kstrtoint(buf, 0, &state);
2264         if (ret)
2265                 return ret;
2266         if (state != 0 && state != 1)
2267                 return -EINVAL;
2268 
2269         ret = toshiba_panel_power_on_set(toshiba, state);
2270         if (ret)
2271                 return ret;
2272 
2273         pr_info("Reboot for changes to Panel Power ON to take effect");
2274 
2275         return count;
2276 }
2277 static DEVICE_ATTR_RW(panel_power_on);
2278 
2279 static ssize_t usb_three_show(struct device *dev,
2280                               struct device_attribute *attr, char *buf)
2281 {
2282         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2283         u32 state;
2284         int ret;
2285 
2286         ret = toshiba_usb_three_get(toshiba, &state);
2287         if (ret < 0)
2288                 return ret;
2289 
2290         return sprintf(buf, "%d\n", state);
2291 }
2292 
2293 static ssize_t usb_three_store(struct device *dev,
2294                                struct device_attribute *attr,
2295                                const char *buf, size_t count)
2296 {
2297         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
2298         int state;
2299         int ret;
2300 
2301         ret = kstrtoint(buf, 0, &state);
2302         if (ret)
2303                 return ret;
2304         /*
2305          * Check for USB 3 mode where:
2306          * 0 - Disabled (Acts like a USB 2 port, saving power)
2307          * 1 - Enabled
2308          */
2309         if (state != 0 && state != 1)
2310                 return -EINVAL;
2311 
2312         ret = toshiba_usb_three_set(toshiba, state);
2313         if (ret)
2314                 return ret;
2315 
2316         pr_info("Reboot for changes to USB 3 to take effect");
2317 
2318         return count;
2319 }
2320 static DEVICE_ATTR_RW(usb_three);
2321 
2322 static struct attribute *toshiba_attributes[] = {
2323         &dev_attr_version.attr,
2324         &dev_attr_fan.attr,
2325         &dev_attr_kbd_backlight_mode.attr,
2326         &dev_attr_kbd_type.attr,
2327         &dev_attr_available_kbd_modes.attr,
2328         &dev_attr_kbd_backlight_timeout.attr,
2329         &dev_attr_touchpad.attr,
2330         &dev_attr_position.attr,
2331         &dev_attr_usb_sleep_charge.attr,
2332         &dev_attr_sleep_functions_on_battery.attr,
2333         &dev_attr_usb_rapid_charge.attr,
2334         &dev_attr_usb_sleep_music.attr,
2335         &dev_attr_kbd_function_keys.attr,
2336         &dev_attr_panel_power_on.attr,
2337         &dev_attr_usb_three.attr,
2338         NULL,
2339 };
2340 
2341 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
2342                                         struct attribute *attr, int idx)
2343 {
2344         struct device *dev = container_of(kobj, struct device, kobj);
2345         struct toshiba_acpi_dev *drv = dev_get_drvdata(dev);
2346         bool exists = true;
2347 
2348         if (attr == &dev_attr_fan.attr)
2349                 exists = (drv->fan_supported) ? true : false;
2350         else if (attr == &dev_attr_kbd_backlight_mode.attr)
2351                 exists = (drv->kbd_illum_supported) ? true : false;
2352         else if (attr == &dev_attr_kbd_backlight_timeout.attr)
2353                 exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false;
2354         else if (attr == &dev_attr_touchpad.attr)
2355                 exists = (drv->touchpad_supported) ? true : false;
2356         else if (attr == &dev_attr_position.attr)
2357                 exists = (drv->accelerometer_supported) ? true : false;
2358         else if (attr == &dev_attr_usb_sleep_charge.attr)
2359                 exists = (drv->usb_sleep_charge_supported) ? true : false;
2360         else if (attr == &dev_attr_sleep_functions_on_battery.attr)
2361                 exists = (drv->usb_sleep_charge_supported) ? true : false;
2362         else if (attr == &dev_attr_usb_rapid_charge.attr)
2363                 exists = (drv->usb_rapid_charge_supported) ? true : false;
2364         else if (attr == &dev_attr_usb_sleep_music.attr)
2365                 exists = (drv->usb_sleep_music_supported) ? true : false;
2366         else if (attr == &dev_attr_kbd_function_keys.attr)
2367                 exists = (drv->kbd_function_keys_supported) ? true : false;
2368         else if (attr == &dev_attr_panel_power_on.attr)
2369                 exists = (drv->panel_power_on_supported) ? true : false;
2370         else if (attr == &dev_attr_usb_three.attr)
2371                 exists = (drv->usb_three_supported) ? true : false;
2372 
2373         return exists ? attr->mode : 0;
2374 }
2375 
2376 static struct attribute_group toshiba_attr_group = {
2377         .is_visible = toshiba_sysfs_is_visible,
2378         .attrs = toshiba_attributes,
2379 };
2380 
2381 /*
2382  * Hotkeys
2383  */
2384 static int toshiba_acpi_enable_hotkeys(struct toshiba_acpi_dev *dev)
2385 {
2386         acpi_status status;
2387         u32 result;
2388 
2389         status = acpi_evaluate_object(dev->acpi_dev->handle,
2390                                       "ENAB", NULL, NULL);
2391         if (ACPI_FAILURE(status))
2392                 return -ENODEV;
2393 
2394         result = hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE);
2395         if (result == TOS_FAILURE)
2396                 return -EIO;
2397         else if (result == TOS_NOT_SUPPORTED)
2398                 return -ENODEV;
2399 
2400         return 0;
2401 }
2402 
2403 static void toshiba_acpi_enable_special_functions(struct toshiba_acpi_dev *dev)
2404 {
2405         u32 result;
2406 
2407         /*
2408          * Re-activate the hotkeys, but this time, we are using the
2409          * "Special Functions" mode.
2410          */
2411         result = hci_write1(dev, HCI_HOTKEY_EVENT,
2412                             HCI_HOTKEY_SPECIAL_FUNCTIONS);
2413         if (result != TOS_SUCCESS)
2414                 pr_err("Could not enable the Special Function mode\n");
2415 }
2416 
2417 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str,
2418                                       struct serio *port)
2419 {
2420         if (str & I8042_STR_AUXDATA)
2421                 return false;
2422 
2423         if (unlikely(data == 0xe0))
2424                 return false;
2425 
2426         if ((data & 0x7f) == TOS1900_FN_SCAN) {
2427                 schedule_work(&toshiba_acpi->hotkey_work);
2428                 return true;
2429         }
2430 
2431         return false;
2432 }
2433 
2434 static void toshiba_acpi_hotkey_work(struct work_struct *work)
2435 {
2436         acpi_handle ec_handle = ec_get_handle();
2437         acpi_status status;
2438 
2439         if (!ec_handle)
2440                 return;
2441 
2442         status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL);
2443         if (ACPI_FAILURE(status))
2444                 pr_err("ACPI NTFY method execution failed\n");
2445 }
2446 
2447 /*
2448  * Returns hotkey scancode, or < 0 on failure.
2449  */
2450 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
2451 {
2452         unsigned long long value;
2453         acpi_status status;
2454 
2455         status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO",
2456                                       NULL, &value);
2457         if (ACPI_FAILURE(status)) {
2458                 pr_err("ACPI INFO method execution failed\n");
2459                 return -EIO;
2460         }
2461 
2462         return value;
2463 }
2464 
2465 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
2466                                        int scancode)
2467 {
2468         if (scancode == 0x100)
2469                 return;
2470 
2471         /* Act on key press; ignore key release */
2472         if (scancode & 0x80)
2473                 return;
2474 
2475         if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true))
2476                 pr_info("Unknown key %x\n", scancode);
2477 }
2478 
2479 static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev)
2480 {
2481         u32 hci_result, value;
2482         int retries = 3;
2483         int scancode;
2484 
2485         if (dev->info_supported) {
2486                 scancode = toshiba_acpi_query_hotkey(dev);
2487                 if (scancode < 0)
2488                         pr_err("Failed to query hotkey event\n");
2489                 else if (scancode != 0)
2490                         toshiba_acpi_report_hotkey(dev, scancode);
2491         } else if (dev->system_event_supported) {
2492                 do {
2493                         hci_result = hci_read1(dev, HCI_SYSTEM_EVENT, &value);
2494                         switch (hci_result) {
2495                         case TOS_SUCCESS:
2496                                 toshiba_acpi_report_hotkey(dev, (int)value);
2497                                 break;
2498                         case TOS_NOT_SUPPORTED:
2499                                 /*
2500                                  * This is a workaround for an unresolved
2501                                  * issue on some machines where system events
2502                                  * sporadically become disabled.
2503                                  */
2504                                 hci_result =
2505                                         hci_write1(dev, HCI_SYSTEM_EVENT, 1);
2506                                 pr_notice("Re-enabled hotkeys\n");
2507                                 /* Fall through */
2508                         default:
2509                                 retries--;
2510                                 break;
2511                         }
2512                 } while (retries && hci_result != TOS_FIFO_EMPTY);
2513         }
2514 }
2515 
2516 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
2517 {
2518         const struct key_entry *keymap = toshiba_acpi_keymap;
2519         acpi_handle ec_handle;
2520         u32 events_type;
2521         u32 hci_result;
2522         int error;
2523 
2524         error = toshiba_acpi_enable_hotkeys(dev);
2525         if (error)
2526                 return error;
2527 
2528         error = toshiba_hotkey_event_type_get(dev, &events_type);
2529         if (error) {
2530                 pr_err("Unable to query Hotkey Event Type\n");
2531                 return error;
2532         }
2533         dev->hotkey_event_type = events_type;
2534 
2535         dev->hotkey_dev = input_allocate_device();
2536         if (!dev->hotkey_dev)
2537                 return -ENOMEM;
2538 
2539         dev->hotkey_dev->name = "Toshiba input device";
2540         dev->hotkey_dev->phys = "toshiba_acpi/input0";
2541         dev->hotkey_dev->id.bustype = BUS_HOST;
2542 
2543         if (events_type == HCI_SYSTEM_TYPE1 ||
2544             !dev->kbd_function_keys_supported)
2545                 keymap = toshiba_acpi_keymap;
2546         else if (events_type == HCI_SYSTEM_TYPE2 ||
2547                  dev->kbd_function_keys_supported)
2548                 keymap = toshiba_acpi_alt_keymap;
2549         else
2550                 pr_info("Unknown event type received %x\n", events_type);
2551         error = sparse_keymap_setup(dev->hotkey_dev, keymap, NULL);
2552         if (error)
2553                 goto err_free_dev;
2554 
2555         /*
2556          * For some machines the SCI responsible for providing hotkey
2557          * notification doesn't fire. We can trigger the notification
2558          * whenever the Fn key is pressed using the NTFY method, if
2559          * supported, so if it's present set up an i8042 key filter
2560          * for this purpose.
2561          */
2562         ec_handle = ec_get_handle();
2563         if (ec_handle && acpi_has_method(ec_handle, "NTFY")) {
2564                 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);
2565 
2566                 error = i8042_install_filter(toshiba_acpi_i8042_filter);
2567                 if (error) {
2568                         pr_err("Error installing key filter\n");
2569                         goto err_free_keymap;
2570                 }
2571 
2572                 dev->ntfy_supported = 1;
2573         }
2574 
2575         /*
2576          * Determine hotkey query interface. Prefer using the INFO
2577          * method when it is available.
2578          */
2579         if (acpi_has_method(dev->acpi_dev->handle, "INFO"))
2580                 dev->info_supported = 1;
2581         else {
2582                 hci_result = hci_write1(dev, HCI_SYSTEM_EVENT, 1);
2583                 if (hci_result == TOS_SUCCESS)
2584                         dev->system_event_supported = 1;
2585         }
2586 
2587         if (!dev->info_supported && !dev->system_event_supported) {
2588                 pr_warn("No hotkey query interface found\n");
2589                 goto err_remove_filter;
2590         }
2591 
2592         error = input_register_device(dev->hotkey_dev);
2593         if (error) {
2594                 pr_info("Unable to register input device\n");
2595                 goto err_remove_filter;
2596         }
2597 
2598         return 0;
2599 
2600  err_remove_filter:
2601         if (dev->ntfy_supported)
2602                 i8042_remove_filter(toshiba_acpi_i8042_filter);
2603  err_free_keymap:
2604         sparse_keymap_free(dev->hotkey_dev);
2605  err_free_dev:
2606         input_free_device(dev->hotkey_dev);
2607         dev->hotkey_dev = NULL;
2608         return error;
2609 }
2610 
2611 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
2612 {
2613         struct backlight_properties props;
2614         int brightness;
2615         int ret;
2616         bool enabled;
2617 
2618         /*
2619          * Some machines don't support the backlight methods at all, and
2620          * others support it read-only. Either of these is pretty useless,
2621          * so only register the backlight device if the backlight method
2622          * supports both reads and writes.
2623          */
2624         brightness = __get_lcd_brightness(dev);
2625         if (brightness < 0)
2626                 return 0;
2627         ret = set_lcd_brightness(dev, brightness);
2628         if (ret) {
2629                 pr_debug("Backlight method is read-only, disabling backlight support\n");
2630                 return 0;
2631         }
2632 
2633         /* Determine whether or not BIOS supports transflective backlight */
2634         ret = get_tr_backlight_status(dev, &enabled);
2635         dev->tr_backlight_supported = !ret;
2636 
2637         /*
2638          * Tell acpi-video-detect code to prefer vendor backlight on all
2639          * systems with transflective backlight and on dmi matched systems.
2640          */
2641         if (dev->tr_backlight_supported ||
2642             dmi_check_system(toshiba_vendor_backlight_dmi))
2643                 acpi_video_dmi_promote_vendor();
2644 
2645         if (acpi_video_backlight_support())
2646                 return 0;
2647 
2648         /* acpi-video may have loaded before we called dmi_promote_vendor() */
2649         acpi_video_unregister_backlight();
2650 
2651         memset(&props, 0, sizeof(props));
2652         props.type = BACKLIGHT_PLATFORM;
2653         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
2654 
2655         /* Adding an extra level and having 0 change to transflective mode */
2656         if (dev->tr_backlight_supported)
2657                 props.max_brightness++;
2658 
2659         dev->backlight_dev = backlight_device_register("toshiba",
2660                                                        &dev->acpi_dev->dev,
2661                                                        dev,
2662                                                        &toshiba_backlight_data,
2663                                                        &props);
2664         if (IS_ERR(dev->backlight_dev)) {
2665                 ret = PTR_ERR(dev->backlight_dev);
2666                 pr_err("Could not register toshiba backlight device\n");
2667                 dev->backlight_dev = NULL;
2668                 return ret;
2669         }
2670 
2671         dev->backlight_dev->props.brightness = brightness;
2672         return 0;
2673 }
2674 
2675 static int toshiba_acpi_remove(struct acpi_device *acpi_dev)
2676 {
2677         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
2678 
2679         remove_toshiba_proc_entries(dev);
2680 
2681         if (dev->sysfs_created)
2682                 sysfs_remove_group(&dev->acpi_dev->dev.kobj,
2683                                    &toshiba_attr_group);
2684 
2685         if (dev->ntfy_supported) {
2686                 i8042_remove_filter(toshiba_acpi_i8042_filter);
2687                 cancel_work_sync(&dev->hotkey_work);
2688         }
2689 
2690         if (dev->hotkey_dev) {
2691                 input_unregister_device(dev->hotkey_dev);
2692                 sparse_keymap_free(dev->hotkey_dev);
2693         }
2694 
2695         if (dev->bt_rfk) {
2696                 rfkill_unregister(dev->bt_rfk);
2697                 rfkill_destroy(dev->bt_rfk);
2698         }
2699 
2700         backlight_device_unregister(dev->backlight_dev);
2701 
2702         if (dev->illumination_supported)
2703                 led_classdev_unregister(&dev->led_dev);
2704 
2705         if (dev->kbd_led_registered)
2706                 led_classdev_unregister(&dev->kbd_led);
2707 
2708         if (dev->eco_supported)
2709                 led_classdev_unregister(&dev->eco_led);
2710 
2711         if (toshiba_acpi)
2712                 toshiba_acpi = NULL;
2713 
2714         kfree(dev);
2715 
2716         return 0;
2717 }
2718 
2719 static const char *find_hci_method(acpi_handle handle)
2720 {
2721         if (acpi_has_method(handle, "GHCI"))
2722                 return "GHCI";
2723 
2724         if (acpi_has_method(handle, "SPFC"))
2725                 return "SPFC";
2726 
2727         return NULL;
2728 }
2729 
2730 static int toshiba_acpi_add(struct acpi_device *acpi_dev)
2731 {
2732         struct toshiba_acpi_dev *dev;
2733         const char *hci_method;
2734         u32 special_functions;
2735         u32 dummy;
2736         bool bt_present;
2737         int ret = 0;
2738 
2739         if (toshiba_acpi)
2740                 return -EBUSY;
2741 
2742         pr_info("Toshiba Laptop ACPI Extras version %s\n",
2743                TOSHIBA_ACPI_VERSION);
2744 
2745         hci_method = find_hci_method(acpi_dev->handle);
2746         if (!hci_method) {
2747                 pr_err("HCI interface not found\n");
2748                 return -ENODEV;
2749         }
2750 
2751         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2752         if (!dev)
2753                 return -ENOMEM;
2754         dev->acpi_dev = acpi_dev;
2755         dev->method_hci = hci_method;
2756         acpi_dev->driver_data = dev;
2757         dev_set_drvdata(&acpi_dev->dev, dev);
2758 
2759         /* Query the BIOS for supported features */
2760 
2761         /*
2762          * The "Special Functions" are always supported by the laptops
2763          * with the new keyboard layout, query for its presence to help
2764          * determine the keymap layout to use.
2765          */
2766         ret = toshiba_function_keys_get(dev, &special_functions);
2767         dev->kbd_function_keys_supported = !ret;
2768 
2769         if (toshiba_acpi_setup_keyboard(dev))
2770                 pr_info("Unable to activate hotkeys\n");
2771 
2772         mutex_init(&dev->mutex);
2773 
2774         ret = toshiba_acpi_setup_backlight(dev);
2775         if (ret)
2776                 goto error;
2777 
2778         /* Register rfkill switch for Bluetooth */
2779         if (hci_get_bt_present(dev, &bt_present) == TOS_SUCCESS && bt_present) {
2780                 dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth",
2781                                            &acpi_dev->dev,
2782                                            RFKILL_TYPE_BLUETOOTH,
2783                                            &toshiba_rfk_ops,
2784                                            dev);
2785                 if (!dev->bt_rfk) {
2786                         pr_err("unable to allocate rfkill device\n");
2787                         ret = -ENOMEM;
2788                         goto error;
2789                 }
2790 
2791                 ret = rfkill_register(dev->bt_rfk);
2792                 if (ret) {
2793                         pr_err("unable to register rfkill device\n");
2794                         rfkill_destroy(dev->bt_rfk);
2795                         goto error;
2796                 }
2797         }
2798 
2799         if (toshiba_illumination_available(dev)) {
2800                 dev->led_dev.name = "toshiba::illumination";
2801                 dev->led_dev.max_brightness = 1;
2802                 dev->led_dev.brightness_set = toshiba_illumination_set;
2803                 dev->led_dev.brightness_get = toshiba_illumination_get;
2804                 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
2805                         dev->illumination_supported = 1;
2806         }
2807 
2808         if (toshiba_eco_mode_available(dev)) {
2809                 dev->eco_led.name = "toshiba::eco_mode";
2810                 dev->eco_led.max_brightness = 1;
2811                 dev->eco_led.brightness_set = toshiba_eco_mode_set_status;
2812                 dev->eco_led.brightness_get = toshiba_eco_mode_get_status;
2813                 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led))
2814                         dev->eco_supported = 1;
2815         }
2816 
2817         dev->kbd_illum_supported = toshiba_kbd_illum_available(dev);
2818         /*
2819          * Only register the LED if KBD illumination is supported
2820          * and the keyboard backlight operation mode is set to FN-Z
2821          */
2822         if (dev->kbd_illum_supported && dev->kbd_mode == SCI_KBD_MODE_FNZ) {
2823                 dev->kbd_led.name = "toshiba::kbd_backlight";
2824                 dev->kbd_led.max_brightness = 1;
2825                 dev->kbd_led.brightness_set = toshiba_kbd_backlight_set;
2826                 dev->kbd_led.brightness_get = toshiba_kbd_backlight_get;
2827                 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led))
2828                         dev->kbd_led_registered = 1;
2829         }
2830 
2831         ret = toshiba_touchpad_get(dev, &dummy);
2832         dev->touchpad_supported = !ret;
2833 
2834         ret = toshiba_accelerometer_supported(dev);
2835         dev->accelerometer_supported = !ret;
2836 
2837         toshiba_usb_sleep_charge_available(dev);
2838 
2839         ret = toshiba_usb_rapid_charge_get(dev, &dummy);
2840         dev->usb_rapid_charge_supported = !ret;
2841 
2842         ret = toshiba_usb_sleep_music_get(dev, &dummy);
2843         dev->usb_sleep_music_supported = !ret;
2844 
2845         ret = toshiba_panel_power_on_get(dev, &dummy);
2846         dev->panel_power_on_supported = !ret;
2847 
2848         ret = toshiba_usb_three_get(dev, &dummy);
2849         dev->usb_three_supported = !ret;
2850 
2851         ret = get_video_status(dev, &dummy);
2852         dev->video_supported = !ret;
2853 
2854         ret = get_fan_status(dev, &dummy);
2855         dev->fan_supported = !ret;
2856 
2857         /*
2858          * Enable the "Special Functions" mode only if they are
2859          * supported and if they are activated.
2860          */
2861         if (dev->kbd_function_keys_supported && special_functions)
2862                 toshiba_acpi_enable_special_functions(dev);
2863 
2864         ret = sysfs_create_group(&dev->acpi_dev->dev.kobj,
2865                                  &toshiba_attr_group);
2866         if (ret) {
2867                 dev->sysfs_created = 0;
2868                 goto error;
2869         }
2870         dev->sysfs_created = !ret;
2871 
2872         create_toshiba_proc_entries(dev);
2873 
2874         toshiba_acpi = dev;
2875 
2876         return 0;
2877 
2878 error:
2879         toshiba_acpi_remove(acpi_dev);
2880         return ret;
2881 }
2882 
2883 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
2884 {
2885         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
2886         int ret;
2887 
2888         switch (event) {
2889         case 0x80: /* Hotkeys and some system events */
2890                 toshiba_acpi_process_hotkeys(dev);
2891                 break;
2892         case 0x81: /* Dock events */
2893         case 0x82:
2894         case 0x83:
2895                 pr_info("Dock event received %x\n", event);
2896                 break;
2897         case 0x88: /* Thermal events */
2898                 pr_info("Thermal event received\n");
2899                 break;
2900         case 0x8f: /* LID closed */
2901         case 0x90: /* LID is closed and Dock has been ejected */
2902                 break;
2903         case 0x8c: /* SATA power events */
2904         case 0x8b:
2905                 pr_info("SATA power event received %x\n", event);
2906                 break;
2907         case 0x92: /* Keyboard backlight mode changed */
2908                 /* Update sysfs entries */
2909                 ret = sysfs_update_group(&acpi_dev->dev.kobj,
2910                                          &toshiba_attr_group);
2911                 if (ret)
2912                         pr_err("Unable to update sysfs entries\n");
2913                 break;
2914         case 0x85: /* Unknown */
2915         case 0x8d: /* Unknown */
2916         case 0x8e: /* Unknown */
2917         case 0x94: /* Unknown */
2918         case 0x95: /* Unknown */
2919         default:
2920                 pr_info("Unknown event received %x\n", event);
2921                 break;
2922         }
2923 
2924         acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class,
2925                                         dev_name(&acpi_dev->dev),
2926                                         event, 0);
2927 }
2928 
2929 #ifdef CONFIG_PM_SLEEP
2930 static int toshiba_acpi_suspend(struct device *device)
2931 {
2932         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
2933         u32 result;
2934 
2935         if (dev->hotkey_dev)
2936                 result = hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE);
2937 
2938         return 0;
2939 }
2940 
2941 static int toshiba_acpi_resume(struct device *device)
2942 {
2943         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
2944         int error;
2945 
2946         if (dev->hotkey_dev) {
2947                 error = toshiba_acpi_enable_hotkeys(dev);
2948                 if (error)
2949                         pr_info("Unable to re-enable hotkeys\n");
2950         }
2951 
2952         return 0;
2953 }
2954 #endif
2955 
2956 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
2957                          toshiba_acpi_suspend, toshiba_acpi_resume);
2958 
2959 static struct acpi_driver toshiba_acpi_driver = {
2960         .name   = "Toshiba ACPI driver",
2961         .owner  = THIS_MODULE,
2962         .ids    = toshiba_device_ids,
2963         .flags  = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
2964         .ops    = {
2965                 .add            = toshiba_acpi_add,
2966                 .remove         = toshiba_acpi_remove,
2967                 .notify         = toshiba_acpi_notify,
2968         },
2969         .drv.pm = &toshiba_acpi_pm,
2970 };
2971 
2972 static int __init toshiba_acpi_init(void)
2973 {
2974         int ret;
2975 
2976         /*
2977          * Machines with this WMI guid aren't supported due to bugs in
2978          * their AML. This check relies on wmi initializing before
2979          * toshiba_acpi to guarantee guids have been identified.
2980          */
2981         if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
2982                 return -ENODEV;
2983 
2984         toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
2985         if (!toshiba_proc_dir) {
2986                 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
2987                 return -ENODEV;
2988         }
2989 
2990         ret = acpi_bus_register_driver(&toshiba_acpi_driver);
2991         if (ret) {
2992                 pr_err("Failed to register ACPI driver: %d\n", ret);
2993                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
2994         }
2995 
2996         return ret;
2997 }
2998 
2999 static void __exit toshiba_acpi_exit(void)
3000 {
3001         acpi_bus_unregister_driver(&toshiba_acpi_driver);
3002         if (toshiba_proc_dir)
3003                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
3004 }
3005 
3006 module_init(toshiba_acpi_init);
3007 module_exit(toshiba_acpi_exit);
3008 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us