Version:  2.0.40 2.2.26 2.4.37 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 4.2 4.3 4.4

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

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