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