kernel/drivers/platform/x86/toshiba_acpi.c

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