drivers/platform/x86/toshiba_acpi.c

   1 /*
   2  *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
   3  *
   4  *
   5  *  Copyright (C) 2002-2004 John Belmonte
   6  *  Copyright (C) 2008 Philip Langdale
   7  *  Copyright (C) 2010 Pierre Ducroquet
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  *
  24  *  The devolpment page for this driver is located at
  25  *  http://memebeam.org/toys/ToshibaAcpiDriver.
  26  *
  27  *  Credits:
  28  *      Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
  29  *              engineering the Windows drivers
  30  *      Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
  31  *      Rob Miller - TV out and hotkeys help
  32  *
  33  *
  34  *  TODO
  35  *
  36  */
  37
  38 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  39
  40 #define TOSHIBA_ACPI_VERSION    "0.19"
  41 #define PROC_INTERFACE_VERSION  1
  42
  43 #include <linux/kernel.h>
  44 #include <linux/module.h>
  45 #include <linux/init.h>
  46 #include <linux/types.h>
  47 #include <linux/proc_fs.h>
  48 #include <linux/seq_file.h>
  49 #include <linux/backlight.h>
  50 #include <linux/rfkill.h>
  51 #include <linux/input.h>
  52 #include <linux/input/sparse-keymap.h>
  53 #include <linux/leds.h>
  54 #include <linux/slab.h>
  55 #include <linux/workqueue.h>
  56 #include <linux/i8042.h>
  57 #include <linux/acpi.h>
  58 #include <asm/uaccess.h>
  59
  60 MODULE_AUTHOR("John Belmonte");
  61 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
  62 MODULE_LICENSE("GPL");
  63
  64 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
  65
  66 /* Scan code for Fn key on TOS1900 models */
  67 #define TOS1900_FN_SCAN         0x6e
  68
  69 /* Toshiba ACPI method paths */
  70 #define METHOD_VIDEO_OUT        "\\_SB_.VALX.DSSX"
  71
  72 /* Toshiba HCI interface definitions
  73  *
  74  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
  75  * be uniform across all their models.  Ideally we would just call
  76  * dedicated ACPI methods instead of using this primitive interface.
  77  * However the ACPI methods seem to be incomplete in some areas (for
  78  * example they allow setting, but not reading, the LCD brightness value),
  79  * so this is still useful.
  80  *
  81  * SCI stands for "System Configuration Interface" which aim is to
  82  * conceal differences in hardware between different models.
  83  */
  84
  85 #define HCI_WORDS                       6
  86
  87 /* operations */
  88 #define HCI_SET                         0xff00
  89 #define HCI_GET                         0xfe00
  90 #define SCI_OPEN                        0xf100
  91 #define SCI_CLOSE                       0xf200
  92 #define SCI_GET                         0xf300
  93 #define SCI_SET                         0xf400
  94
  95 /* return codes */
  96 #define HCI_SUCCESS                     0x0000
  97 #define HCI_FAILURE                     0x1000
  98 #define HCI_NOT_SUPPORTED               0x8000
  99 #define HCI_EMPTY                       0x8c00
 100 #define SCI_OPEN_CLOSE_OK               0x0044
 101 #define SCI_ALREADY_OPEN                0x8100
 102 #define SCI_NOT_OPENED                  0x8200
 103 #define SCI_INPUT_DATA_ERROR            0x8300
 104 #define SCI_NOT_PRESENT                 0x8600
 105
 106 /* registers */
 107 #define HCI_FAN                         0x0004
 108 #define HCI_TR_BACKLIGHT                0x0005
 109 #define HCI_SYSTEM_EVENT                0x0016
 110 #define HCI_VIDEO_OUT                   0x001c
 111 #define HCI_HOTKEY_EVENT                0x001e
 112 #define HCI_LCD_BRIGHTNESS              0x002a
 113 #define HCI_WIRELESS                    0x0056
 114 #define HCI_KBD_ILLUMINATION            0x0095
 115 #define HCI_ECO_MODE                    0x0097
 116 #define SCI_ILLUMINATION                0x014e
 117 #define SCI_KBD_ILLUM_STATUS            0x015c
 118 #define SCI_TOUCHPAD                    0x050e
 119
 120 /* field definitions */
 121 #define HCI_HOTKEY_DISABLE              0x0b
 122 #define HCI_HOTKEY_ENABLE               0x09
 123 #define HCI_LCD_BRIGHTNESS_BITS         3
 124 #define HCI_LCD_BRIGHTNESS_SHIFT        (16-HCI_LCD_BRIGHTNESS_BITS)
 125 #define HCI_LCD_BRIGHTNESS_LEVELS       (1 << HCI_LCD_BRIGHTNESS_BITS)
 126 #define HCI_MISC_SHIFT                  0x10
 127 #define HCI_VIDEO_OUT_LCD               0x1
 128 #define HCI_VIDEO_OUT_CRT               0x2
 129 #define HCI_VIDEO_OUT_TV                0x4
 130 #define HCI_WIRELESS_KILL_SWITCH        0x01
 131 #define HCI_WIRELESS_BT_PRESENT         0x0f
 132 #define HCI_WIRELESS_BT_ATTACH          0x40
 133 #define HCI_WIRELESS_BT_POWER           0x80
 134 #define SCI_KBD_MODE_FNZ                0x1
 135 #define SCI_KBD_MODE_AUTO               0x2
 136
 137 struct toshiba_acpi_dev {
 138         struct acpi_device *acpi_dev;
 139         const char *method_hci;
 140         struct rfkill *bt_rfk;
 141         struct input_dev *hotkey_dev;
 142         struct work_struct hotkey_work;
 143         struct backlight_device *backlight_dev;
 144         struct led_classdev led_dev;
 145         struct led_classdev kbd_led;
 146         struct led_classdev eco_led;
 147
 148         int force_fan;
 149         int last_key_event;
 150         int key_event_valid;
 151         int kbd_mode;
 152         int kbd_time;
 153
 154         unsigned int illumination_supported:1;
 155         unsigned int video_supported:1;
 156         unsigned int fan_supported:1;
 157         unsigned int system_event_supported:1;
 158         unsigned int ntfy_supported:1;
 159         unsigned int info_supported:1;
 160         unsigned int tr_backlight_supported:1;
 161         unsigned int kbd_illum_supported:1;
 162         unsigned int kbd_led_registered:1;
 163         unsigned int touchpad_supported:1;
 164         unsigned int eco_supported:1;
 165         unsigned int sysfs_created:1;
 166
 167         struct mutex mutex;
 168 };
 169
 170 static struct toshiba_acpi_dev *toshiba_acpi;
 171
 172 static const struct acpi_device_id toshiba_device_ids[] = {
 173         {"TOS6200", 0},
 174         {"TOS6208", 0},
 175         {"TOS1900", 0},
 176         {"", 0},
 177 };
 178 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
 179
 180 static const struct key_entry toshiba_acpi_keymap[] = {
 181         { KE_KEY, 0x9e, { KEY_RFKILL } },
 182         { KE_KEY, 0x101, { KEY_MUTE } },
 183         { KE_KEY, 0x102, { KEY_ZOOMOUT } },
 184         { KE_KEY, 0x103, { KEY_ZOOMIN } },
 185         { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
 186         { KE_KEY, 0x139, { KEY_ZOOMRESET } },
 187         { KE_KEY, 0x13b, { KEY_COFFEE } },
 188         { KE_KEY, 0x13c, { KEY_BATTERY } },
 189         { KE_KEY, 0x13d, { KEY_SLEEP } },
 190         { KE_KEY, 0x13e, { KEY_SUSPEND } },
 191         { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
 192         { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
 193         { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
 194         { KE_KEY, 0x142, { KEY_WLAN } },
 195         { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } },
 196         { KE_KEY, 0x17f, { KEY_FN } },
 197         { KE_KEY, 0xb05, { KEY_PROG2 } },
 198         { KE_KEY, 0xb06, { KEY_WWW } },
 199         { KE_KEY, 0xb07, { KEY_MAIL } },
 200         { KE_KEY, 0xb30, { KEY_STOP } },
 201         { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
 202         { KE_KEY, 0xb32, { KEY_NEXTSONG } },
 203         { KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
 204         { KE_KEY, 0xb5a, { KEY_MEDIA } },
 205         { KE_IGNORE, 0x1430, { KEY_RESERVED } },
 206         { KE_END, 0 },
 207 };
 208
 209 /* utility
 210  */
 211
 212 static __inline__ void _set_bit(u32 * word, u32 mask, int value)
 213 {
 214         *word = (*word & ~mask) | (mask * value);
 215 }
 216
 217 /* acpi interface wrappers
 218  */
 219
 220 static int write_acpi_int(const char *methodName, int val)
 221 {
 222         acpi_status status;
 223
 224         status = acpi_execute_simple_method(NULL, (char *)methodName, val);
 225         return (status == AE_OK) ? 0 : -EIO;
 226 }
 227
 228 /* Perform a raw HCI call.  Here we don't care about input or output buffer
 229  * format.
 230  */
 231 static acpi_status hci_raw(struct toshiba_acpi_dev *dev,
 232                            const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
 233 {
 234         struct acpi_object_list params;
 235         union acpi_object in_objs[HCI_WORDS];
 236         struct acpi_buffer results;
 237         union acpi_object out_objs[HCI_WORDS + 1];
 238         acpi_status status;
 239         int i;
 240
 241         params.count = HCI_WORDS;
 242         params.pointer = in_objs;
 243         for (i = 0; i < HCI_WORDS; ++i) {
 244                 in_objs[i].type = ACPI_TYPE_INTEGER;
 245                 in_objs[i].integer.value = in[i];
 246         }
 247
 248         results.length = sizeof(out_objs);
 249         results.pointer = out_objs;
 250
 251         status = acpi_evaluate_object(dev->acpi_dev->handle,
 252                                       (char *)dev->method_hci, &params,
 253                                       &results);
 254         if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
 255                 for (i = 0; i < out_objs->package.count; ++i) {
 256                         out[i] = out_objs->package.elements[i].integer.value;
 257                 }
 258         }
 259
 260         return status;
 261 }
 262
 263 /* common hci tasks (get or set one or two value)
 264  *
 265  * In addition to the ACPI status, the HCI system returns a result which
 266  * may be useful (such as "not supported").
 267  */
 268
 269 static acpi_status hci_write1(struct toshiba_acpi_dev *dev, u32 reg,
 270                               u32 in1, u32 *result)
 271 {
 272         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
 273         u32 out[HCI_WORDS];
 274         acpi_status status = hci_raw(dev, in, out);
 275         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 276         return status;
 277 }
 278
 279 static acpi_status hci_read1(struct toshiba_acpi_dev *dev, u32 reg,
 280                              u32 *out1, u32 *result)
 281 {
 282         u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
 283         u32 out[HCI_WORDS];
 284         acpi_status status = hci_raw(dev, in, out);
 285         *out1 = out[2];
 286         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 287         return status;
 288 }
 289
 290 static acpi_status hci_write2(struct toshiba_acpi_dev *dev, u32 reg,
 291                               u32 in1, u32 in2, u32 *result)
 292 {
 293         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
 294         u32 out[HCI_WORDS];
 295         acpi_status status = hci_raw(dev, in, out);
 296         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 297         return status;
 298 }
 299
 300 static acpi_status hci_read2(struct toshiba_acpi_dev *dev, u32 reg,
 301                              u32 *out1, u32 *out2, u32 *result)
 302 {
 303         u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
 304         u32 out[HCI_WORDS];
 305         acpi_status status = hci_raw(dev, in, out);
 306         *out1 = out[2];
 307         *out2 = out[3];
 308         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 309         return status;
 310 }
 311
 312 /* common sci tasks
 313  */
 314
 315 static int sci_open(struct toshiba_acpi_dev *dev)
 316 {
 317         u32 in[HCI_WORDS] = { SCI_OPEN, 0, 0, 0, 0, 0 };
 318         u32 out[HCI_WORDS];
 319         acpi_status status;
 320
 321         status = hci_raw(dev, in, out);
 322         if  (ACPI_FAILURE(status) || out[0] == HCI_FAILURE) {
 323                 pr_err("ACPI call to open SCI failed\n");
 324                 return 0;
 325         }
 326
 327         if (out[0] == SCI_OPEN_CLOSE_OK) {
 328                 return 1;
 329         } else if (out[0] == SCI_ALREADY_OPEN) {
 330                 pr_info("Toshiba SCI already opened\n");
 331                 return 1;
 332         } else if (out[0] == SCI_NOT_PRESENT) {
 333                 pr_info("Toshiba SCI is not present\n");
 334         }
 335
 336         return 0;
 337 }
 338
 339 static void sci_close(struct toshiba_acpi_dev *dev)
 340 {
 341         u32 in[HCI_WORDS] = { SCI_CLOSE, 0, 0, 0, 0, 0 };
 342         u32 out[HCI_WORDS];
 343         acpi_status status;
 344
 345         status = hci_raw(dev, in, out);
 346         if (ACPI_FAILURE(status) || out[0] == HCI_FAILURE) {
 347                 pr_err("ACPI call to close SCI failed\n");
 348                 return;
 349         }
 350
 351         if (out[0] == SCI_OPEN_CLOSE_OK)
 352                 return;
 353         else if (out[0] == SCI_NOT_OPENED)
 354                 pr_info("Toshiba SCI not opened\n");
 355         else if (out[0] == SCI_NOT_PRESENT)
 356                 pr_info("Toshiba SCI is not present\n");
 357 }
 358
 359 static acpi_status sci_read(struct toshiba_acpi_dev *dev, u32 reg,
 360                             u32 *out1, u32 *result)
 361 {
 362         u32 in[HCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 };
 363         u32 out[HCI_WORDS];
 364         acpi_status status = hci_raw(dev, in, out);
 365         *out1 = out[2];
 366         *result = (ACPI_SUCCESS(status)) ? out[0] : HCI_FAILURE;
 367         return status;
 368 }
 369
 370 static acpi_status sci_write(struct toshiba_acpi_dev *dev, u32 reg,
 371                              u32 in1, u32 *result)
 372 {
 373         u32 in[HCI_WORDS] = { SCI_SET, reg, in1, 0, 0, 0 };
 374         u32 out[HCI_WORDS];
 375         acpi_status status = hci_raw(dev, in, out);
 376         *result = (ACPI_SUCCESS(status)) ? out[0] : HCI_FAILURE;
 377         return status;
 378 }
 379
 380 /* Illumination support */
 381 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev)
 382 {
 383         u32 in[HCI_WORDS] = { SCI_GET, SCI_ILLUMINATION, 0, 0, 0, 0 };
 384         u32 out[HCI_WORDS];
 385         acpi_status status;
 386
 387         if (!sci_open(dev))
 388                 return 0;
 389
 390         status = hci_raw(dev, in, out);
 391         sci_close(dev);
 392         if (ACPI_FAILURE(status) || out[0] == HCI_FAILURE) {
 393                 pr_err("ACPI call to query Illumination support failed\n");
 394                 return 0;
 395         } else if (out[0] == HCI_NOT_SUPPORTED || out[1] != 1) {
 396                 pr_info("Illumination device not available\n");
 397                 return 0;
 398         }
 399
 400         return 1;
 401 }
 402
 403 static void toshiba_illumination_set(struct led_classdev *cdev,
 404                                      enum led_brightness brightness)
 405 {
 406         struct toshiba_acpi_dev *dev = container_of(cdev,
 407                         struct toshiba_acpi_dev, led_dev);
 408         u32 state, result;
 409         acpi_status status;
 410
 411         /* First request : initialize communication. */
 412         if (!sci_open(dev))
 413                 return;
 414
 415         /* Switch the illumination on/off */
 416         state = brightness ? 1 : 0;
 417         status = sci_write(dev, SCI_ILLUMINATION, state, &result);
 418         sci_close(dev);
 419         if (ACPI_FAILURE(status)) {
 420                 pr_err("ACPI call for illumination failed\n");
 421                 return;
 422         } else if (result == HCI_NOT_SUPPORTED) {
 423                 pr_info("Illumination not supported\n");
 424                 return;
 425         }
 426 }
 427
 428 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
 429 {
 430         struct toshiba_acpi_dev *dev = container_of(cdev,
 431                         struct toshiba_acpi_dev, led_dev);
 432         u32 state, result;
 433         acpi_status status;
 434
 435         /* First request : initialize communication. */
 436         if (!sci_open(dev))
 437                 return LED_OFF;
 438
 439         /* Check the illumination */
 440         status = sci_read(dev, SCI_ILLUMINATION, &state, &result);
 441         sci_close(dev);
 442         if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) {
 443                 pr_err("ACPI call for illumination failed\n");
 444                 return LED_OFF;
 445         } else if (result == HCI_NOT_SUPPORTED) {
 446                 pr_info("Illumination not supported\n");
 447                 return LED_OFF;
 448         }
 449
 450         return state ? LED_FULL : LED_OFF;
 451 }
 452
 453 /* KBD Illumination */
 454 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time)
 455 {
 456         u32 result;
 457         acpi_status status;
 458
 459         if (!sci_open(dev))
 460                 return -EIO;
 461
 462         status = sci_write(dev, SCI_KBD_ILLUM_STATUS, time, &result);
 463         sci_close(dev);
 464         if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) {
 465                 pr_err("ACPI call to set KBD backlight status failed\n");
 466                 return -EIO;
 467         } else if (result == HCI_NOT_SUPPORTED) {
 468                 pr_info("Keyboard backlight status not supported\n");
 469                 return -ENODEV;
 470         }
 471
 472         return 0;
 473 }
 474
 475 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time)
 476 {
 477         u32 result;
 478         acpi_status status;
 479
 480         if (!sci_open(dev))
 481                 return -EIO;
 482
 483         status = sci_read(dev, SCI_KBD_ILLUM_STATUS, time, &result);
 484         sci_close(dev);
 485         if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) {
 486                 pr_err("ACPI call to get KBD backlight status failed\n");
 487                 return -EIO;
 488         } else if (result == HCI_NOT_SUPPORTED) {
 489                 pr_info("Keyboard backlight status not supported\n");
 490                 return -ENODEV;
 491         }
 492
 493         return 0;
 494 }
 495
 496 static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev)
 497 {
 498         struct toshiba_acpi_dev *dev = container_of(cdev,
 499                         struct toshiba_acpi_dev, kbd_led);
 500         u32 state, result;
 501         acpi_status status;
 502
 503         /* Check the keyboard backlight state */
 504         status = hci_read1(dev, HCI_KBD_ILLUMINATION, &state, &result);
 505         if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) {
 506                 pr_err("ACPI call to get the keyboard backlight failed\n");
 507                 return LED_OFF;
 508         } else if (result == HCI_NOT_SUPPORTED) {
 509                 pr_info("Keyboard backlight not supported\n");
 510                 return LED_OFF;
 511         }
 512
 513         return state ? LED_FULL : LED_OFF;
 514 }
 515
 516 static void toshiba_kbd_backlight_set(struct led_classdev *cdev,
 517                                      enum led_brightness brightness)
 518 {
 519         struct toshiba_acpi_dev *dev = container_of(cdev,
 520                         struct toshiba_acpi_dev, kbd_led);
 521         u32 state, result;
 522         acpi_status status;
 523
 524         /* Set the keyboard backlight state */
 525         state = brightness ? 1 : 0;
 526         status = hci_write1(dev, HCI_KBD_ILLUMINATION, state, &result);
 527         if (ACPI_FAILURE(status) || result == SCI_INPUT_DATA_ERROR) {
 528                 pr_err("ACPI call to set KBD Illumination mode failed\n");
 529                 return;
 530         } else if (result == HCI_NOT_SUPPORTED) {
 531                 pr_info("Keyboard backlight not supported\n");
 532                 return;
 533         }
 534 }
 535
 536 /* TouchPad support */
 537 static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state)
 538 {
 539         u32 result;
 540         acpi_status status;
 541
 542         if (!sci_open(dev))
 543                 return -EIO;
 544
 545         status = sci_write(dev, SCI_TOUCHPAD, state, &result);
 546         sci_close(dev);
 547         if (ACPI_FAILURE(status)) {
 548                 pr_err("ACPI call to set the touchpad failed\n");
 549                 return -EIO;
 550         } else if (result == HCI_NOT_SUPPORTED) {
 551                 return -ENODEV;
 552         }
 553
 554         return 0;
 555 }
 556
 557 static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state)
 558 {
 559         u32 result;
 560         acpi_status status;
 561
 562         if (!sci_open(dev))
 563                 return -EIO;
 564
 565         status = sci_read(dev, SCI_TOUCHPAD, state, &result);
 566         sci_close(dev);
 567         if (ACPI_FAILURE(status)) {
 568                 pr_err("ACPI call to query the touchpad failed\n");
 569                 return -EIO;
 570         } else if (result == HCI_NOT_SUPPORTED) {
 571                 return -ENODEV;
 572         }
 573
 574         return 0;
 575 }
 576
 577 /* Eco Mode support */
 578 static int toshiba_eco_mode_available(struct toshiba_acpi_dev *dev)
 579 {
 580         acpi_status status;
 581         u32 in[HCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 };
 582         u32 out[HCI_WORDS];
 583
 584         status = hci_raw(dev, in, out);
 585         if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) {
 586                 pr_info("ACPI call to get ECO led failed\n");
 587                 return 0;
 588         }
 589
 590         return 1;
 591 }
 592
 593 static enum led_brightness toshiba_eco_mode_get_status(struct led_classdev *cdev)
 594 {
 595         struct toshiba_acpi_dev *dev = container_of(cdev,
 596                         struct toshiba_acpi_dev, eco_led);
 597         u32 in[HCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 };
 598         u32 out[HCI_WORDS];
 599         acpi_status status;
 600
 601         status = hci_raw(dev, in, out);
 602         if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) {
 603                 pr_err("ACPI call to get ECO led failed\n");
 604                 return LED_OFF;
 605         }
 606
 607         return out[2] ? LED_FULL : LED_OFF;
 608 }
 609
 610 static void toshiba_eco_mode_set_status(struct led_classdev *cdev,
 611                                      enum led_brightness brightness)
 612 {
 613         struct toshiba_acpi_dev *dev = container_of(cdev,
 614                         struct toshiba_acpi_dev, eco_led);
 615         u32 in[HCI_WORDS] = { HCI_SET, HCI_ECO_MODE, 0, 1, 0, 0 };
 616         u32 out[HCI_WORDS];
 617         acpi_status status;
 618
 619         /* Switch the Eco Mode led on/off */
 620         in[2] = (brightness) ? 1 : 0;
 621         status = hci_raw(dev, in, out);
 622         if (ACPI_FAILURE(status) || out[0] == SCI_INPUT_DATA_ERROR) {
 623                 pr_err("ACPI call to set ECO led failed\n");
 624                 return;
 625         }
 626 }
 627
 628 /* Bluetooth rfkill handlers */
 629
 630 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
 631 {
 632         u32 hci_result;
 633         u32 value, value2;
 634
 635         value = 0;
 636         value2 = 0;
 637         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
 638         if (hci_result == HCI_SUCCESS)
 639                 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;
 640
 641         return hci_result;
 642 }
 643
 644 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state)
 645 {
 646         u32 hci_result;
 647         u32 value, value2;
 648
 649         value = 0;
 650         value2 = 0x0001;
 651         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
 652
 653         *radio_state = value & HCI_WIRELESS_KILL_SWITCH;
 654         return hci_result;
 655 }
 656
 657 static int bt_rfkill_set_block(void *data, bool blocked)
 658 {
 659         struct toshiba_acpi_dev *dev = data;
 660         u32 result1, result2;
 661         u32 value;
 662         int err;
 663         bool radio_state;
 664
 665         value = (blocked == false);
 666
 667         mutex_lock(&dev->mutex);
 668         if (hci_get_radio_state(dev, &radio_state) != HCI_SUCCESS) {
 669                 err = -EIO;
 670                 goto out;
 671         }
 672
 673         if (!radio_state) {
 674                 err = 0;
 675                 goto out;
 676         }
 677
 678         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
 679         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);
 680
 681         if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
 682                 err = -EIO;
 683         else
 684                 err = 0;
 685  out:
 686         mutex_unlock(&dev->mutex);
 687         return err;
 688 }
 689
 690 static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
 691 {
 692         bool new_rfk_state;
 693         bool value;
 694         u32 hci_result;
 695         struct toshiba_acpi_dev *dev = data;
 696
 697         mutex_lock(&dev->mutex);
 698
 699         hci_result = hci_get_radio_state(dev, &value);
 700         if (hci_result != HCI_SUCCESS) {
 701                 /* Can't do anything useful */
 702                 mutex_unlock(&dev->mutex);
 703                 return;
 704         }
 705
 706         new_rfk_state = value;
 707
 708         mutex_unlock(&dev->mutex);
 709
 710         if (rfkill_set_hw_state(rfkill, !new_rfk_state))
 711                 bt_rfkill_set_block(data, true);
 712 }
 713
 714 static const struct rfkill_ops toshiba_rfk_ops = {
 715         .set_block = bt_rfkill_set_block,
 716         .poll = bt_rfkill_poll,
 717 };
 718
 719 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, bool *enabled)
 720 {
 721         u32 hci_result;
 722         u32 status;
 723
 724         hci_read1(dev, HCI_TR_BACKLIGHT, &status, &hci_result);
 725         *enabled = !status;
 726         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 727 }
 728
 729 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable)
 730 {
 731         u32 hci_result;
 732         u32 value = !enable;
 733
 734         hci_write1(dev, HCI_TR_BACKLIGHT, value, &hci_result);
 735         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 736 }
 737
 738 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
 739
 740 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
 741 {
 742         u32 hci_result;
 743         u32 value;
 744         int brightness = 0;
 745
 746         if (dev->tr_backlight_supported) {
 747                 bool enabled;
 748                 int ret = get_tr_backlight_status(dev, &enabled);
 749                 if (ret)
 750                         return ret;
 751                 if (enabled)
 752                         return 0;
 753                 brightness++;
 754         }
 755
 756         hci_read1(dev, HCI_LCD_BRIGHTNESS, &value, &hci_result);
 757         if (hci_result == HCI_SUCCESS)
 758                 return brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT);
 759
 760         return -EIO;
 761 }
 762
 763 static int get_lcd_brightness(struct backlight_device *bd)
 764 {
 765         struct toshiba_acpi_dev *dev = bl_get_data(bd);
 766         return __get_lcd_brightness(dev);
 767 }
 768
 769 static int lcd_proc_show(struct seq_file *m, void *v)
 770 {
 771         struct toshiba_acpi_dev *dev = m->private;
 772         int value;
 773         int levels;
 774
 775         if (!dev->backlight_dev)
 776                 return -ENODEV;
 777
 778         levels = dev->backlight_dev->props.max_brightness + 1;
 779         value = get_lcd_brightness(dev->backlight_dev);
 780         if (value >= 0) {
 781                 seq_printf(m, "brightness:              %d\n", value);
 782                 seq_printf(m, "brightness_levels:       %d\n", levels);
 783                 return 0;
 784         }
 785
 786         pr_err("Error reading LCD brightness\n");
 787         return -EIO;
 788 }
 789
 790 static int lcd_proc_open(struct inode *inode, struct file *file)
 791 {
 792         return single_open(file, lcd_proc_show, PDE_DATA(inode));
 793 }
 794
 795 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
 796 {
 797         u32 hci_result;
 798
 799         if (dev->tr_backlight_supported) {
 800                 bool enable = !value;
 801                 int ret = set_tr_backlight_status(dev, enable);
 802                 if (ret)
 803                         return ret;
 804                 if (value)
 805                         value--;
 806         }
 807
 808         value = value << HCI_LCD_BRIGHTNESS_SHIFT;
 809         hci_write1(dev, HCI_LCD_BRIGHTNESS, value, &hci_result);
 810         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 811 }
 812
 813 static int set_lcd_status(struct backlight_device *bd)
 814 {
 815         struct toshiba_acpi_dev *dev = bl_get_data(bd);
 816         return set_lcd_brightness(dev, bd->props.brightness);
 817 }
 818
 819 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
 820                               size_t count, loff_t *pos)
 821 {
 822         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
 823         char cmd[42];
 824         size_t len;
 825         int value;
 826         int ret;
 827         int levels = dev->backlight_dev->props.max_brightness + 1;
 828
 829         len = min(count, sizeof(cmd) - 1);
 830         if (copy_from_user(cmd, buf, len))
 831                 return -EFAULT;
 832         cmd[len] = '\0';
 833
 834         if (sscanf(cmd, " brightness : %i", &value) == 1 &&
 835             value >= 0 && value < levels) {
 836                 ret = set_lcd_brightness(dev, value);
 837                 if (ret == 0)
 838                         ret = count;
 839         } else {
 840                 ret = -EINVAL;
 841         }
 842         return ret;
 843 }
 844
 845 static const struct file_operations lcd_proc_fops = {
 846         .owner          = THIS_MODULE,
 847         .open           = lcd_proc_open,
 848         .read           = seq_read,
 849         .llseek         = seq_lseek,
 850         .release        = single_release,
 851         .write          = lcd_proc_write,
 852 };
 853
 854 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
 855 {
 856         u32 hci_result;
 857
 858         hci_read1(dev, HCI_VIDEO_OUT, status, &hci_result);
 859         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 860 }
 861
 862 static int video_proc_show(struct seq_file *m, void *v)
 863 {
 864         struct toshiba_acpi_dev *dev = m->private;
 865         u32 value;
 866         int ret;
 867
 868         ret = get_video_status(dev, &value);
 869         if (!ret) {
 870                 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
 871                 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
 872                 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
 873                 seq_printf(m, "lcd_out:                 %d\n", is_lcd);
 874                 seq_printf(m, "crt_out:                 %d\n", is_crt);
 875                 seq_printf(m, "tv_out:                  %d\n", is_tv);
 876         }
 877
 878         return ret;
 879 }
 880
 881 static int video_proc_open(struct inode *inode, struct file *file)
 882 {
 883         return single_open(file, video_proc_show, PDE_DATA(inode));
 884 }
 885
 886 static ssize_t video_proc_write(struct file *file, const char __user *buf,
 887                                 size_t count, loff_t *pos)
 888 {
 889         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
 890         char *cmd, *buffer;
 891         int ret;
 892         int value;
 893         int remain = count;
 894         int lcd_out = -1;
 895         int crt_out = -1;
 896         int tv_out = -1;
 897         u32 video_out;
 898
 899         cmd = kmalloc(count + 1, GFP_KERNEL);
 900         if (!cmd)
 901                 return -ENOMEM;
 902         if (copy_from_user(cmd, buf, count)) {
 903                 kfree(cmd);
 904                 return -EFAULT;
 905         }
 906         cmd[count] = '\0';
 907
 908         buffer = cmd;
 909
 910         /* scan expression.  Multiple expressions may be delimited with ;
 911          *
 912          *  NOTE: to keep scanning simple, invalid fields are ignored
 913          */
 914         while (remain) {
 915                 if (sscanf(buffer, " lcd_out : %i", &value) == 1)
 916                         lcd_out = value & 1;
 917                 else if (sscanf(buffer, " crt_out : %i", &value) == 1)
 918                         crt_out = value & 1;
 919                 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
 920                         tv_out = value & 1;
 921                 /* advance to one character past the next ; */
 922                 do {
 923                         ++buffer;
 924                         --remain;
 925                 }
 926                 while (remain && *(buffer - 1) != ';');
 927         }
 928
 929         kfree(cmd);
 930
 931         ret = get_video_status(dev, &video_out);
 932         if (!ret) {
 933                 unsigned int new_video_out = video_out;
 934                 if (lcd_out != -1)
 935                         _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
 936                 if (crt_out != -1)
 937                         _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
 938                 if (tv_out != -1)
 939                         _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
 940                 /* To avoid unnecessary video disruption, only write the new
 941                  * video setting if something changed. */
 942                 if (new_video_out != video_out)
 943                         ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
 944         }
 945
 946         return ret ? ret : count;
 947 }
 948
 949 static const struct file_operations video_proc_fops = {
 950         .owner          = THIS_MODULE,
 951         .open           = video_proc_open,
 952         .read           = seq_read,
 953         .llseek         = seq_lseek,
 954         .release        = single_release,
 955         .write          = video_proc_write,
 956 };
 957
 958 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
 959 {
 960         u32 hci_result;
 961
 962         hci_read1(dev, HCI_FAN, status, &hci_result);
 963         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 964 }
 965
 966 static int fan_proc_show(struct seq_file *m, void *v)
 967 {
 968         struct toshiba_acpi_dev *dev = m->private;
 969         int ret;
 970         u32 value;
 971
 972         ret = get_fan_status(dev, &value);
 973         if (!ret) {
 974                 seq_printf(m, "running:                 %d\n", (value > 0));
 975                 seq_printf(m, "force_on:                %d\n", dev->force_fan);
 976         }
 977
 978         return ret;
 979 }
 980
 981 static int fan_proc_open(struct inode *inode, struct file *file)
 982 {
 983         return single_open(file, fan_proc_show, PDE_DATA(inode));
 984 }
 985
 986 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
 987                               size_t count, loff_t *pos)
 988 {
 989         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
 990         char cmd[42];
 991         size_t len;
 992         int value;
 993         u32 hci_result;
 994
 995         len = min(count, sizeof(cmd) - 1);
 996         if (copy_from_user(cmd, buf, len))
 997                 return -EFAULT;
 998         cmd[len] = '\0';
 999
1000         if (sscanf(cmd, " force_on : %i", &value) == 1 &&
1001             value >= 0 && value <= 1) {
1002                 hci_write1(dev, HCI_FAN, value, &hci_result);
1003                 if (hci_result != HCI_SUCCESS)
1004                         return -EIO;
1005                 else
1006                         dev->force_fan = value;
1007         } else {
1008                 return -EINVAL;
1009         }
1010
1011         return count;
1012 }
1013
1014 static const struct file_operations fan_proc_fops = {
1015         .owner          = THIS_MODULE,
1016         .open           = fan_proc_open,
1017         .read           = seq_read,
1018         .llseek         = seq_lseek,
1019         .release        = single_release,
1020         .write          = fan_proc_write,
1021 };
1022
1023 static int keys_proc_show(struct seq_file *m, void *v)
1024 {
1025         struct toshiba_acpi_dev *dev = m->private;
1026         u32 hci_result;
1027         u32 value;
1028
1029         if (!dev->key_event_valid && dev->system_event_supported) {
1030                 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
1031                 if (hci_result == HCI_SUCCESS) {
1032                         dev->key_event_valid = 1;
1033                         dev->last_key_event = value;
1034                 } else if (hci_result == HCI_EMPTY) {
1035                         /* better luck next time */
1036                 } else if (hci_result == HCI_NOT_SUPPORTED) {
1037                         /* This is a workaround for an unresolved issue on
1038                          * some machines where system events sporadically
1039                          * become disabled. */
1040                         hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
1041                         pr_notice("Re-enabled hotkeys\n");
1042                 } else {
1043                         pr_err("Error reading hotkey status\n");
1044                         return -EIO;
1045                 }
1046         }
1047
1048         seq_printf(m, "hotkey_ready:            %d\n", dev->key_event_valid);
1049         seq_printf(m, "hotkey:                  0x%04x\n", dev->last_key_event);
1050         return 0;
1051 }
1052
1053 static int keys_proc_open(struct inode *inode, struct file *file)
1054 {
1055         return single_open(file, keys_proc_show, PDE_DATA(inode));
1056 }
1057
1058 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
1059                                size_t count, loff_t *pos)
1060 {
1061         struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
1062         char cmd[42];
1063         size_t len;
1064         int value;
1065
1066         len = min(count, sizeof(cmd) - 1);
1067         if (copy_from_user(cmd, buf, len))
1068                 return -EFAULT;
1069         cmd[len] = '\0';
1070
1071         if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
1072                 dev->key_event_valid = 0;
1073         } else {
1074                 return -EINVAL;
1075         }
1076
1077         return count;
1078 }
1079
1080 static const struct file_operations keys_proc_fops = {
1081         .owner          = THIS_MODULE,
1082         .open           = keys_proc_open,
1083         .read           = seq_read,
1084         .llseek         = seq_lseek,
1085         .release        = single_release,
1086         .write          = keys_proc_write,
1087 };
1088
1089 static int version_proc_show(struct seq_file *m, void *v)
1090 {
1091         seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
1092         seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
1093         return 0;
1094 }
1095
1096 static int version_proc_open(struct inode *inode, struct file *file)
1097 {
1098         return single_open(file, version_proc_show, PDE_DATA(inode));
1099 }
1100
1101 static const struct file_operations version_proc_fops = {
1102         .owner          = THIS_MODULE,
1103         .open           = version_proc_open,
1104         .read           = seq_read,
1105         .llseek         = seq_lseek,
1106         .release        = single_release,
1107 };
1108
1109 /* proc and module init
1110  */
1111
1112 #define PROC_TOSHIBA            "toshiba"
1113
1114 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
1115 {
1116         if (dev->backlight_dev)
1117                 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1118                                  &lcd_proc_fops, dev);
1119         if (dev->video_supported)
1120                 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1121                                  &video_proc_fops, dev);
1122         if (dev->fan_supported)
1123                 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1124                                  &fan_proc_fops, dev);
1125         if (dev->hotkey_dev)
1126                 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
1127                                  &keys_proc_fops, dev);
1128         proc_create_data("version", S_IRUGO, toshiba_proc_dir,
1129                          &version_proc_fops, dev);
1130 }
1131
1132 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
1133 {
1134         if (dev->backlight_dev)
1135                 remove_proc_entry("lcd", toshiba_proc_dir);
1136         if (dev->video_supported)
1137                 remove_proc_entry("video", toshiba_proc_dir);
1138         if (dev->fan_supported)
1139                 remove_proc_entry("fan", toshiba_proc_dir);
1140         if (dev->hotkey_dev)
1141                 remove_proc_entry("keys", toshiba_proc_dir);
1142         remove_proc_entry("version", toshiba_proc_dir);
1143 }
1144
1145 static const struct backlight_ops toshiba_backlight_data = {
1146         .options = BL_CORE_SUSPENDRESUME,
1147         .get_brightness = get_lcd_brightness,
1148         .update_status  = set_lcd_status,
1149 };
1150
1151 /*
1152  * Sysfs files
1153  */
1154
1155 static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
1156                                          struct device_attribute *attr,
1157                                          const char *buf, size_t count)
1158 {
1159         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1160         int mode = -1;
1161         int time = -1;
1162
1163         if (sscanf(buf, "%i", &mode) != 1 && (mode != 2 || mode != 1))
1164                 return -EINVAL;
1165
1166         /* Set the Keyboard Backlight Mode where:
1167          * Mode - Auto (2) | FN-Z (1)
1168          *      Auto - KBD backlight turns off automatically in given time
1169          *      FN-Z - KBD backlight "toggles" when hotkey pressed
1170          */
1171         if (mode != -1 && toshiba->kbd_mode != mode) {
1172                 time = toshiba->kbd_time << HCI_MISC_SHIFT;
1173                 time = time + toshiba->kbd_mode;
1174                 if (toshiba_kbd_illum_status_set(toshiba, time) < 0)
1175                         return -EIO;
1176                 toshiba->kbd_mode = mode;
1177         }
1178
1179         return count;
1180 }
1181
1182 static ssize_t toshiba_kbd_bl_mode_show(struct device *dev,
1183                                         struct device_attribute *attr,
1184                                         char *buf)
1185 {
1186         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1187         u32 time;
1188
1189         if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
1190                 return -EIO;
1191
1192         return sprintf(buf, "%i\n", time & 0x07);
1193 }
1194
1195 static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev,
1196                                             struct device_attribute *attr,
1197                                             const char *buf, size_t count)
1198 {
1199         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1200         int time = -1;
1201
1202         if (sscanf(buf, "%i", &time) != 1 && (time < 0 || time > 60))
1203                 return -EINVAL;
1204
1205         /* Set the Keyboard Backlight Timeout: 0-60 seconds */
1206         if (time != -1 && toshiba->kbd_time != time) {
1207                 time = time << HCI_MISC_SHIFT;
1208                 time = (toshiba->kbd_mode == SCI_KBD_MODE_AUTO) ?
1209                                                         time + 1 : time + 2;
1210                 if (toshiba_kbd_illum_status_set(toshiba, time) < 0)
1211                         return -EIO;
1212                 toshiba->kbd_time = time >> HCI_MISC_SHIFT;
1213         }
1214
1215         return count;
1216 }
1217
1218 static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev,
1219                                            struct device_attribute *attr,
1220                                            char *buf)
1221 {
1222         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1223         u32 time;
1224
1225         if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
1226                 return -EIO;
1227
1228         return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT);
1229 }
1230
1231 static ssize_t toshiba_touchpad_store(struct device *dev,
1232                                       struct device_attribute *attr,
1233                                       const char *buf, size_t count)
1234 {
1235         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1236         int state;
1237
1238         /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */
1239         if (sscanf(buf, "%i", &state) == 1 && (state == 0 || state == 1)) {
1240                 if (toshiba_touchpad_set(toshiba, state) < 0)
1241                         return -EIO;
1242         }
1243
1244         return count;
1245 }
1246
1247 static ssize_t toshiba_touchpad_show(struct device *dev,
1248                                      struct device_attribute *attr, char *buf)
1249 {
1250         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
1251         u32 state;
1252         int ret;
1253
1254         ret = toshiba_touchpad_get(toshiba, &state);
1255         if (ret < 0)
1256                 return ret;
1257
1258         return sprintf(buf, "%i\n", state);
1259 }
1260
1261 static DEVICE_ATTR(kbd_backlight_mode, S_IRUGO | S_IWUSR,
1262                    toshiba_kbd_bl_mode_show, toshiba_kbd_bl_mode_store);
1263 static DEVICE_ATTR(kbd_backlight_timeout, S_IRUGO | S_IWUSR,
1264                    toshiba_kbd_bl_timeout_show, toshiba_kbd_bl_timeout_store);
1265 static DEVICE_ATTR(touchpad, S_IRUGO | S_IWUSR,
1266                    toshiba_touchpad_show, toshiba_touchpad_store);
1267
1268 static struct attribute *toshiba_attributes[] = {
1269         &dev_attr_kbd_backlight_mode.attr,
1270         &dev_attr_kbd_backlight_timeout.attr,
1271         &dev_attr_touchpad.attr,
1272         NULL,
1273 };
1274
1275 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
1276                                         struct attribute *attr, int idx)
1277 {
1278         struct device *dev = container_of(kobj, struct device, kobj);
1279         struct toshiba_acpi_dev *drv = dev_get_drvdata(dev);
1280         bool exists = true;
1281
1282         if (attr == &dev_attr_kbd_backlight_mode.attr)
1283                 exists = (drv->kbd_illum_supported) ? true : false;
1284         else if (attr == &dev_attr_kbd_backlight_timeout.attr)
1285                 exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false;
1286         else if (attr == &dev_attr_touchpad.attr)
1287                 exists = (drv->touchpad_supported) ? true : false;
1288
1289         return exists ? attr->mode : 0;
1290 }
1291
1292 static struct attribute_group toshiba_attr_group = {
1293         .is_visible = toshiba_sysfs_is_visible,
1294         .attrs = toshiba_attributes,
1295 };
1296
1297 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str,
1298                                       struct serio *port)
1299 {
1300         if (str & 0x20)
1301                 return false;
1302
1303         if (unlikely(data == 0xe0))
1304                 return false;
1305
1306         if ((data & 0x7f) == TOS1900_FN_SCAN) {
1307                 schedule_work(&toshiba_acpi->hotkey_work);
1308                 return true;
1309         }
1310
1311         return false;
1312 }
1313
1314 static void toshiba_acpi_hotkey_work(struct work_struct *work)
1315 {
1316         acpi_handle ec_handle = ec_get_handle();
1317         acpi_status status;
1318
1319         if (!ec_handle)
1320                 return;
1321
1322         status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL);
1323         if (ACPI_FAILURE(status))
1324                 pr_err("ACPI NTFY method execution failed\n");
1325 }
1326
1327 /*
1328  * Returns hotkey scancode, or < 0 on failure.
1329  */
1330 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
1331 {
1332         unsigned long long value;
1333         acpi_status status;
1334
1335         status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO",
1336                                       NULL, &value);
1337         if (ACPI_FAILURE(status)) {
1338                 pr_err("ACPI INFO method execution failed\n");
1339                 return -EIO;
1340         }
1341
1342         return value;
1343 }
1344
1345 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
1346                                        int scancode)
1347 {
1348         if (scancode == 0x100)
1349                 return;
1350
1351         /* act on key press; ignore key release */
1352         if (scancode & 0x80)
1353                 return;
1354
1355         if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true))
1356                 pr_info("Unknown key %x\n", scancode);
1357 }
1358
1359 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
1360 {
1361         acpi_status status;
1362         acpi_handle ec_handle;
1363         int error;
1364         u32 hci_result;
1365
1366         dev->hotkey_dev = input_allocate_device();
1367         if (!dev->hotkey_dev)
1368                 return -ENOMEM;
1369
1370         dev->hotkey_dev->name = "Toshiba input device";
1371         dev->hotkey_dev->phys = "toshiba_acpi/input0";
1372         dev->hotkey_dev->id.bustype = BUS_HOST;
1373
1374         error = sparse_keymap_setup(dev->hotkey_dev, toshiba_acpi_keymap, NULL);
1375         if (error)
1376                 goto err_free_dev;
1377
1378         /*
1379          * For some machines the SCI responsible for providing hotkey
1380          * notification doesn't fire. We can trigger the notification
1381          * whenever the Fn key is pressed using the NTFY method, if
1382          * supported, so if it's present set up an i8042 key filter
1383          * for this purpose.
1384          */
1385         status = AE_ERROR;
1386         ec_handle = ec_get_handle();
1387         if (ec_handle && acpi_has_method(ec_handle, "NTFY")) {
1388                 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);
1389
1390                 error = i8042_install_filter(toshiba_acpi_i8042_filter);
1391                 if (error) {
1392                         pr_err("Error installing key filter\n");
1393                         goto err_free_keymap;
1394                 }
1395
1396                 dev->ntfy_supported = 1;
1397         }
1398
1399         /*
1400          * Determine hotkey query interface. Prefer using the INFO
1401          * method when it is available.
1402          */
1403         if (acpi_has_method(dev->acpi_dev->handle, "INFO"))
1404                 dev->info_supported = 1;
1405         else {
1406                 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
1407                 if (hci_result == HCI_SUCCESS)
1408                         dev->system_event_supported = 1;
1409         }
1410
1411         if (!dev->info_supported && !dev->system_event_supported) {
1412                 pr_warn("No hotkey query interface found\n");
1413                 goto err_remove_filter;
1414         }
1415
1416         status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", NULL, NULL);
1417         if (ACPI_FAILURE(status)) {
1418                 pr_info("Unable to enable hotkeys\n");
1419                 error = -ENODEV;
1420                 goto err_remove_filter;
1421         }
1422
1423         error = input_register_device(dev->hotkey_dev);
1424         if (error) {
1425                 pr_info("Unable to register input device\n");
1426                 goto err_remove_filter;
1427         }
1428
1429         hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &hci_result);
1430         return 0;
1431
1432  err_remove_filter:
1433         if (dev->ntfy_supported)
1434                 i8042_remove_filter(toshiba_acpi_i8042_filter);
1435  err_free_keymap:
1436         sparse_keymap_free(dev->hotkey_dev);
1437  err_free_dev:
1438         input_free_device(dev->hotkey_dev);
1439         dev->hotkey_dev = NULL;
1440         return error;
1441 }
1442
1443 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
1444 {
1445         struct backlight_properties props;
1446         int brightness;
1447         int ret;
1448         bool enabled;
1449
1450         /*
1451          * Some machines don't support the backlight methods at all, and
1452          * others support it read-only. Either of these is pretty useless,
1453          * so only register the backlight device if the backlight method
1454          * supports both reads and writes.
1455          */
1456         brightness = __get_lcd_brightness(dev);
1457         if (brightness < 0)
1458                 return 0;
1459         ret = set_lcd_brightness(dev, brightness);
1460         if (ret) {
1461                 pr_debug("Backlight method is read-only, disabling backlight support\n");
1462                 return 0;
1463         }
1464
1465         /* Determine whether or not BIOS supports transflective backlight */
1466         ret = get_tr_backlight_status(dev, &enabled);
1467         dev->tr_backlight_supported = !ret;
1468
1469         memset(&props, 0, sizeof(props));
1470         props.type = BACKLIGHT_PLATFORM;
1471         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
1472
1473         /* adding an extra level and having 0 change to transflective mode */
1474         if (dev->tr_backlight_supported)
1475                 props.max_brightness++;
1476
1477         dev->backlight_dev = backlight_device_register("toshiba",
1478                                                        &dev->acpi_dev->dev,
1479                                                        dev,
1480                                                        &toshiba_backlight_data,
1481                                                        &props);
1482         if (IS_ERR(dev->backlight_dev)) {
1483                 ret = PTR_ERR(dev->backlight_dev);
1484                 pr_err("Could not register toshiba backlight device\n");
1485                 dev->backlight_dev = NULL;
1486                 return ret;
1487         }
1488
1489         dev->backlight_dev->props.brightness = brightness;
1490         return 0;
1491 }
1492
1493 static int toshiba_acpi_remove(struct acpi_device *acpi_dev)
1494 {
1495         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1496
1497         remove_toshiba_proc_entries(dev);
1498
1499         if (dev->sysfs_created)
1500                 sysfs_remove_group(&dev->acpi_dev->dev.kobj,
1501                                    &toshiba_attr_group);
1502
1503         if (dev->ntfy_supported) {
1504                 i8042_remove_filter(toshiba_acpi_i8042_filter);
1505                 cancel_work_sync(&dev->hotkey_work);
1506         }
1507
1508         if (dev->hotkey_dev) {
1509                 input_unregister_device(dev->hotkey_dev);
1510                 sparse_keymap_free(dev->hotkey_dev);
1511         }
1512
1513         if (dev->bt_rfk) {
1514                 rfkill_unregister(dev->bt_rfk);
1515                 rfkill_destroy(dev->bt_rfk);
1516         }
1517
1518         if (dev->backlight_dev)
1519                 backlight_device_unregister(dev->backlight_dev);
1520
1521         if (dev->illumination_supported)
1522                 led_classdev_unregister(&dev->led_dev);
1523
1524         if (dev->kbd_led_registered)
1525                 led_classdev_unregister(&dev->kbd_led);
1526
1527         if (dev->eco_supported)
1528                 led_classdev_unregister(&dev->eco_led);
1529
1530         if (toshiba_acpi)
1531                 toshiba_acpi = NULL;
1532
1533         kfree(dev);
1534
1535         return 0;
1536 }
1537
1538 static const char *find_hci_method(acpi_handle handle)
1539 {
1540         if (acpi_has_method(handle, "GHCI"))
1541                 return "GHCI";
1542
1543         if (acpi_has_method(handle, "SPFC"))
1544                 return "SPFC";
1545
1546         return NULL;
1547 }
1548
1549 static int toshiba_acpi_add(struct acpi_device *acpi_dev)
1550 {
1551         struct toshiba_acpi_dev *dev;
1552         const char *hci_method;
1553         u32 dummy;
1554         bool bt_present;
1555         int ret = 0;
1556
1557         if (toshiba_acpi)
1558                 return -EBUSY;
1559
1560         pr_info("Toshiba Laptop ACPI Extras version %s\n",
1561                TOSHIBA_ACPI_VERSION);
1562
1563         hci_method = find_hci_method(acpi_dev->handle);
1564         if (!hci_method) {
1565                 pr_err("HCI interface not found\n");
1566                 return -ENODEV;
1567         }
1568
1569         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1570         if (!dev)
1571                 return -ENOMEM;
1572         dev->acpi_dev = acpi_dev;
1573         dev->method_hci = hci_method;
1574         acpi_dev->driver_data = dev;
1575         dev_set_drvdata(&acpi_dev->dev, dev);
1576
1577         if (toshiba_acpi_setup_keyboard(dev))
1578                 pr_info("Unable to activate hotkeys\n");
1579
1580         mutex_init(&dev->mutex);
1581
1582         ret = toshiba_acpi_setup_backlight(dev);
1583         if (ret)
1584                 goto error;
1585
1586         /* Register rfkill switch for Bluetooth */
1587         if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) {
1588                 dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth",
1589                                            &acpi_dev->dev,
1590                                            RFKILL_TYPE_BLUETOOTH,
1591                                            &toshiba_rfk_ops,
1592                                            dev);
1593                 if (!dev->bt_rfk) {
1594                         pr_err("unable to allocate rfkill device\n");
1595                         ret = -ENOMEM;
1596                         goto error;
1597                 }
1598
1599                 ret = rfkill_register(dev->bt_rfk);
1600                 if (ret) {
1601                         pr_err("unable to register rfkill device\n");
1602                         rfkill_destroy(dev->bt_rfk);
1603                         goto error;
1604                 }
1605         }
1606
1607         if (toshiba_illumination_available(dev)) {
1608                 dev->led_dev.name = "toshiba::illumination";
1609                 dev->led_dev.max_brightness = 1;
1610                 dev->led_dev.brightness_set = toshiba_illumination_set;
1611                 dev->led_dev.brightness_get = toshiba_illumination_get;
1612                 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
1613                         dev->illumination_supported = 1;
1614         }
1615
1616         if (toshiba_eco_mode_available(dev)) {
1617                 dev->eco_led.name = "toshiba::eco_mode";
1618                 dev->eco_led.max_brightness = 1;
1619                 dev->eco_led.brightness_set = toshiba_eco_mode_set_status;
1620                 dev->eco_led.brightness_get = toshiba_eco_mode_get_status;
1621                 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led))
1622                         dev->eco_supported = 1;
1623         }
1624
1625         ret = toshiba_kbd_illum_status_get(dev, &dummy);
1626         if (!ret) {
1627                 dev->kbd_time = dummy >> HCI_MISC_SHIFT;
1628                 dev->kbd_mode = dummy & 0x07;
1629         }
1630         dev->kbd_illum_supported = !ret;
1631         /*
1632          * Only register the LED if KBD illumination is supported
1633          * and the keyboard backlight operation mode is set to FN-Z
1634          */
1635         if (dev->kbd_illum_supported && dev->kbd_mode == SCI_KBD_MODE_FNZ) {
1636                 dev->kbd_led.name = "toshiba::kbd_backlight";
1637                 dev->kbd_led.max_brightness = 1;
1638                 dev->kbd_led.brightness_set = toshiba_kbd_backlight_set;
1639                 dev->kbd_led.brightness_get = toshiba_kbd_backlight_get;
1640                 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led))
1641                         dev->kbd_led_registered = 1;
1642         }
1643
1644         ret = toshiba_touchpad_get(dev, &dummy);
1645         dev->touchpad_supported = !ret;
1646
1647         /* Determine whether or not BIOS supports fan and video interfaces */
1648
1649         ret = get_video_status(dev, &dummy);
1650         dev->video_supported = !ret;
1651
1652         ret = get_fan_status(dev, &dummy);
1653         dev->fan_supported = !ret;
1654
1655         ret = sysfs_create_group(&dev->acpi_dev->dev.kobj,
1656                                  &toshiba_attr_group);
1657         if (ret) {
1658                 dev->sysfs_created = 0;
1659                 goto error;
1660         }
1661         dev->sysfs_created = !ret;
1662
1663         create_toshiba_proc_entries(dev);
1664
1665         toshiba_acpi = dev;
1666
1667         return 0;
1668
1669 error:
1670         toshiba_acpi_remove(acpi_dev);
1671         return ret;
1672 }
1673
1674 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
1675 {
1676         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1677         u32 hci_result, value;
1678         int retries = 3;
1679         int scancode;
1680
1681         if (event != 0x80)
1682                 return;
1683
1684         if (dev->info_supported) {
1685                 scancode = toshiba_acpi_query_hotkey(dev);
1686                 if (scancode < 0)
1687                         pr_err("Failed to query hotkey event\n");
1688                 else if (scancode != 0)
1689                         toshiba_acpi_report_hotkey(dev, scancode);
1690         } else if (dev->system_event_supported) {
1691                 do {
1692                         hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
1693                         switch (hci_result) {
1694                         case HCI_SUCCESS:
1695                                 toshiba_acpi_report_hotkey(dev, (int)value);
1696                                 break;
1697                         case HCI_NOT_SUPPORTED:
1698                                 /*
1699                                  * This is a workaround for an unresolved
1700                                  * issue on some machines where system events
1701                                  * sporadically become disabled.
1702                                  */
1703                                 hci_write1(dev, HCI_SYSTEM_EVENT, 1,
1704                                            &hci_result);
1705                                 pr_notice("Re-enabled hotkeys\n");
1706                                 /* fall through */
1707                         default:
1708                                 retries--;
1709                                 break;
1710                         }
1711                 } while (retries && hci_result != HCI_EMPTY);
1712         }
1713 }
1714
1715 #ifdef CONFIG_PM_SLEEP
1716 static int toshiba_acpi_suspend(struct device *device)
1717 {
1718         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1719         u32 result;
1720
1721         if (dev->hotkey_dev)
1722                 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE, &result);
1723
1724         return 0;
1725 }
1726
1727 static int toshiba_acpi_resume(struct device *device)
1728 {
1729         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1730         u32 result;
1731
1732         if (dev->hotkey_dev)
1733                 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &result);
1734
1735         return 0;
1736 }
1737 #endif
1738
1739 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
1740                          toshiba_acpi_suspend, toshiba_acpi_resume);
1741
1742 static struct acpi_driver toshiba_acpi_driver = {
1743         .name   = "Toshiba ACPI driver",
1744         .owner  = THIS_MODULE,
1745         .ids    = toshiba_device_ids,
1746         .flags  = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1747         .ops    = {
1748                 .add            = toshiba_acpi_add,
1749                 .remove         = toshiba_acpi_remove,
1750                 .notify         = toshiba_acpi_notify,
1751         },
1752         .drv.pm = &toshiba_acpi_pm,
1753 };
1754
1755 static int __init toshiba_acpi_init(void)
1756 {
1757         int ret;
1758
1759         /*
1760          * Machines with this WMI guid aren't supported due to bugs in
1761          * their AML. This check relies on wmi initializing before
1762          * toshiba_acpi to guarantee guids have been identified.
1763          */
1764         if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
1765                 return -ENODEV;
1766
1767         toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
1768         if (!toshiba_proc_dir) {
1769                 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
1770                 return -ENODEV;
1771         }
1772
1773         ret = acpi_bus_register_driver(&toshiba_acpi_driver);
1774         if (ret) {
1775                 pr_err("Failed to register ACPI driver: %d\n", ret);
1776                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1777         }
1778
1779         return ret;
1780 }
1781
1782 static void __exit toshiba_acpi_exit(void)
1783 {
1784         acpi_bus_unregister_driver(&toshiba_acpi_driver);
1785         if (toshiba_proc_dir)
1786                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1787 }
1788
1789 module_init(toshiba_acpi_init);
1790 module_exit(toshiba_acpi_exit);