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
  58 #include <asm/uaccess.h>
  59
  60 #include <acpi/acpi_drivers.h>
  61
  62 MODULE_AUTHOR("John Belmonte");
  63 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
  64 MODULE_LICENSE("GPL");
  65
  66 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"
  67
  68 /* Scan code for Fn key on TOS1900 models */
  69 #define TOS1900_FN_SCAN         0x6e
  70
  71 /* Toshiba ACPI method paths */
  72 #define METHOD_VIDEO_OUT        "\\_SB_.VALX.DSSX"
  73
  74 /* Toshiba HCI interface definitions
  75  *
  76  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
  77  * be uniform across all their models.  Ideally we would just call
  78  * dedicated ACPI methods instead of using this primitive interface.
  79  * However the ACPI methods seem to be incomplete in some areas (for
  80  * example they allow setting, but not reading, the LCD brightness value),
  81  * so this is still useful.
  82  */
  83
  84 #define HCI_WORDS                       6
  85
  86 /* operations */
  87 #define HCI_SET                         0xff00
  88 #define HCI_GET                         0xfe00
  89
  90 /* return codes */
  91 #define HCI_SUCCESS                     0x0000
  92 #define HCI_FAILURE                     0x1000
  93 #define HCI_NOT_SUPPORTED               0x8000
  94 #define HCI_EMPTY                       0x8c00
  95
  96 /* registers */
  97 #define HCI_FAN                         0x0004
  98 #define HCI_TR_BACKLIGHT                0x0005
  99 #define HCI_SYSTEM_EVENT                0x0016
 100 #define HCI_VIDEO_OUT                   0x001c
 101 #define HCI_HOTKEY_EVENT                0x001e
 102 #define HCI_LCD_BRIGHTNESS              0x002a
 103 #define HCI_WIRELESS                    0x0056
 104
 105 /* field definitions */
 106 #define HCI_HOTKEY_DISABLE              0x0b
 107 #define HCI_HOTKEY_ENABLE               0x09
 108 #define HCI_LCD_BRIGHTNESS_BITS         3
 109 #define HCI_LCD_BRIGHTNESS_SHIFT        (16-HCI_LCD_BRIGHTNESS_BITS)
 110 #define HCI_LCD_BRIGHTNESS_LEVELS       (1 << HCI_LCD_BRIGHTNESS_BITS)
 111 #define HCI_VIDEO_OUT_LCD               0x1
 112 #define HCI_VIDEO_OUT_CRT               0x2
 113 #define HCI_VIDEO_OUT_TV                0x4
 114 #define HCI_WIRELESS_KILL_SWITCH        0x01
 115 #define HCI_WIRELESS_BT_PRESENT         0x0f
 116 #define HCI_WIRELESS_BT_ATTACH          0x40
 117 #define HCI_WIRELESS_BT_POWER           0x80
 118
 119 struct toshiba_acpi_dev {
 120         struct acpi_device *acpi_dev;
 121         const char *method_hci;
 122         struct rfkill *bt_rfk;
 123         struct input_dev *hotkey_dev;
 124         struct work_struct hotkey_work;
 125         struct backlight_device *backlight_dev;
 126         struct led_classdev led_dev;
 127
 128         int force_fan;
 129         int last_key_event;
 130         int key_event_valid;
 131
 132         unsigned int illumination_supported:1;
 133         unsigned int video_supported:1;
 134         unsigned int fan_supported:1;
 135         unsigned int system_event_supported:1;
 136         unsigned int ntfy_supported:1;
 137         unsigned int info_supported:1;
 138         unsigned int tr_backlight_supported:1;
 139
 140         struct mutex mutex;
 141 };
 142
 143 static struct toshiba_acpi_dev *toshiba_acpi;
 144
 145 static const struct acpi_device_id toshiba_device_ids[] = {
 146         {"TOS6200", 0},
 147         {"TOS6208", 0},
 148         {"TOS1900", 0},
 149         {"", 0},
 150 };
 151 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
 152
 153 static const struct key_entry toshiba_acpi_keymap[] __devinitconst = {
 154         { KE_KEY, 0x101, { KEY_MUTE } },
 155         { KE_KEY, 0x102, { KEY_ZOOMOUT } },
 156         { KE_KEY, 0x103, { KEY_ZOOMIN } },
 157         { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
 158         { KE_KEY, 0x139, { KEY_ZOOMRESET } },
 159         { KE_KEY, 0x13b, { KEY_COFFEE } },
 160         { KE_KEY, 0x13c, { KEY_BATTERY } },
 161         { KE_KEY, 0x13d, { KEY_SLEEP } },
 162         { KE_KEY, 0x13e, { KEY_SUSPEND } },
 163         { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
 164         { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
 165         { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
 166         { KE_KEY, 0x142, { KEY_WLAN } },
 167         { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } },
 168         { KE_KEY, 0x17f, { KEY_FN } },
 169         { KE_KEY, 0xb05, { KEY_PROG2 } },
 170         { KE_KEY, 0xb06, { KEY_WWW } },
 171         { KE_KEY, 0xb07, { KEY_MAIL } },
 172         { KE_KEY, 0xb30, { KEY_STOP } },
 173         { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
 174         { KE_KEY, 0xb32, { KEY_NEXTSONG } },
 175         { KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
 176         { KE_KEY, 0xb5a, { KEY_MEDIA } },
 177         { KE_IGNORE, 0x1430, { KEY_RESERVED } },
 178         { KE_END, 0 },
 179 };
 180
 181 /* utility
 182  */
 183
 184 static __inline__ void _set_bit(u32 * word, u32 mask, int value)
 185 {
 186         *word = (*word & ~mask) | (mask * value);
 187 }
 188
 189 /* acpi interface wrappers
 190  */
 191
 192 static int write_acpi_int(const char *methodName, int val)
 193 {
 194         struct acpi_object_list params;
 195         union acpi_object in_objs[1];
 196         acpi_status status;
 197
 198         params.count = ARRAY_SIZE(in_objs);
 199         params.pointer = in_objs;
 200         in_objs[0].type = ACPI_TYPE_INTEGER;
 201         in_objs[0].integer.value = val;
 202
 203         status = acpi_evaluate_object(NULL, (char *)methodName, &params, NULL);
 204         return (status == AE_OK) ? 0 : -EIO;
 205 }
 206
 207 /* Perform a raw HCI call.  Here we don't care about input or output buffer
 208  * format.
 209  */
 210 static acpi_status hci_raw(struct toshiba_acpi_dev *dev,
 211                            const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
 212 {
 213         struct acpi_object_list params;
 214         union acpi_object in_objs[HCI_WORDS];
 215         struct acpi_buffer results;
 216         union acpi_object out_objs[HCI_WORDS + 1];
 217         acpi_status status;
 218         int i;
 219
 220         params.count = HCI_WORDS;
 221         params.pointer = in_objs;
 222         for (i = 0; i < HCI_WORDS; ++i) {
 223                 in_objs[i].type = ACPI_TYPE_INTEGER;
 224                 in_objs[i].integer.value = in[i];
 225         }
 226
 227         results.length = sizeof(out_objs);
 228         results.pointer = out_objs;
 229
 230         status = acpi_evaluate_object(dev->acpi_dev->handle,
 231                                       (char *)dev->method_hci, &params,
 232                                       &results);
 233         if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
 234                 for (i = 0; i < out_objs->package.count; ++i) {
 235                         out[i] = out_objs->package.elements[i].integer.value;
 236                 }
 237         }
 238
 239         return status;
 240 }
 241
 242 /* common hci tasks (get or set one or two value)
 243  *
 244  * In addition to the ACPI status, the HCI system returns a result which
 245  * may be useful (such as "not supported").
 246  */
 247
 248 static acpi_status hci_write1(struct toshiba_acpi_dev *dev, u32 reg,
 249                               u32 in1, u32 *result)
 250 {
 251         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
 252         u32 out[HCI_WORDS];
 253         acpi_status status = hci_raw(dev, in, out);
 254         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 255         return status;
 256 }
 257
 258 static acpi_status hci_read1(struct toshiba_acpi_dev *dev, u32 reg,
 259                              u32 *out1, u32 *result)
 260 {
 261         u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
 262         u32 out[HCI_WORDS];
 263         acpi_status status = hci_raw(dev, in, out);
 264         *out1 = out[2];
 265         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 266         return status;
 267 }
 268
 269 static acpi_status hci_write2(struct toshiba_acpi_dev *dev, u32 reg,
 270                               u32 in1, u32 in2, u32 *result)
 271 {
 272         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 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_read2(struct toshiba_acpi_dev *dev, u32 reg,
 280                              u32 *out1, u32 *out2, u32 *result)
 281 {
 282         u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
 283         u32 out[HCI_WORDS];
 284         acpi_status status = hci_raw(dev, in, out);
 285         *out1 = out[2];
 286         *out2 = out[3];
 287         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 288         return status;
 289 }
 290
 291 /* Illumination support */
 292 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev)
 293 {
 294         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
 295         u32 out[HCI_WORDS];
 296         acpi_status status;
 297
 298         in[0] = 0xf100;
 299         status = hci_raw(dev, in, out);
 300         if (ACPI_FAILURE(status)) {
 301                 pr_info("Illumination device not available\n");
 302                 return 0;
 303         }
 304         in[0] = 0xf400;
 305         status = hci_raw(dev, in, out);
 306         return 1;
 307 }
 308
 309 static void toshiba_illumination_set(struct led_classdev *cdev,
 310                                      enum led_brightness brightness)
 311 {
 312         struct toshiba_acpi_dev *dev = container_of(cdev,
 313                         struct toshiba_acpi_dev, led_dev);
 314         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
 315         u32 out[HCI_WORDS];
 316         acpi_status status;
 317
 318         /* First request : initialize communication. */
 319         in[0] = 0xf100;
 320         status = hci_raw(dev, in, out);
 321         if (ACPI_FAILURE(status)) {
 322                 pr_info("Illumination device not available\n");
 323                 return;
 324         }
 325
 326         if (brightness) {
 327                 /* Switch the illumination on */
 328                 in[0] = 0xf400;
 329                 in[1] = 0x14e;
 330                 in[2] = 1;
 331                 status = hci_raw(dev, in, out);
 332                 if (ACPI_FAILURE(status)) {
 333                         pr_info("ACPI call for illumination failed\n");
 334                         return;
 335                 }
 336         } else {
 337                 /* Switch the illumination off */
 338                 in[0] = 0xf400;
 339                 in[1] = 0x14e;
 340                 in[2] = 0;
 341                 status = hci_raw(dev, in, out);
 342                 if (ACPI_FAILURE(status)) {
 343                         pr_info("ACPI call for illumination failed.\n");
 344                         return;
 345                 }
 346         }
 347
 348         /* Last request : close communication. */
 349         in[0] = 0xf200;
 350         in[1] = 0;
 351         in[2] = 0;
 352         hci_raw(dev, in, out);
 353 }
 354
 355 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
 356 {
 357         struct toshiba_acpi_dev *dev = container_of(cdev,
 358                         struct toshiba_acpi_dev, led_dev);
 359         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
 360         u32 out[HCI_WORDS];
 361         acpi_status status;
 362         enum led_brightness result;
 363
 364         /* First request : initialize communication. */
 365         in[0] = 0xf100;
 366         status = hci_raw(dev, in, out);
 367         if (ACPI_FAILURE(status)) {
 368                 pr_info("Illumination device not available\n");
 369                 return LED_OFF;
 370         }
 371
 372         /* Check the illumination */
 373         in[0] = 0xf300;
 374         in[1] = 0x14e;
 375         status = hci_raw(dev, in, out);
 376         if (ACPI_FAILURE(status)) {
 377                 pr_info("ACPI call for illumination failed.\n");
 378                 return LED_OFF;
 379         }
 380
 381         result = out[2] ? LED_FULL : LED_OFF;
 382
 383         /* Last request : close communication. */
 384         in[0] = 0xf200;
 385         in[1] = 0;
 386         in[2] = 0;
 387         hci_raw(dev, in, out);
 388
 389         return result;
 390 }
 391
 392 /* Bluetooth rfkill handlers */
 393
 394 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
 395 {
 396         u32 hci_result;
 397         u32 value, value2;
 398
 399         value = 0;
 400         value2 = 0;
 401         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
 402         if (hci_result == HCI_SUCCESS)
 403                 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;
 404
 405         return hci_result;
 406 }
 407
 408 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state)
 409 {
 410         u32 hci_result;
 411         u32 value, value2;
 412
 413         value = 0;
 414         value2 = 0x0001;
 415         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
 416
 417         *radio_state = value & HCI_WIRELESS_KILL_SWITCH;
 418         return hci_result;
 419 }
 420
 421 static int bt_rfkill_set_block(void *data, bool blocked)
 422 {
 423         struct toshiba_acpi_dev *dev = data;
 424         u32 result1, result2;
 425         u32 value;
 426         int err;
 427         bool radio_state;
 428
 429         value = (blocked == false);
 430
 431         mutex_lock(&dev->mutex);
 432         if (hci_get_radio_state(dev, &radio_state) != HCI_SUCCESS) {
 433                 err = -EIO;
 434                 goto out;
 435         }
 436
 437         if (!radio_state) {
 438                 err = 0;
 439                 goto out;
 440         }
 441
 442         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
 443         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);
 444
 445         if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
 446                 err = -EIO;
 447         else
 448                 err = 0;
 449  out:
 450         mutex_unlock(&dev->mutex);
 451         return err;
 452 }
 453
 454 static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
 455 {
 456         bool new_rfk_state;
 457         bool value;
 458         u32 hci_result;
 459         struct toshiba_acpi_dev *dev = data;
 460
 461         mutex_lock(&dev->mutex);
 462
 463         hci_result = hci_get_radio_state(dev, &value);
 464         if (hci_result != HCI_SUCCESS) {
 465                 /* Can't do anything useful */
 466                 mutex_unlock(&dev->mutex);
 467                 return;
 468         }
 469
 470         new_rfk_state = value;
 471
 472         mutex_unlock(&dev->mutex);
 473
 474         if (rfkill_set_hw_state(rfkill, !new_rfk_state))
 475                 bt_rfkill_set_block(data, true);
 476 }
 477
 478 static const struct rfkill_ops toshiba_rfk_ops = {
 479         .set_block = bt_rfkill_set_block,
 480         .poll = bt_rfkill_poll,
 481 };
 482
 483 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, bool *enabled)
 484 {
 485         u32 hci_result;
 486         u32 status;
 487
 488         hci_read1(dev, HCI_TR_BACKLIGHT, &status, &hci_result);
 489         *enabled = !status;
 490         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 491 }
 492
 493 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable)
 494 {
 495         u32 hci_result;
 496         u32 value = !enable;
 497
 498         hci_write1(dev, HCI_TR_BACKLIGHT, value, &hci_result);
 499         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 500 }
 501
 502 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
 503
 504 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
 505 {
 506         u32 hci_result;
 507         u32 value;
 508         int brightness = 0;
 509
 510         if (dev->tr_backlight_supported) {
 511                 bool enabled;
 512                 int ret = get_tr_backlight_status(dev, &enabled);
 513                 if (ret)
 514                         return ret;
 515                 if (enabled)
 516                         return 0;
 517                 brightness++;
 518         }
 519
 520         hci_read1(dev, HCI_LCD_BRIGHTNESS, &value, &hci_result);
 521         if (hci_result == HCI_SUCCESS)
 522                 return brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT);
 523
 524         return -EIO;
 525 }
 526
 527 static int get_lcd_brightness(struct backlight_device *bd)
 528 {
 529         struct toshiba_acpi_dev *dev = bl_get_data(bd);
 530         return __get_lcd_brightness(dev);
 531 }
 532
 533 static int lcd_proc_show(struct seq_file *m, void *v)
 534 {
 535         struct toshiba_acpi_dev *dev = m->private;
 536         int value;
 537         int levels;
 538
 539         if (!dev->backlight_dev)
 540                 return -ENODEV;
 541
 542         levels = dev->backlight_dev->props.max_brightness + 1;
 543         value = get_lcd_brightness(dev->backlight_dev);
 544         if (value >= 0) {
 545                 seq_printf(m, "brightness:              %d\n", value);
 546                 seq_printf(m, "brightness_levels:       %d\n", levels);
 547                 return 0;
 548         }
 549
 550         pr_err("Error reading LCD brightness\n");
 551         return -EIO;
 552 }
 553
 554 static int lcd_proc_open(struct inode *inode, struct file *file)
 555 {
 556         return single_open(file, lcd_proc_show, PDE(inode)->data);
 557 }
 558
 559 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
 560 {
 561         u32 hci_result;
 562
 563         if (dev->tr_backlight_supported) {
 564                 bool enable = !value;
 565                 int ret = set_tr_backlight_status(dev, enable);
 566                 if (ret)
 567                         return ret;
 568                 if (value)
 569                         value--;
 570         }
 571
 572         value = value << HCI_LCD_BRIGHTNESS_SHIFT;
 573         hci_write1(dev, HCI_LCD_BRIGHTNESS, value, &hci_result);
 574         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 575 }
 576
 577 static int set_lcd_status(struct backlight_device *bd)
 578 {
 579         struct toshiba_acpi_dev *dev = bl_get_data(bd);
 580         return set_lcd_brightness(dev, bd->props.brightness);
 581 }
 582
 583 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
 584                               size_t count, loff_t *pos)
 585 {
 586         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 587         char cmd[42];
 588         size_t len;
 589         int value;
 590         int ret;
 591         int levels = dev->backlight_dev->props.max_brightness + 1;
 592
 593         len = min(count, sizeof(cmd) - 1);
 594         if (copy_from_user(cmd, buf, len))
 595                 return -EFAULT;
 596         cmd[len] = '\0';
 597
 598         if (sscanf(cmd, " brightness : %i", &value) == 1 &&
 599             value >= 0 && value < levels) {
 600                 ret = set_lcd_brightness(dev, value);
 601                 if (ret == 0)
 602                         ret = count;
 603         } else {
 604                 ret = -EINVAL;
 605         }
 606         return ret;
 607 }
 608
 609 static const struct file_operations lcd_proc_fops = {
 610         .owner          = THIS_MODULE,
 611         .open           = lcd_proc_open,
 612         .read           = seq_read,
 613         .llseek         = seq_lseek,
 614         .release        = single_release,
 615         .write          = lcd_proc_write,
 616 };
 617
 618 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
 619 {
 620         u32 hci_result;
 621
 622         hci_read1(dev, HCI_VIDEO_OUT, status, &hci_result);
 623         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 624 }
 625
 626 static int video_proc_show(struct seq_file *m, void *v)
 627 {
 628         struct toshiba_acpi_dev *dev = m->private;
 629         u32 value;
 630         int ret;
 631
 632         ret = get_video_status(dev, &value);
 633         if (!ret) {
 634                 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
 635                 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
 636                 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
 637                 seq_printf(m, "lcd_out:                 %d\n", is_lcd);
 638                 seq_printf(m, "crt_out:                 %d\n", is_crt);
 639                 seq_printf(m, "tv_out:                  %d\n", is_tv);
 640         }
 641
 642         return ret;
 643 }
 644
 645 static int video_proc_open(struct inode *inode, struct file *file)
 646 {
 647         return single_open(file, video_proc_show, PDE(inode)->data);
 648 }
 649
 650 static ssize_t video_proc_write(struct file *file, const char __user *buf,
 651                                 size_t count, loff_t *pos)
 652 {
 653         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 654         char *cmd, *buffer;
 655         int ret;
 656         int value;
 657         int remain = count;
 658         int lcd_out = -1;
 659         int crt_out = -1;
 660         int tv_out = -1;
 661         u32 video_out;
 662
 663         cmd = kmalloc(count + 1, GFP_KERNEL);
 664         if (!cmd)
 665                 return -ENOMEM;
 666         if (copy_from_user(cmd, buf, count)) {
 667                 kfree(cmd);
 668                 return -EFAULT;
 669         }
 670         cmd[count] = '\0';
 671
 672         buffer = cmd;
 673
 674         /* scan expression.  Multiple expressions may be delimited with ;
 675          *
 676          *  NOTE: to keep scanning simple, invalid fields are ignored
 677          */
 678         while (remain) {
 679                 if (sscanf(buffer, " lcd_out : %i", &value) == 1)
 680                         lcd_out = value & 1;
 681                 else if (sscanf(buffer, " crt_out : %i", &value) == 1)
 682                         crt_out = value & 1;
 683                 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
 684                         tv_out = value & 1;
 685                 /* advance to one character past the next ; */
 686                 do {
 687                         ++buffer;
 688                         --remain;
 689                 }
 690                 while (remain && *(buffer - 1) != ';');
 691         }
 692
 693         kfree(cmd);
 694
 695         ret = get_video_status(dev, &video_out);
 696         if (!ret) {
 697                 unsigned int new_video_out = video_out;
 698                 if (lcd_out != -1)
 699                         _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
 700                 if (crt_out != -1)
 701                         _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
 702                 if (tv_out != -1)
 703                         _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
 704                 /* To avoid unnecessary video disruption, only write the new
 705                  * video setting if something changed. */
 706                 if (new_video_out != video_out)
 707                         ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
 708         }
 709
 710         return ret ? ret : count;
 711 }
 712
 713 static const struct file_operations video_proc_fops = {
 714         .owner          = THIS_MODULE,
 715         .open           = video_proc_open,
 716         .read           = seq_read,
 717         .llseek         = seq_lseek,
 718         .release        = single_release,
 719         .write          = video_proc_write,
 720 };
 721
 722 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
 723 {
 724         u32 hci_result;
 725
 726         hci_read1(dev, HCI_FAN, status, &hci_result);
 727         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 728 }
 729
 730 static int fan_proc_show(struct seq_file *m, void *v)
 731 {
 732         struct toshiba_acpi_dev *dev = m->private;
 733         int ret;
 734         u32 value;
 735
 736         ret = get_fan_status(dev, &value);
 737         if (!ret) {
 738                 seq_printf(m, "running:                 %d\n", (value > 0));
 739                 seq_printf(m, "force_on:                %d\n", dev->force_fan);
 740         }
 741
 742         return ret;
 743 }
 744
 745 static int fan_proc_open(struct inode *inode, struct file *file)
 746 {
 747         return single_open(file, fan_proc_show, PDE(inode)->data);
 748 }
 749
 750 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
 751                               size_t count, loff_t *pos)
 752 {
 753         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 754         char cmd[42];
 755         size_t len;
 756         int value;
 757         u32 hci_result;
 758
 759         len = min(count, sizeof(cmd) - 1);
 760         if (copy_from_user(cmd, buf, len))
 761                 return -EFAULT;
 762         cmd[len] = '\0';
 763
 764         if (sscanf(cmd, " force_on : %i", &value) == 1 &&
 765             value >= 0 && value <= 1) {
 766                 hci_write1(dev, HCI_FAN, value, &hci_result);
 767                 if (hci_result != HCI_SUCCESS)
 768                         return -EIO;
 769                 else
 770                         dev->force_fan = value;
 771         } else {
 772                 return -EINVAL;
 773         }
 774
 775         return count;
 776 }
 777
 778 static const struct file_operations fan_proc_fops = {
 779         .owner          = THIS_MODULE,
 780         .open           = fan_proc_open,
 781         .read           = seq_read,
 782         .llseek         = seq_lseek,
 783         .release        = single_release,
 784         .write          = fan_proc_write,
 785 };
 786
 787 static int keys_proc_show(struct seq_file *m, void *v)
 788 {
 789         struct toshiba_acpi_dev *dev = m->private;
 790         u32 hci_result;
 791         u32 value;
 792
 793         if (!dev->key_event_valid && dev->system_event_supported) {
 794                 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
 795                 if (hci_result == HCI_SUCCESS) {
 796                         dev->key_event_valid = 1;
 797                         dev->last_key_event = value;
 798                 } else if (hci_result == HCI_EMPTY) {
 799                         /* better luck next time */
 800                 } else if (hci_result == HCI_NOT_SUPPORTED) {
 801                         /* This is a workaround for an unresolved issue on
 802                          * some machines where system events sporadically
 803                          * become disabled. */
 804                         hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
 805                         pr_notice("Re-enabled hotkeys\n");
 806                 } else {
 807                         pr_err("Error reading hotkey status\n");
 808                         return -EIO;
 809                 }
 810         }
 811
 812         seq_printf(m, "hotkey_ready:            %d\n", dev->key_event_valid);
 813         seq_printf(m, "hotkey:                  0x%04x\n", dev->last_key_event);
 814         return 0;
 815 }
 816
 817 static int keys_proc_open(struct inode *inode, struct file *file)
 818 {
 819         return single_open(file, keys_proc_show, PDE(inode)->data);
 820 }
 821
 822 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
 823                                size_t count, loff_t *pos)
 824 {
 825         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 826         char cmd[42];
 827         size_t len;
 828         int value;
 829
 830         len = min(count, sizeof(cmd) - 1);
 831         if (copy_from_user(cmd, buf, len))
 832                 return -EFAULT;
 833         cmd[len] = '\0';
 834
 835         if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
 836                 dev->key_event_valid = 0;
 837         } else {
 838                 return -EINVAL;
 839         }
 840
 841         return count;
 842 }
 843
 844 static const struct file_operations keys_proc_fops = {
 845         .owner          = THIS_MODULE,
 846         .open           = keys_proc_open,
 847         .read           = seq_read,
 848         .llseek         = seq_lseek,
 849         .release        = single_release,
 850         .write          = keys_proc_write,
 851 };
 852
 853 static int version_proc_show(struct seq_file *m, void *v)
 854 {
 855         seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
 856         seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
 857         return 0;
 858 }
 859
 860 static int version_proc_open(struct inode *inode, struct file *file)
 861 {
 862         return single_open(file, version_proc_show, PDE(inode)->data);
 863 }
 864
 865 static const struct file_operations version_proc_fops = {
 866         .owner          = THIS_MODULE,
 867         .open           = version_proc_open,
 868         .read           = seq_read,
 869         .llseek         = seq_lseek,
 870         .release        = single_release,
 871 };
 872
 873 /* proc and module init
 874  */
 875
 876 #define PROC_TOSHIBA            "toshiba"
 877
 878 static void __devinit
 879 create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
 880 {
 881         if (dev->backlight_dev)
 882                 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 883                                  &lcd_proc_fops, dev);
 884         if (dev->video_supported)
 885                 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 886                                  &video_proc_fops, dev);
 887         if (dev->fan_supported)
 888                 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 889                                  &fan_proc_fops, dev);
 890         if (dev->hotkey_dev)
 891                 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 892                                  &keys_proc_fops, dev);
 893         proc_create_data("version", S_IRUGO, toshiba_proc_dir,
 894                          &version_proc_fops, dev);
 895 }
 896
 897 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
 898 {
 899         if (dev->backlight_dev)
 900                 remove_proc_entry("lcd", toshiba_proc_dir);
 901         if (dev->video_supported)
 902                 remove_proc_entry("video", toshiba_proc_dir);
 903         if (dev->fan_supported)
 904                 remove_proc_entry("fan", toshiba_proc_dir);
 905         if (dev->hotkey_dev)
 906                 remove_proc_entry("keys", toshiba_proc_dir);
 907         remove_proc_entry("version", toshiba_proc_dir);
 908 }
 909
 910 static const struct backlight_ops toshiba_backlight_data = {
 911         .options = BL_CORE_SUSPENDRESUME,
 912         .get_brightness = get_lcd_brightness,
 913         .update_status  = set_lcd_status,
 914 };
 915
 916 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str,
 917                                       struct serio *port)
 918 {
 919         if (str & 0x20)
 920                 return false;
 921
 922         if (unlikely(data == 0xe0))
 923                 return false;
 924
 925         if ((data & 0x7f) == TOS1900_FN_SCAN) {
 926                 schedule_work(&toshiba_acpi->hotkey_work);
 927                 return true;
 928         }
 929
 930         return false;
 931 }
 932
 933 static void toshiba_acpi_hotkey_work(struct work_struct *work)
 934 {
 935         acpi_handle ec_handle = ec_get_handle();
 936         acpi_status status;
 937
 938         if (!ec_handle)
 939                 return;
 940
 941         status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL);
 942         if (ACPI_FAILURE(status))
 943                 pr_err("ACPI NTFY method execution failed\n");
 944 }
 945
 946 /*
 947  * Returns hotkey scancode, or < 0 on failure.
 948  */
 949 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
 950 {
 951         struct acpi_buffer buf;
 952         union acpi_object out_obj;
 953         acpi_status status;
 954
 955         buf.pointer = &out_obj;
 956         buf.length = sizeof(out_obj);
 957
 958         status = acpi_evaluate_object(dev->acpi_dev->handle, "INFO",
 959                                       NULL, &buf);
 960         if (ACPI_FAILURE(status) || out_obj.type != ACPI_TYPE_INTEGER) {
 961                 pr_err("ACPI INFO method execution failed\n");
 962                 return -EIO;
 963         }
 964
 965         return out_obj.integer.value;
 966 }
 967
 968 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
 969                                        int scancode)
 970 {
 971         if (scancode == 0x100)
 972                 return;
 973
 974         /* act on key press; ignore key release */
 975         if (scancode & 0x80)
 976                 return;
 977
 978         if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true))
 979                 pr_info("Unknown key %x\n", scancode);
 980 }
 981
 982 static int __devinit toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
 983 {
 984         acpi_status status;
 985         acpi_handle ec_handle, handle;
 986         int error;
 987         u32 hci_result;
 988
 989         dev->hotkey_dev = input_allocate_device();
 990         if (!dev->hotkey_dev) {
 991                 pr_info("Unable to register input device\n");
 992                 return -ENOMEM;
 993         }
 994
 995         dev->hotkey_dev->name = "Toshiba input device";
 996         dev->hotkey_dev->phys = "toshiba_acpi/input0";
 997         dev->hotkey_dev->id.bustype = BUS_HOST;
 998
 999         error = sparse_keymap_setup(dev->hotkey_dev, toshiba_acpi_keymap, NULL);
1000         if (error)
1001                 goto err_free_dev;
1002
1003         /*
1004          * For some machines the SCI responsible for providing hotkey
1005          * notification doesn't fire. We can trigger the notification
1006          * whenever the Fn key is pressed using the NTFY method, if
1007          * supported, so if it's present set up an i8042 key filter
1008          * for this purpose.
1009          */
1010         status = AE_ERROR;
1011         ec_handle = ec_get_handle();
1012         if (ec_handle)
1013                 status = acpi_get_handle(ec_handle, "NTFY", &handle);
1014
1015         if (ACPI_SUCCESS(status)) {
1016                 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);
1017
1018                 error = i8042_install_filter(toshiba_acpi_i8042_filter);
1019                 if (error) {
1020                         pr_err("Error installing key filter\n");
1021                         goto err_free_keymap;
1022                 }
1023
1024                 dev->ntfy_supported = 1;
1025         }
1026
1027         /*
1028          * Determine hotkey query interface. Prefer using the INFO
1029          * method when it is available.
1030          */
1031         status = acpi_get_handle(dev->acpi_dev->handle, "INFO", &handle);
1032         if (ACPI_SUCCESS(status)) {
1033                 dev->info_supported = 1;
1034         } else {
1035                 hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
1036                 if (hci_result == HCI_SUCCESS)
1037                         dev->system_event_supported = 1;
1038         }
1039
1040         if (!dev->info_supported && !dev->system_event_supported) {
1041                 pr_warn("No hotkey query interface found\n");
1042                 goto err_remove_filter;
1043         }
1044
1045         status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", NULL, NULL);
1046         if (ACPI_FAILURE(status)) {
1047                 pr_info("Unable to enable hotkeys\n");
1048                 error = -ENODEV;
1049                 goto err_remove_filter;
1050         }
1051
1052         error = input_register_device(dev->hotkey_dev);
1053         if (error) {
1054                 pr_info("Unable to register input device\n");
1055                 goto err_remove_filter;
1056         }
1057
1058         hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &hci_result);
1059         return 0;
1060
1061  err_remove_filter:
1062         if (dev->ntfy_supported)
1063                 i8042_remove_filter(toshiba_acpi_i8042_filter);
1064  err_free_keymap:
1065         sparse_keymap_free(dev->hotkey_dev);
1066  err_free_dev:
1067         input_free_device(dev->hotkey_dev);
1068         dev->hotkey_dev = NULL;
1069         return error;
1070 }
1071
1072 static int __devinit toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
1073 {
1074         struct backlight_properties props;
1075         int brightness;
1076         int ret;
1077         bool enabled;
1078
1079         /*
1080          * Some machines don't support the backlight methods at all, and
1081          * others support it read-only. Either of these is pretty useless,
1082          * so only register the backlight device if the backlight method
1083          * supports both reads and writes.
1084          */
1085         brightness = __get_lcd_brightness(dev);
1086         if (brightness < 0)
1087                 return 0;
1088         ret = set_lcd_brightness(dev, brightness);
1089         if (ret) {
1090                 pr_debug("Backlight method is read-only, disabling backlight support\n");
1091                 return 0;
1092         }
1093
1094         /* Determine whether or not BIOS supports transflective backlight */
1095         ret = get_tr_backlight_status(dev, &enabled);
1096         dev->tr_backlight_supported = !ret;
1097
1098         memset(&props, 0, sizeof(props));
1099         props.type = BACKLIGHT_PLATFORM;
1100         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
1101
1102         /* adding an extra level and having 0 change to transflective mode */
1103         if (dev->tr_backlight_supported)
1104                 props.max_brightness++;
1105
1106         dev->backlight_dev = backlight_device_register("toshiba",
1107                                                        &dev->acpi_dev->dev,
1108                                                        dev,
1109                                                        &toshiba_backlight_data,
1110                                                        &props);
1111         if (IS_ERR(dev->backlight_dev)) {
1112                 ret = PTR_ERR(dev->backlight_dev);
1113                 pr_err("Could not register toshiba backlight device\n");
1114                 dev->backlight_dev = NULL;
1115                 return ret;
1116         }
1117
1118         dev->backlight_dev->props.brightness = brightness;
1119         return 0;
1120 }
1121
1122 static int toshiba_acpi_remove(struct acpi_device *acpi_dev, int type)
1123 {
1124         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1125
1126         remove_toshiba_proc_entries(dev);
1127
1128         if (dev->ntfy_supported) {
1129                 i8042_remove_filter(toshiba_acpi_i8042_filter);
1130                 cancel_work_sync(&dev->hotkey_work);
1131         }
1132
1133         if (dev->hotkey_dev) {
1134                 input_unregister_device(dev->hotkey_dev);
1135                 sparse_keymap_free(dev->hotkey_dev);
1136         }
1137
1138         if (dev->bt_rfk) {
1139                 rfkill_unregister(dev->bt_rfk);
1140                 rfkill_destroy(dev->bt_rfk);
1141         }
1142
1143         if (dev->backlight_dev)
1144                 backlight_device_unregister(dev->backlight_dev);
1145
1146         if (dev->illumination_supported)
1147                 led_classdev_unregister(&dev->led_dev);
1148
1149         if (toshiba_acpi)
1150                 toshiba_acpi = NULL;
1151
1152         kfree(dev);
1153
1154         return 0;
1155 }
1156
1157 static const char * __devinit find_hci_method(acpi_handle handle)
1158 {
1159         acpi_status status;
1160         acpi_handle hci_handle;
1161
1162         status = acpi_get_handle(handle, "GHCI", &hci_handle);
1163         if (ACPI_SUCCESS(status))
1164                 return "GHCI";
1165
1166         status = acpi_get_handle(handle, "SPFC", &hci_handle);
1167         if (ACPI_SUCCESS(status))
1168                 return "SPFC";
1169
1170         return NULL;
1171 }
1172
1173 static int __devinit toshiba_acpi_add(struct acpi_device *acpi_dev)
1174 {
1175         struct toshiba_acpi_dev *dev;
1176         const char *hci_method;
1177         u32 dummy;
1178         bool bt_present;
1179         int ret = 0;
1180
1181         if (toshiba_acpi)
1182                 return -EBUSY;
1183
1184         pr_info("Toshiba Laptop ACPI Extras version %s\n",
1185                TOSHIBA_ACPI_VERSION);
1186
1187         hci_method = find_hci_method(acpi_dev->handle);
1188         if (!hci_method) {
1189                 pr_err("HCI interface not found\n");
1190                 return -ENODEV;
1191         }
1192
1193         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1194         if (!dev)
1195                 return -ENOMEM;
1196         dev->acpi_dev = acpi_dev;
1197         dev->method_hci = hci_method;
1198         acpi_dev->driver_data = dev;
1199
1200         if (toshiba_acpi_setup_keyboard(dev))
1201                 pr_info("Unable to activate hotkeys\n");
1202
1203         mutex_init(&dev->mutex);
1204
1205         ret = toshiba_acpi_setup_backlight(dev);
1206         if (ret)
1207                 goto error;
1208
1209         /* Register rfkill switch for Bluetooth */
1210         if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) {
1211                 dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth",
1212                                            &acpi_dev->dev,
1213                                            RFKILL_TYPE_BLUETOOTH,
1214                                            &toshiba_rfk_ops,
1215                                            dev);
1216                 if (!dev->bt_rfk) {
1217                         pr_err("unable to allocate rfkill device\n");
1218                         ret = -ENOMEM;
1219                         goto error;
1220                 }
1221
1222                 ret = rfkill_register(dev->bt_rfk);
1223                 if (ret) {
1224                         pr_err("unable to register rfkill device\n");
1225                         rfkill_destroy(dev->bt_rfk);
1226                         goto error;
1227                 }
1228         }
1229
1230         if (toshiba_illumination_available(dev)) {
1231                 dev->led_dev.name = "toshiba::illumination";
1232                 dev->led_dev.max_brightness = 1;
1233                 dev->led_dev.brightness_set = toshiba_illumination_set;
1234                 dev->led_dev.brightness_get = toshiba_illumination_get;
1235                 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
1236                         dev->illumination_supported = 1;
1237         }
1238
1239         /* Determine whether or not BIOS supports fan and video interfaces */
1240
1241         ret = get_video_status(dev, &dummy);
1242         dev->video_supported = !ret;
1243
1244         ret = get_fan_status(dev, &dummy);
1245         dev->fan_supported = !ret;
1246
1247         create_toshiba_proc_entries(dev);
1248
1249         toshiba_acpi = dev;
1250
1251         return 0;
1252
1253 error:
1254         toshiba_acpi_remove(acpi_dev, 0);
1255         return ret;
1256 }
1257
1258 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
1259 {
1260         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1261         u32 hci_result, value;
1262         int retries = 3;
1263         int scancode;
1264
1265         if (event != 0x80)
1266                 return;
1267
1268         if (dev->info_supported) {
1269                 scancode = toshiba_acpi_query_hotkey(dev);
1270                 if (scancode < 0)
1271                         pr_err("Failed to query hotkey event\n");
1272                 else if (scancode != 0)
1273                         toshiba_acpi_report_hotkey(dev, scancode);
1274         } else if (dev->system_event_supported) {
1275                 do {
1276                         hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
1277                         switch (hci_result) {
1278                         case HCI_SUCCESS:
1279                                 toshiba_acpi_report_hotkey(dev, (int)value);
1280                                 break;
1281                         case HCI_NOT_SUPPORTED:
1282                                 /*
1283                                  * This is a workaround for an unresolved
1284                                  * issue on some machines where system events
1285                                  * sporadically become disabled.
1286                                  */
1287                                 hci_write1(dev, HCI_SYSTEM_EVENT, 1,
1288                                            &hci_result);
1289                                 pr_notice("Re-enabled hotkeys\n");
1290                                 /* fall through */
1291                         default:
1292                                 retries--;
1293                                 break;
1294                         }
1295                 } while (retries && hci_result != HCI_EMPTY);
1296         }
1297 }
1298
1299 #ifdef CONFIG_PM_SLEEP
1300 static int toshiba_acpi_suspend(struct device *device)
1301 {
1302         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1303         u32 result;
1304
1305         if (dev->hotkey_dev)
1306                 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE, &result);
1307
1308         return 0;
1309 }
1310
1311 static int toshiba_acpi_resume(struct device *device)
1312 {
1313         struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
1314         u32 result;
1315
1316         if (dev->hotkey_dev)
1317                 hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &result);
1318
1319         return 0;
1320 }
1321 #endif
1322
1323 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
1324                          toshiba_acpi_suspend, toshiba_acpi_resume);
1325
1326 static struct acpi_driver toshiba_acpi_driver = {
1327         .name   = "Toshiba ACPI driver",
1328         .owner  = THIS_MODULE,
1329         .ids    = toshiba_device_ids,
1330         .flags  = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1331         .ops    = {
1332                 .add            = toshiba_acpi_add,
1333                 .remove         = toshiba_acpi_remove,
1334                 .notify         = toshiba_acpi_notify,
1335         },
1336         .drv.pm = &toshiba_acpi_pm,
1337 };
1338
1339 static int __init toshiba_acpi_init(void)
1340 {
1341         int ret;
1342
1343         /*
1344          * Machines with this WMI guid aren't supported due to bugs in
1345          * their AML. This check relies on wmi initializing before
1346          * toshiba_acpi to guarantee guids have been identified.
1347          */
1348         if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
1349                 return -ENODEV;
1350
1351         toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
1352         if (!toshiba_proc_dir) {
1353                 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
1354                 return -ENODEV;
1355         }
1356
1357         ret = acpi_bus_register_driver(&toshiba_acpi_driver);
1358         if (ret) {
1359                 pr_err("Failed to register ACPI driver: %d\n", ret);
1360                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1361         }
1362
1363         return ret;
1364 }
1365
1366 static void __exit toshiba_acpi_exit(void)
1367 {
1368         acpi_bus_unregister_driver(&toshiba_acpi_driver);
1369         if (toshiba_proc_dir)
1370                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1371 }
1372
1373 module_init(toshiba_acpi_init);
1374 module_exit(toshiba_acpi_exit);