drivers/platform/x86/toshiba_acpi.c

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