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