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
  56 #include <asm/uaccess.h>
  57
  58 #include <acpi/acpi_drivers.h>
  59
  60 MODULE_AUTHOR("John Belmonte");
  61 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
  62 MODULE_LICENSE("GPL");
  63
  64 /* Toshiba ACPI method paths */
  65 #define METHOD_VIDEO_OUT        "\\_SB_.VALX.DSSX"
  66
  67 /* Toshiba HCI interface definitions
  68  *
  69  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
  70  * be uniform across all their models.  Ideally we would just call
  71  * dedicated ACPI methods instead of using this primitive interface.
  72  * However the ACPI methods seem to be incomplete in some areas (for
  73  * example they allow setting, but not reading, the LCD brightness value),
  74  * so this is still useful.
  75  */
  76
  77 #define HCI_WORDS                       6
  78
  79 /* operations */
  80 #define HCI_SET                         0xff00
  81 #define HCI_GET                         0xfe00
  82
  83 /* return codes */
  84 #define HCI_SUCCESS                     0x0000
  85 #define HCI_FAILURE                     0x1000
  86 #define HCI_NOT_SUPPORTED               0x8000
  87 #define HCI_EMPTY                       0x8c00
  88
  89 /* registers */
  90 #define HCI_FAN                         0x0004
  91 #define HCI_SYSTEM_EVENT                0x0016
  92 #define HCI_VIDEO_OUT                   0x001c
  93 #define HCI_HOTKEY_EVENT                0x001e
  94 #define HCI_LCD_BRIGHTNESS              0x002a
  95 #define HCI_WIRELESS                    0x0056
  96
  97 /* field definitions */
  98 #define HCI_LCD_BRIGHTNESS_BITS         3
  99 #define HCI_LCD_BRIGHTNESS_SHIFT        (16-HCI_LCD_BRIGHTNESS_BITS)
 100 #define HCI_LCD_BRIGHTNESS_LEVELS       (1 << HCI_LCD_BRIGHTNESS_BITS)
 101 #define HCI_VIDEO_OUT_LCD               0x1
 102 #define HCI_VIDEO_OUT_CRT               0x2
 103 #define HCI_VIDEO_OUT_TV                0x4
 104 #define HCI_WIRELESS_KILL_SWITCH        0x01
 105 #define HCI_WIRELESS_BT_PRESENT         0x0f
 106 #define HCI_WIRELESS_BT_ATTACH          0x40
 107 #define HCI_WIRELESS_BT_POWER           0x80
 108
 109 struct toshiba_acpi_dev {
 110         struct acpi_device *acpi_dev;
 111         const char *method_hci;
 112         struct rfkill *bt_rfk;
 113         struct input_dev *hotkey_dev;
 114         struct backlight_device *backlight_dev;
 115         struct led_classdev led_dev;
 116
 117         int force_fan;
 118         int last_key_event;
 119         int key_event_valid;
 120
 121         int illumination_supported:1;
 122         int video_supported:1;
 123         int fan_supported:1;
 124
 125         struct mutex mutex;
 126 };
 127
 128 static const struct acpi_device_id toshiba_device_ids[] = {
 129         {"TOS6200", 0},
 130         {"TOS6208", 0},
 131         {"TOS1900", 0},
 132         {"", 0},
 133 };
 134 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);
 135
 136 static const struct key_entry toshiba_acpi_keymap[] __devinitconst = {
 137         { KE_KEY, 0x101, { KEY_MUTE } },
 138         { KE_KEY, 0x102, { KEY_ZOOMOUT } },
 139         { KE_KEY, 0x103, { KEY_ZOOMIN } },
 140         { KE_KEY, 0x13b, { KEY_COFFEE } },
 141         { KE_KEY, 0x13c, { KEY_BATTERY } },
 142         { KE_KEY, 0x13d, { KEY_SLEEP } },
 143         { KE_KEY, 0x13e, { KEY_SUSPEND } },
 144         { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
 145         { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
 146         { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
 147         { KE_KEY, 0x142, { KEY_WLAN } },
 148         { KE_KEY, 0x143, { KEY_PROG1 } },
 149         { KE_KEY, 0x17f, { KEY_FN } },
 150         { KE_KEY, 0xb05, { KEY_PROG2 } },
 151         { KE_KEY, 0xb06, { KEY_WWW } },
 152         { KE_KEY, 0xb07, { KEY_MAIL } },
 153         { KE_KEY, 0xb30, { KEY_STOP } },
 154         { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
 155         { KE_KEY, 0xb32, { KEY_NEXTSONG } },
 156         { KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
 157         { KE_KEY, 0xb5a, { KEY_MEDIA } },
 158         { KE_END, 0 },
 159 };
 160
 161 /* utility
 162  */
 163
 164 static __inline__ void _set_bit(u32 * word, u32 mask, int value)
 165 {
 166         *word = (*word & ~mask) | (mask * value);
 167 }
 168
 169 /* acpi interface wrappers
 170  */
 171
 172 static int write_acpi_int(const char *methodName, int val)
 173 {
 174         struct acpi_object_list params;
 175         union acpi_object in_objs[1];
 176         acpi_status status;
 177
 178         params.count = ARRAY_SIZE(in_objs);
 179         params.pointer = in_objs;
 180         in_objs[0].type = ACPI_TYPE_INTEGER;
 181         in_objs[0].integer.value = val;
 182
 183         status = acpi_evaluate_object(NULL, (char *)methodName, &params, NULL);
 184         return (status == AE_OK) ? 0 : -EIO;
 185 }
 186
 187 /* Perform a raw HCI call.  Here we don't care about input or output buffer
 188  * format.
 189  */
 190 static acpi_status hci_raw(struct toshiba_acpi_dev *dev,
 191                            const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
 192 {
 193         struct acpi_object_list params;
 194         union acpi_object in_objs[HCI_WORDS];
 195         struct acpi_buffer results;
 196         union acpi_object out_objs[HCI_WORDS + 1];
 197         acpi_status status;
 198         int i;
 199
 200         params.count = HCI_WORDS;
 201         params.pointer = in_objs;
 202         for (i = 0; i < HCI_WORDS; ++i) {
 203                 in_objs[i].type = ACPI_TYPE_INTEGER;
 204                 in_objs[i].integer.value = in[i];
 205         }
 206
 207         results.length = sizeof(out_objs);
 208         results.pointer = out_objs;
 209
 210         status = acpi_evaluate_object(dev->acpi_dev->handle,
 211                                       (char *)dev->method_hci, &params,
 212                                       &results);
 213         if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
 214                 for (i = 0; i < out_objs->package.count; ++i) {
 215                         out[i] = out_objs->package.elements[i].integer.value;
 216                 }
 217         }
 218
 219         return status;
 220 }
 221
 222 /* common hci tasks (get or set one or two value)
 223  *
 224  * In addition to the ACPI status, the HCI system returns a result which
 225  * may be useful (such as "not supported").
 226  */
 227
 228 static acpi_status hci_write1(struct toshiba_acpi_dev *dev, u32 reg,
 229                               u32 in1, u32 *result)
 230 {
 231         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
 232         u32 out[HCI_WORDS];
 233         acpi_status status = hci_raw(dev, in, out);
 234         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 235         return status;
 236 }
 237
 238 static acpi_status hci_read1(struct toshiba_acpi_dev *dev, u32 reg,
 239                              u32 *out1, u32 *result)
 240 {
 241         u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
 242         u32 out[HCI_WORDS];
 243         acpi_status status = hci_raw(dev, in, out);
 244         *out1 = out[2];
 245         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 246         return status;
 247 }
 248
 249 static acpi_status hci_write2(struct toshiba_acpi_dev *dev, u32 reg,
 250                               u32 in1, u32 in2, u32 *result)
 251 {
 252         u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
 253         u32 out[HCI_WORDS];
 254         acpi_status status = hci_raw(dev, in, out);
 255         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 256         return status;
 257 }
 258
 259 static acpi_status hci_read2(struct toshiba_acpi_dev *dev, u32 reg,
 260                              u32 *out1, u32 *out2, u32 *result)
 261 {
 262         u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
 263         u32 out[HCI_WORDS];
 264         acpi_status status = hci_raw(dev, in, out);
 265         *out1 = out[2];
 266         *out2 = out[3];
 267         *result = (status == AE_OK) ? out[0] : HCI_FAILURE;
 268         return status;
 269 }
 270
 271 /* Illumination support */
 272 static int toshiba_illumination_available(struct toshiba_acpi_dev *dev)
 273 {
 274         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
 275         u32 out[HCI_WORDS];
 276         acpi_status status;
 277
 278         in[0] = 0xf100;
 279         status = hci_raw(dev, in, out);
 280         if (ACPI_FAILURE(status)) {
 281                 pr_info("Illumination device not available\n");
 282                 return 0;
 283         }
 284         in[0] = 0xf400;
 285         status = hci_raw(dev, in, out);
 286         return 1;
 287 }
 288
 289 static void toshiba_illumination_set(struct led_classdev *cdev,
 290                                      enum led_brightness brightness)
 291 {
 292         struct toshiba_acpi_dev *dev = container_of(cdev,
 293                         struct toshiba_acpi_dev, led_dev);
 294         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
 295         u32 out[HCI_WORDS];
 296         acpi_status status;
 297
 298         /* First request : initialize communication. */
 299         in[0] = 0xf100;
 300         status = hci_raw(dev, in, out);
 301         if (ACPI_FAILURE(status)) {
 302                 pr_info("Illumination device not available\n");
 303                 return;
 304         }
 305
 306         if (brightness) {
 307                 /* Switch the illumination on */
 308                 in[0] = 0xf400;
 309                 in[1] = 0x14e;
 310                 in[2] = 1;
 311                 status = hci_raw(dev, in, out);
 312                 if (ACPI_FAILURE(status)) {
 313                         pr_info("ACPI call for illumination failed\n");
 314                         return;
 315                 }
 316         } else {
 317                 /* Switch the illumination off */
 318                 in[0] = 0xf400;
 319                 in[1] = 0x14e;
 320                 in[2] = 0;
 321                 status = hci_raw(dev, in, out);
 322                 if (ACPI_FAILURE(status)) {
 323                         pr_info("ACPI call for illumination failed.\n");
 324                         return;
 325                 }
 326         }
 327
 328         /* Last request : close communication. */
 329         in[0] = 0xf200;
 330         in[1] = 0;
 331         in[2] = 0;
 332         hci_raw(dev, in, out);
 333 }
 334
 335 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
 336 {
 337         struct toshiba_acpi_dev *dev = container_of(cdev,
 338                         struct toshiba_acpi_dev, led_dev);
 339         u32 in[HCI_WORDS] = { 0, 0, 0, 0, 0, 0 };
 340         u32 out[HCI_WORDS];
 341         acpi_status status;
 342         enum led_brightness result;
 343
 344         /* First request : initialize communication. */
 345         in[0] = 0xf100;
 346         status = hci_raw(dev, in, out);
 347         if (ACPI_FAILURE(status)) {
 348                 pr_info("Illumination device not available\n");
 349                 return LED_OFF;
 350         }
 351
 352         /* Check the illumination */
 353         in[0] = 0xf300;
 354         in[1] = 0x14e;
 355         status = hci_raw(dev, in, out);
 356         if (ACPI_FAILURE(status)) {
 357                 pr_info("ACPI call for illumination failed.\n");
 358                 return LED_OFF;
 359         }
 360
 361         result = out[2] ? LED_FULL : LED_OFF;
 362
 363         /* Last request : close communication. */
 364         in[0] = 0xf200;
 365         in[1] = 0;
 366         in[2] = 0;
 367         hci_raw(dev, in, out);
 368
 369         return result;
 370 }
 371
 372 /* Bluetooth rfkill handlers */
 373
 374 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
 375 {
 376         u32 hci_result;
 377         u32 value, value2;
 378
 379         value = 0;
 380         value2 = 0;
 381         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
 382         if (hci_result == HCI_SUCCESS)
 383                 *present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;
 384
 385         return hci_result;
 386 }
 387
 388 static u32 hci_get_radio_state(struct toshiba_acpi_dev *dev, bool *radio_state)
 389 {
 390         u32 hci_result;
 391         u32 value, value2;
 392
 393         value = 0;
 394         value2 = 0x0001;
 395         hci_read2(dev, HCI_WIRELESS, &value, &value2, &hci_result);
 396
 397         *radio_state = value & HCI_WIRELESS_KILL_SWITCH;
 398         return hci_result;
 399 }
 400
 401 static int bt_rfkill_set_block(void *data, bool blocked)
 402 {
 403         struct toshiba_acpi_dev *dev = data;
 404         u32 result1, result2;
 405         u32 value;
 406         int err;
 407         bool radio_state;
 408
 409         value = (blocked == false);
 410
 411         mutex_lock(&dev->mutex);
 412         if (hci_get_radio_state(dev, &radio_state) != HCI_SUCCESS) {
 413                 err = -EIO;
 414                 goto out;
 415         }
 416
 417         if (!radio_state) {
 418                 err = 0;
 419                 goto out;
 420         }
 421
 422         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
 423         hci_write2(dev, HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);
 424
 425         if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
 426                 err = -EIO;
 427         else
 428                 err = 0;
 429  out:
 430         mutex_unlock(&dev->mutex);
 431         return err;
 432 }
 433
 434 static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
 435 {
 436         bool new_rfk_state;
 437         bool value;
 438         u32 hci_result;
 439         struct toshiba_acpi_dev *dev = data;
 440
 441         mutex_lock(&dev->mutex);
 442
 443         hci_result = hci_get_radio_state(dev, &value);
 444         if (hci_result != HCI_SUCCESS) {
 445                 /* Can't do anything useful */
 446                 mutex_unlock(&dev->mutex);
 447                 return;
 448         }
 449
 450         new_rfk_state = value;
 451
 452         mutex_unlock(&dev->mutex);
 453
 454         if (rfkill_set_hw_state(rfkill, !new_rfk_state))
 455                 bt_rfkill_set_block(data, true);
 456 }
 457
 458 static const struct rfkill_ops toshiba_rfk_ops = {
 459         .set_block = bt_rfkill_set_block,
 460         .poll = bt_rfkill_poll,
 461 };
 462
 463 static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
 464
 465 static int get_lcd(struct backlight_device *bd)
 466 {
 467         struct toshiba_acpi_dev *dev = bl_get_data(bd);
 468         u32 hci_result;
 469         u32 value;
 470
 471         hci_read1(dev, HCI_LCD_BRIGHTNESS, &value, &hci_result);
 472         if (hci_result == HCI_SUCCESS)
 473                 return (value >> HCI_LCD_BRIGHTNESS_SHIFT);
 474
 475         return -EIO;
 476 }
 477
 478 static int lcd_proc_show(struct seq_file *m, void *v)
 479 {
 480         struct toshiba_acpi_dev *dev = m->private;
 481         int value;
 482
 483         if (!dev->backlight_dev)
 484                 return -ENODEV;
 485
 486         value = get_lcd(dev->backlight_dev);
 487         if (value >= 0) {
 488                 seq_printf(m, "brightness:              %d\n", value);
 489                 seq_printf(m, "brightness_levels:       %d\n",
 490                              HCI_LCD_BRIGHTNESS_LEVELS);
 491                 return 0;
 492         }
 493
 494         pr_err("Error reading LCD brightness\n");
 495         return -EIO;
 496 }
 497
 498 static int lcd_proc_open(struct inode *inode, struct file *file)
 499 {
 500         return single_open(file, lcd_proc_show, PDE(inode)->data);
 501 }
 502
 503 static int set_lcd(struct toshiba_acpi_dev *dev, int value)
 504 {
 505         u32 hci_result;
 506
 507         value = value << HCI_LCD_BRIGHTNESS_SHIFT;
 508         hci_write1(dev, HCI_LCD_BRIGHTNESS, value, &hci_result);
 509         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 510 }
 511
 512 static int set_lcd_status(struct backlight_device *bd)
 513 {
 514         struct toshiba_acpi_dev *dev = bl_get_data(bd);
 515         return set_lcd(dev, bd->props.brightness);
 516 }
 517
 518 static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
 519                               size_t count, loff_t *pos)
 520 {
 521         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 522         char cmd[42];
 523         size_t len;
 524         int value;
 525         int ret;
 526
 527         len = min(count, sizeof(cmd) - 1);
 528         if (copy_from_user(cmd, buf, len))
 529                 return -EFAULT;
 530         cmd[len] = '\0';
 531
 532         if (sscanf(cmd, " brightness : %i", &value) == 1 &&
 533             value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS) {
 534                 ret = set_lcd(dev, value);
 535                 if (ret == 0)
 536                         ret = count;
 537         } else {
 538                 ret = -EINVAL;
 539         }
 540         return ret;
 541 }
 542
 543 static const struct file_operations lcd_proc_fops = {
 544         .owner          = THIS_MODULE,
 545         .open           = lcd_proc_open,
 546         .read           = seq_read,
 547         .llseek         = seq_lseek,
 548         .release        = single_release,
 549         .write          = lcd_proc_write,
 550 };
 551
 552 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
 553 {
 554         u32 hci_result;
 555
 556         hci_read1(dev, HCI_VIDEO_OUT, status, &hci_result);
 557         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 558 }
 559
 560 static int video_proc_show(struct seq_file *m, void *v)
 561 {
 562         struct toshiba_acpi_dev *dev = m->private;
 563         u32 value;
 564         int ret;
 565
 566         ret = get_video_status(dev, &value);
 567         if (!ret) {
 568                 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
 569                 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
 570                 int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
 571                 seq_printf(m, "lcd_out:                 %d\n", is_lcd);
 572                 seq_printf(m, "crt_out:                 %d\n", is_crt);
 573                 seq_printf(m, "tv_out:                  %d\n", is_tv);
 574         }
 575
 576         return ret;
 577 }
 578
 579 static int video_proc_open(struct inode *inode, struct file *file)
 580 {
 581         return single_open(file, video_proc_show, PDE(inode)->data);
 582 }
 583
 584 static ssize_t video_proc_write(struct file *file, const char __user *buf,
 585                                 size_t count, loff_t *pos)
 586 {
 587         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 588         char *cmd, *buffer;
 589         int ret;
 590         int value;
 591         int remain = count;
 592         int lcd_out = -1;
 593         int crt_out = -1;
 594         int tv_out = -1;
 595         u32 video_out;
 596
 597         cmd = kmalloc(count + 1, GFP_KERNEL);
 598         if (!cmd)
 599                 return -ENOMEM;
 600         if (copy_from_user(cmd, buf, count)) {
 601                 kfree(cmd);
 602                 return -EFAULT;
 603         }
 604         cmd[count] = '\0';
 605
 606         buffer = cmd;
 607
 608         /* scan expression.  Multiple expressions may be delimited with ;
 609          *
 610          *  NOTE: to keep scanning simple, invalid fields are ignored
 611          */
 612         while (remain) {
 613                 if (sscanf(buffer, " lcd_out : %i", &value) == 1)
 614                         lcd_out = value & 1;
 615                 else if (sscanf(buffer, " crt_out : %i", &value) == 1)
 616                         crt_out = value & 1;
 617                 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
 618                         tv_out = value & 1;
 619                 /* advance to one character past the next ; */
 620                 do {
 621                         ++buffer;
 622                         --remain;
 623                 }
 624                 while (remain && *(buffer - 1) != ';');
 625         }
 626
 627         kfree(cmd);
 628
 629         ret = get_video_status(dev, &video_out);
 630         if (!ret) {
 631                 unsigned int new_video_out = video_out;
 632                 if (lcd_out != -1)
 633                         _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
 634                 if (crt_out != -1)
 635                         _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
 636                 if (tv_out != -1)
 637                         _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
 638                 /* To avoid unnecessary video disruption, only write the new
 639                  * video setting if something changed. */
 640                 if (new_video_out != video_out)
 641                         ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
 642         }
 643
 644         return ret ? ret : count;
 645 }
 646
 647 static const struct file_operations video_proc_fops = {
 648         .owner          = THIS_MODULE,
 649         .open           = video_proc_open,
 650         .read           = seq_read,
 651         .llseek         = seq_lseek,
 652         .release        = single_release,
 653         .write          = video_proc_write,
 654 };
 655
 656 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
 657 {
 658         u32 hci_result;
 659
 660         hci_read1(dev, HCI_FAN, status, &hci_result);
 661         return hci_result == HCI_SUCCESS ? 0 : -EIO;
 662 }
 663
 664 static int fan_proc_show(struct seq_file *m, void *v)
 665 {
 666         struct toshiba_acpi_dev *dev = m->private;
 667         int ret;
 668         u32 value;
 669
 670         ret = get_fan_status(dev, &value);
 671         if (!ret) {
 672                 seq_printf(m, "running:                 %d\n", (value > 0));
 673                 seq_printf(m, "force_on:                %d\n", dev->force_fan);
 674         }
 675
 676         return ret;
 677 }
 678
 679 static int fan_proc_open(struct inode *inode, struct file *file)
 680 {
 681         return single_open(file, fan_proc_show, PDE(inode)->data);
 682 }
 683
 684 static ssize_t fan_proc_write(struct file *file, const char __user *buf,
 685                               size_t count, loff_t *pos)
 686 {
 687         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 688         char cmd[42];
 689         size_t len;
 690         int value;
 691         u32 hci_result;
 692
 693         len = min(count, sizeof(cmd) - 1);
 694         if (copy_from_user(cmd, buf, len))
 695                 return -EFAULT;
 696         cmd[len] = '\0';
 697
 698         if (sscanf(cmd, " force_on : %i", &value) == 1 &&
 699             value >= 0 && value <= 1) {
 700                 hci_write1(dev, HCI_FAN, value, &hci_result);
 701                 if (hci_result != HCI_SUCCESS)
 702                         return -EIO;
 703                 else
 704                         dev->force_fan = value;
 705         } else {
 706                 return -EINVAL;
 707         }
 708
 709         return count;
 710 }
 711
 712 static const struct file_operations fan_proc_fops = {
 713         .owner          = THIS_MODULE,
 714         .open           = fan_proc_open,
 715         .read           = seq_read,
 716         .llseek         = seq_lseek,
 717         .release        = single_release,
 718         .write          = fan_proc_write,
 719 };
 720
 721 static int keys_proc_show(struct seq_file *m, void *v)
 722 {
 723         struct toshiba_acpi_dev *dev = m->private;
 724         u32 hci_result;
 725         u32 value;
 726
 727         if (!dev->key_event_valid) {
 728                 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
 729                 if (hci_result == HCI_SUCCESS) {
 730                         dev->key_event_valid = 1;
 731                         dev->last_key_event = value;
 732                 } else if (hci_result == HCI_EMPTY) {
 733                         /* better luck next time */
 734                 } else if (hci_result == HCI_NOT_SUPPORTED) {
 735                         /* This is a workaround for an unresolved issue on
 736                          * some machines where system events sporadically
 737                          * become disabled. */
 738                         hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
 739                         pr_notice("Re-enabled hotkeys\n");
 740                 } else {
 741                         pr_err("Error reading hotkey status\n");
 742                         return -EIO;
 743                 }
 744         }
 745
 746         seq_printf(m, "hotkey_ready:            %d\n", dev->key_event_valid);
 747         seq_printf(m, "hotkey:                  0x%04x\n", dev->last_key_event);
 748         return 0;
 749 }
 750
 751 static int keys_proc_open(struct inode *inode, struct file *file)
 752 {
 753         return single_open(file, keys_proc_show, PDE(inode)->data);
 754 }
 755
 756 static ssize_t keys_proc_write(struct file *file, const char __user *buf,
 757                                size_t count, loff_t *pos)
 758 {
 759         struct toshiba_acpi_dev *dev = PDE(file->f_path.dentry->d_inode)->data;
 760         char cmd[42];
 761         size_t len;
 762         int value;
 763
 764         len = min(count, sizeof(cmd) - 1);
 765         if (copy_from_user(cmd, buf, len))
 766                 return -EFAULT;
 767         cmd[len] = '\0';
 768
 769         if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
 770                 dev->key_event_valid = 0;
 771         } else {
 772                 return -EINVAL;
 773         }
 774
 775         return count;
 776 }
 777
 778 static const struct file_operations keys_proc_fops = {
 779         .owner          = THIS_MODULE,
 780         .open           = keys_proc_open,
 781         .read           = seq_read,
 782         .llseek         = seq_lseek,
 783         .release        = single_release,
 784         .write          = keys_proc_write,
 785 };
 786
 787 static int version_proc_show(struct seq_file *m, void *v)
 788 {
 789         seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
 790         seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
 791         return 0;
 792 }
 793
 794 static int version_proc_open(struct inode *inode, struct file *file)
 795 {
 796         return single_open(file, version_proc_show, PDE(inode)->data);
 797 }
 798
 799 static const struct file_operations version_proc_fops = {
 800         .owner          = THIS_MODULE,
 801         .open           = version_proc_open,
 802         .read           = seq_read,
 803         .llseek         = seq_lseek,
 804         .release        = single_release,
 805 };
 806
 807 /* proc and module init
 808  */
 809
 810 #define PROC_TOSHIBA            "toshiba"
 811
 812 static void __devinit
 813 create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
 814 {
 815         if (dev->backlight_dev)
 816                 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 817                                  &lcd_proc_fops, dev);
 818         if (dev->video_supported)
 819                 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 820                                  &video_proc_fops, dev);
 821         if (dev->fan_supported)
 822                 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 823                                  &fan_proc_fops, dev);
 824         if (dev->hotkey_dev)
 825                 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
 826                                  &keys_proc_fops, dev);
 827         proc_create_data("version", S_IRUGO, toshiba_proc_dir,
 828                          &version_proc_fops, dev);
 829 }
 830
 831 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
 832 {
 833         if (dev->backlight_dev)
 834                 remove_proc_entry("lcd", toshiba_proc_dir);
 835         if (dev->video_supported)
 836                 remove_proc_entry("video", toshiba_proc_dir);
 837         if (dev->fan_supported)
 838                 remove_proc_entry("fan", toshiba_proc_dir);
 839         if (dev->hotkey_dev)
 840                 remove_proc_entry("keys", toshiba_proc_dir);
 841         remove_proc_entry("version", toshiba_proc_dir);
 842 }
 843
 844 static const struct backlight_ops toshiba_backlight_data = {
 845         .get_brightness = get_lcd,
 846         .update_status  = set_lcd_status,
 847 };
 848
 849 static int __devinit toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
 850 {
 851         acpi_status status;
 852         int error;
 853
 854         dev->hotkey_dev = input_allocate_device();
 855         if (!dev->hotkey_dev) {
 856                 pr_info("Unable to register input device\n");
 857                 return -ENOMEM;
 858         }
 859
 860         dev->hotkey_dev->name = "Toshiba input device";
 861         dev->hotkey_dev->phys = "toshiba_acpi/input0";
 862         dev->hotkey_dev->id.bustype = BUS_HOST;
 863
 864         error = sparse_keymap_setup(dev->hotkey_dev, toshiba_acpi_keymap, NULL);
 865         if (error)
 866                 goto err_free_dev;
 867
 868         status = acpi_evaluate_object(dev->acpi_dev->handle, "ENAB", NULL, NULL);
 869         if (ACPI_FAILURE(status)) {
 870                 pr_info("Unable to enable hotkeys\n");
 871                 error = -ENODEV;
 872                 goto err_free_keymap;
 873         }
 874
 875         error = input_register_device(dev->hotkey_dev);
 876         if (error) {
 877                 pr_info("Unable to register input device\n");
 878                 goto err_free_keymap;
 879         }
 880
 881         return 0;
 882
 883  err_free_keymap:
 884         sparse_keymap_free(dev->hotkey_dev);
 885  err_free_dev:
 886         input_free_device(dev->hotkey_dev);
 887         dev->hotkey_dev = NULL;
 888         return error;
 889 }
 890
 891 static int toshiba_acpi_remove(struct acpi_device *acpi_dev, int type)
 892 {
 893         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
 894
 895         remove_toshiba_proc_entries(dev);
 896
 897         if (dev->hotkey_dev) {
 898                 input_unregister_device(dev->hotkey_dev);
 899                 sparse_keymap_free(dev->hotkey_dev);
 900         }
 901
 902         if (dev->bt_rfk) {
 903                 rfkill_unregister(dev->bt_rfk);
 904                 rfkill_destroy(dev->bt_rfk);
 905         }
 906
 907         if (dev->backlight_dev)
 908                 backlight_device_unregister(dev->backlight_dev);
 909
 910         if (dev->illumination_supported)
 911                 led_classdev_unregister(&dev->led_dev);
 912
 913         kfree(dev);
 914
 915         return 0;
 916 }
 917
 918 static const char * __devinit find_hci_method(acpi_handle handle)
 919 {
 920         acpi_status status;
 921         acpi_handle hci_handle;
 922
 923         status = acpi_get_handle(handle, "GHCI", &hci_handle);
 924         if (ACPI_SUCCESS(status))
 925                 return "GHCI";
 926
 927         status = acpi_get_handle(handle, "SPFC", &hci_handle);
 928         if (ACPI_SUCCESS(status))
 929                 return "SPFC";
 930
 931         return NULL;
 932 }
 933
 934 static int __devinit toshiba_acpi_add(struct acpi_device *acpi_dev)
 935 {
 936         struct toshiba_acpi_dev *dev;
 937         const char *hci_method;
 938         u32 hci_result;
 939         u32 dummy;
 940         bool bt_present;
 941         int ret = 0;
 942         struct backlight_properties props;
 943
 944         pr_info("Toshiba Laptop ACPI Extras version %s\n",
 945                TOSHIBA_ACPI_VERSION);
 946
 947         hci_method = find_hci_method(acpi_dev->handle);
 948         if (!hci_method) {
 949                 pr_err("HCI interface not found\n");
 950                 return -ENODEV;
 951         }
 952
 953         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 954         if (!dev)
 955                 return -ENOMEM;
 956         dev->acpi_dev = acpi_dev;
 957         dev->method_hci = hci_method;
 958         acpi_dev->driver_data = dev;
 959
 960         if (toshiba_acpi_setup_keyboard(dev))
 961                 pr_info("Unable to activate hotkeys\n");
 962
 963         mutex_init(&dev->mutex);
 964
 965         /* enable event fifo */
 966         hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
 967
 968         props.type = BACKLIGHT_PLATFORM;
 969         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
 970         dev->backlight_dev = backlight_device_register("toshiba",
 971                                                        &acpi_dev->dev,
 972                                                        dev,
 973                                                        &toshiba_backlight_data,
 974                                                        &props);
 975         if (IS_ERR(dev->backlight_dev)) {
 976                 ret = PTR_ERR(dev->backlight_dev);
 977
 978                 pr_err("Could not register toshiba backlight device\n");
 979                 dev->backlight_dev = NULL;
 980                 goto error;
 981         }
 982         dev->backlight_dev->props.brightness = get_lcd(dev->backlight_dev);
 983
 984         /* Register rfkill switch for Bluetooth */
 985         if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) {
 986                 dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth",
 987                                            &acpi_dev->dev,
 988                                            RFKILL_TYPE_BLUETOOTH,
 989                                            &toshiba_rfk_ops,
 990                                            dev);
 991                 if (!dev->bt_rfk) {
 992                         pr_err("unable to allocate rfkill device\n");
 993                         ret = -ENOMEM;
 994                         goto error;
 995                 }
 996
 997                 ret = rfkill_register(dev->bt_rfk);
 998                 if (ret) {
 999                         pr_err("unable to register rfkill device\n");
1000                         rfkill_destroy(dev->bt_rfk);
1001                         goto error;
1002                 }
1003         }
1004
1005         if (toshiba_illumination_available(dev)) {
1006                 dev->led_dev.name = "toshiba::illumination";
1007                 dev->led_dev.max_brightness = 1;
1008                 dev->led_dev.brightness_set = toshiba_illumination_set;
1009                 dev->led_dev.brightness_get = toshiba_illumination_get;
1010                 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
1011                         dev->illumination_supported = 1;
1012         }
1013
1014         /* Determine whether or not BIOS supports fan and video interfaces */
1015
1016         ret = get_video_status(dev, &dummy);
1017         dev->video_supported = !ret;
1018
1019         ret = get_fan_status(dev, &dummy);
1020         dev->fan_supported = !ret;
1021
1022         create_toshiba_proc_entries(dev);
1023
1024         return 0;
1025
1026 error:
1027         toshiba_acpi_remove(acpi_dev, 0);
1028         return ret;
1029 }
1030
1031 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
1032 {
1033         struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
1034         u32 hci_result, value;
1035
1036         if (event != 0x80)
1037                 return;
1038         do {
1039                 hci_read1(dev, HCI_SYSTEM_EVENT, &value, &hci_result);
1040                 if (hci_result == HCI_SUCCESS) {
1041                         if (value == 0x100)
1042                                 continue;
1043                         /* act on key press; ignore key release */
1044                         if (value & 0x80)
1045                                 continue;
1046
1047                         if (!sparse_keymap_report_event(dev->hotkey_dev,
1048                                                         value, 1, true)) {
1049                                 pr_info("Unknown key %x\n",
1050                                        value);
1051                         }
1052                 } else if (hci_result == HCI_NOT_SUPPORTED) {
1053                         /* This is a workaround for an unresolved issue on
1054                          * some machines where system events sporadically
1055                          * become disabled. */
1056                         hci_write1(dev, HCI_SYSTEM_EVENT, 1, &hci_result);
1057                         pr_notice("Re-enabled hotkeys\n");
1058                 }
1059         } while (hci_result != HCI_EMPTY);
1060 }
1061
1062
1063 static struct acpi_driver toshiba_acpi_driver = {
1064         .name   = "Toshiba ACPI driver",
1065         .owner  = THIS_MODULE,
1066         .ids    = toshiba_device_ids,
1067         .flags  = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1068         .ops    = {
1069                 .add            = toshiba_acpi_add,
1070                 .remove         = toshiba_acpi_remove,
1071                 .notify         = toshiba_acpi_notify,
1072         },
1073 };
1074
1075 static int __init toshiba_acpi_init(void)
1076 {
1077         int ret;
1078
1079         toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
1080         if (!toshiba_proc_dir) {
1081                 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
1082                 return -ENODEV;
1083         }
1084
1085         ret = acpi_bus_register_driver(&toshiba_acpi_driver);
1086         if (ret) {
1087                 pr_err("Failed to register ACPI driver: %d\n", ret);
1088                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1089         }
1090
1091         return ret;
1092 }
1093
1094 static void __exit toshiba_acpi_exit(void)
1095 {
1096         acpi_bus_unregister_driver(&toshiba_acpi_driver);
1097         if (toshiba_proc_dir)
1098                 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
1099 }
1100
1101 module_init(toshiba_acpi_init);
1102 module_exit(toshiba_acpi_exit);