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