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