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