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