1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * toshiba_acpi.c - Toshiba Laptop ACPI Extras 4 * 5 * Copyright (C) 2002-2004 John Belmonte 6 * Copyright (C) 2008 Philip Langdale 7 * Copyright (C) 2010 Pierre Ducroquet 8 * Copyright (C) 2014-2016 Azael Avalos 9 * 10 * The devolpment page for this driver is located at 11 * http://memebeam.org/toys/ToshibaAcpiDriver. 12 * 13 * Credits: 14 * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse 15 * engineering the Windows drivers 16 * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5 17 * Rob Miller - TV out and hotkeys help 18 */ 19 20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 21 22 #define TOSHIBA_ACPI_VERSION "0.24" 23 #define PROC_INTERFACE_VERSION 1 24 25 #include <linux/compiler.h> 26 #include <linux/dmi.h> 27 #include <linux/kernel.h> 28 #include <linux/module.h> 29 #include <linux/moduleparam.h> 30 #include <linux/init.h> 31 #include <linux/types.h> 32 #include <linux/proc_fs.h> 33 #include <linux/seq_file.h> 34 #include <linux/backlight.h> 35 #include <linux/input.h> 36 #include <linux/input/sparse-keymap.h> 37 #include <linux/leds.h> 38 #include <linux/slab.h> 39 #include <linux/workqueue.h> 40 #include <linux/i8042.h> 41 #include <linux/acpi.h> 42 #include <linux/uaccess.h> 43 #include <linux/miscdevice.h> 44 #include <linux/rfkill.h> 45 #include <linux/hwmon.h> 46 #include <linux/iio/iio.h> 47 #include <linux/toshiba.h> 48 #include <acpi/battery.h> 49 #include <acpi/video.h> 50 51 MODULE_AUTHOR("John Belmonte"); 52 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver"); 53 MODULE_LICENSE("GPL"); 54 55 static int turn_on_panel_on_resume = -1; 56 module_param(turn_on_panel_on_resume, int, 0644); 57 MODULE_PARM_DESC(turn_on_panel_on_resume, 58 "Call HCI_PANEL_POWER_ON on resume (-1 = auto, 0 = no, 1 = yes"); 59 60 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100" 61 62 /* Scan code for Fn key on TOS1900 models */ 63 #define TOS1900_FN_SCAN 0x6e 64 65 /* Toshiba ACPI method paths */ 66 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX" 67 68 /* 69 * The Toshiba configuration interface is composed of the HCI and the SCI, 70 * which are defined as follows: 71 * 72 * HCI is Toshiba's "Hardware Control Interface" which is supposed to 73 * be uniform across all their models. Ideally we would just call 74 * dedicated ACPI methods instead of using this primitive interface. 75 * However the ACPI methods seem to be incomplete in some areas (for 76 * example they allow setting, but not reading, the LCD brightness value), 77 * so this is still useful. 78 * 79 * SCI stands for "System Configuration Interface" which aim is to 80 * conceal differences in hardware between different models. 81 */ 82 83 #define TCI_WORDS 6 84 85 /* Operations */ 86 #define HCI_SET 0xff00 87 #define HCI_GET 0xfe00 88 #define SCI_OPEN 0xf100 89 #define SCI_CLOSE 0xf200 90 #define SCI_GET 0xf300 91 #define SCI_SET 0xf400 92 93 /* Return codes */ 94 #define TOS_SUCCESS 0x0000 95 #define TOS_SUCCESS2 0x0001 96 #define TOS_OPEN_CLOSE_OK 0x0044 97 #define TOS_FAILURE 0x1000 98 #define TOS_NOT_SUPPORTED 0x8000 99 #define TOS_ALREADY_OPEN 0x8100 100 #define TOS_NOT_OPENED 0x8200 101 #define TOS_INPUT_DATA_ERROR 0x8300 102 #define TOS_WRITE_PROTECTED 0x8400 103 #define TOS_NOT_PRESENT 0x8600 104 #define TOS_FIFO_EMPTY 0x8c00 105 #define TOS_DATA_NOT_AVAILABLE 0x8d20 106 #define TOS_NOT_INITIALIZED 0x8d50 107 #define TOS_NOT_INSTALLED 0x8e00 108 109 /* Registers */ 110 #define HCI_PANEL_POWER_ON 0x0002 111 #define HCI_FAN 0x0004 112 #define HCI_TR_BACKLIGHT 0x0005 113 #define HCI_SYSTEM_EVENT 0x0016 114 #define HCI_VIDEO_OUT 0x001c 115 #define HCI_HOTKEY_EVENT 0x001e 116 #define HCI_LCD_BRIGHTNESS 0x002a 117 #define HCI_FAN_RPM 0x0045 118 #define HCI_WIRELESS 0x0056 119 #define HCI_ACCELEROMETER 0x006d 120 #define HCI_COOLING_METHOD 0x007f 121 #define HCI_KBD_ILLUMINATION 0x0095 122 #define HCI_ECO_MODE 0x0097 123 #define HCI_ACCELEROMETER2 0x00a6 124 #define HCI_BATTERY_CHARGE_MODE 0x00ba 125 #define HCI_SYSTEM_INFO 0xc000 126 #define SCI_PANEL_POWER_ON 0x010d 127 #define SCI_ILLUMINATION 0x014e 128 #define SCI_USB_SLEEP_CHARGE 0x0150 129 #define SCI_KBD_ILLUM_STATUS 0x015c 130 #define SCI_USB_SLEEP_MUSIC 0x015e 131 #define SCI_USB_THREE 0x0169 132 #define SCI_TOUCHPAD 0x050e 133 #define SCI_KBD_FUNCTION_KEYS 0x0522 134 135 /* Field definitions */ 136 #define HCI_ACCEL_MASK 0x7fff 137 #define HCI_ACCEL_DIRECTION_MASK 0x8000 138 #define HCI_HOTKEY_DISABLE 0x0b 139 #define HCI_HOTKEY_ENABLE 0x09 140 #define HCI_HOTKEY_SPECIAL_FUNCTIONS 0x10 141 #define HCI_LCD_BRIGHTNESS_BITS 3 142 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS) 143 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS) 144 #define HCI_MISC_SHIFT 0x10 145 #define HCI_SYSTEM_TYPE1 0x10 146 #define HCI_SYSTEM_TYPE2 0x11 147 #define HCI_VIDEO_OUT_LCD 0x1 148 #define HCI_VIDEO_OUT_CRT 0x2 149 #define HCI_VIDEO_OUT_TV 0x4 150 #define SCI_KBD_MODE_MASK 0x1f 151 #define SCI_KBD_MODE_FNZ 0x1 152 #define SCI_KBD_MODE_AUTO 0x2 153 #define SCI_KBD_MODE_ON 0x8 154 #define SCI_KBD_MODE_OFF 0x10 155 #define SCI_KBD_TIME_MAX 0x3c001a 156 #define HCI_WIRELESS_STATUS 0x1 157 #define HCI_WIRELESS_WWAN 0x3 158 #define HCI_WIRELESS_WWAN_STATUS 0x2000 159 #define HCI_WIRELESS_WWAN_POWER 0x4000 160 #define SCI_USB_CHARGE_MODE_MASK 0xff 161 #define SCI_USB_CHARGE_DISABLED 0x00 162 #define SCI_USB_CHARGE_ALTERNATE 0x09 163 #define SCI_USB_CHARGE_TYPICAL 0x11 164 #define SCI_USB_CHARGE_AUTO 0x21 165 #define SCI_USB_CHARGE_BAT_MASK 0x7 166 #define SCI_USB_CHARGE_BAT_LVL_OFF 0x1 167 #define SCI_USB_CHARGE_BAT_LVL_ON 0x4 168 #define SCI_USB_CHARGE_BAT_LVL 0x0200 169 #define SCI_USB_CHARGE_RAPID_DSP 0x0300 170 171 struct toshiba_acpi_dev { 172 struct acpi_device *acpi_dev; 173 const char *method_hci; 174 struct input_dev *hotkey_dev; 175 struct work_struct hotkey_work; 176 struct backlight_device *backlight_dev; 177 struct led_classdev led_dev; 178 struct led_classdev kbd_led; 179 struct led_classdev eco_led; 180 struct miscdevice miscdev; 181 struct rfkill *wwan_rfk; 182 struct iio_dev *indio_dev; 183 #if IS_ENABLED(CONFIG_HWMON) 184 struct device *hwmon_device; 185 #endif 186 187 int force_fan; 188 int last_key_event; 189 int key_event_valid; 190 int kbd_type; 191 int kbd_mode; 192 int kbd_time; 193 int usbsc_bat_level; 194 int usbsc_mode_base; 195 int hotkey_event_type; 196 int max_cooling_method; 197 198 unsigned int illumination_supported:1; 199 unsigned int video_supported:1; 200 unsigned int fan_supported:1; 201 unsigned int fan_rpm_supported:1; 202 unsigned int system_event_supported:1; 203 unsigned int ntfy_supported:1; 204 unsigned int info_supported:1; 205 unsigned int tr_backlight_supported:1; 206 unsigned int kbd_illum_supported:1; 207 unsigned int touchpad_supported:1; 208 unsigned int eco_supported:1; 209 unsigned int accelerometer_supported:1; 210 unsigned int usb_sleep_charge_supported:1; 211 unsigned int usb_rapid_charge_supported:1; 212 unsigned int usb_sleep_music_supported:1; 213 unsigned int kbd_function_keys_supported:1; 214 unsigned int panel_power_on_supported:1; 215 unsigned int usb_three_supported:1; 216 unsigned int wwan_supported:1; 217 unsigned int cooling_method_supported:1; 218 unsigned int battery_charge_mode_supported:1; 219 unsigned int sysfs_created:1; 220 unsigned int special_functions; 221 222 bool kbd_event_generated; 223 bool killswitch; 224 }; 225 226 static struct toshiba_acpi_dev *toshiba_acpi; 227 228 static bool disable_hotkeys; 229 module_param(disable_hotkeys, bool, 0444); 230 MODULE_PARM_DESC(disable_hotkeys, "Disables the hotkeys activation"); 231 232 static const struct acpi_device_id toshiba_device_ids[] = { 233 {"TOS6200", 0}, 234 {"TOS6207", 0}, 235 {"TOS6208", 0}, 236 {"TOS1900", 0}, 237 {"", 0}, 238 }; 239 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids); 240 241 static const struct key_entry toshiba_acpi_keymap[] = { 242 { KE_KEY, 0x9e, { KEY_RFKILL } }, 243 { KE_KEY, 0x101, { KEY_MUTE } }, 244 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 245 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 246 { KE_KEY, 0x10f, { KEY_TAB } }, 247 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 248 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 249 { KE_KEY, 0x13b, { KEY_COFFEE } }, 250 { KE_KEY, 0x13c, { KEY_BATTERY } }, 251 { KE_KEY, 0x13d, { KEY_SLEEP } }, 252 { KE_KEY, 0x13e, { KEY_SUSPEND } }, 253 { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } }, 254 { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } }, 255 { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } }, 256 { KE_KEY, 0x142, { KEY_WLAN } }, 257 { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } }, 258 { KE_KEY, 0x17f, { KEY_FN } }, 259 { KE_KEY, 0xb05, { KEY_PROG2 } }, 260 { KE_KEY, 0xb06, { KEY_WWW } }, 261 { KE_KEY, 0xb07, { KEY_MAIL } }, 262 { KE_KEY, 0xb30, { KEY_STOP } }, 263 { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } }, 264 { KE_KEY, 0xb32, { KEY_NEXTSONG } }, 265 { KE_KEY, 0xb33, { KEY_PLAYPAUSE } }, 266 { KE_KEY, 0xb5a, { KEY_MEDIA } }, 267 { KE_IGNORE, 0x1430, { KEY_RESERVED } }, /* Wake from sleep */ 268 { KE_IGNORE, 0x1501, { KEY_RESERVED } }, /* Output changed */ 269 { KE_IGNORE, 0x1502, { KEY_RESERVED } }, /* HDMI plugged/unplugged */ 270 { KE_IGNORE, 0x1ABE, { KEY_RESERVED } }, /* Protection level set */ 271 { KE_IGNORE, 0x1ABF, { KEY_RESERVED } }, /* Protection level off */ 272 { KE_END, 0 }, 273 }; 274 275 static const struct key_entry toshiba_acpi_alt_keymap[] = { 276 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 277 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 278 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 279 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 280 { KE_KEY, 0x13c, { KEY_BRIGHTNESSDOWN } }, 281 { KE_KEY, 0x13d, { KEY_BRIGHTNESSUP } }, 282 { KE_KEY, 0x13e, { KEY_SWITCHVIDEOMODE } }, 283 { KE_KEY, 0x13f, { KEY_TOUCHPAD_TOGGLE } }, 284 { KE_KEY, 0x157, { KEY_MUTE } }, 285 { KE_KEY, 0x158, { KEY_WLAN } }, 286 { KE_END, 0 }, 287 }; 288 289 /* 290 * Utility 291 */ 292 293 static inline void _set_bit(u32 *word, u32 mask, int value) 294 { 295 *word = (*word & ~mask) | (mask * value); 296 } 297 298 /* 299 * ACPI interface wrappers 300 */ 301 302 static int write_acpi_int(const char *methodName, int val) 303 { 304 acpi_status status; 305 306 status = acpi_execute_simple_method(NULL, (char *)methodName, val); 307 return (status == AE_OK) ? 0 : -EIO; 308 } 309 310 /* 311 * Perform a raw configuration call. Here we don't care about input or output 312 * buffer format. 313 */ 314 static acpi_status tci_raw(struct toshiba_acpi_dev *dev, 315 const u32 in[TCI_WORDS], u32 out[TCI_WORDS]) 316 { 317 union acpi_object in_objs[TCI_WORDS], out_objs[TCI_WORDS + 1]; 318 struct acpi_object_list params; 319 struct acpi_buffer results; 320 acpi_status status; 321 int i; 322 323 params.count = TCI_WORDS; 324 params.pointer = in_objs; 325 for (i = 0; i < TCI_WORDS; ++i) { 326 in_objs[i].type = ACPI_TYPE_INTEGER; 327 in_objs[i].integer.value = in[i]; 328 } 329 330 results.length = sizeof(out_objs); 331 results.pointer = out_objs; 332 333 status = acpi_evaluate_object(dev->acpi_dev->handle, 334 (char *)dev->method_hci, ¶ms, 335 &results); 336 if ((status == AE_OK) && (out_objs->package.count <= TCI_WORDS)) { 337 for (i = 0; i < out_objs->package.count; ++i) 338 out[i] = out_objs->package.elements[i].integer.value; 339 } 340 341 return status; 342 } 343 344 /* 345 * Common hci tasks 346 * 347 * In addition to the ACPI status, the HCI system returns a result which 348 * may be useful (such as "not supported"). 349 */ 350 351 static u32 hci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1) 352 { 353 u32 in[TCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 }; 354 u32 out[TCI_WORDS]; 355 acpi_status status = tci_raw(dev, in, out); 356 357 return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE; 358 } 359 360 static u32 hci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1) 361 { 362 u32 in[TCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 }; 363 u32 out[TCI_WORDS]; 364 acpi_status status = tci_raw(dev, in, out); 365 366 if (ACPI_FAILURE(status)) 367 return TOS_FAILURE; 368 369 *out1 = out[2]; 370 371 return out[0]; 372 } 373 374 /* 375 * Common sci tasks 376 */ 377 378 static int sci_open(struct toshiba_acpi_dev *dev) 379 { 380 u32 in[TCI_WORDS] = { SCI_OPEN, 0, 0, 0, 0, 0 }; 381 u32 out[TCI_WORDS]; 382 acpi_status status = tci_raw(dev, in, out); 383 384 if (ACPI_FAILURE(status)) { 385 pr_err("ACPI call to open SCI failed\n"); 386 return 0; 387 } 388 389 if (out[0] == TOS_OPEN_CLOSE_OK) { 390 return 1; 391 } else if (out[0] == TOS_ALREADY_OPEN) { 392 pr_info("Toshiba SCI already opened\n"); 393 return 1; 394 } else if (out[0] == TOS_NOT_SUPPORTED) { 395 /* 396 * Some BIOSes do not have the SCI open/close functions 397 * implemented and return 0x8000 (Not Supported), failing to 398 * register some supported features. 399 * 400 * Simply return 1 if we hit those affected laptops to make the 401 * supported features work. 402 * 403 * In the case that some laptops really do not support the SCI, 404 * all the SCI dependent functions check for TOS_NOT_SUPPORTED, 405 * and thus, not registering support for the queried feature. 406 */ 407 return 1; 408 } else if (out[0] == TOS_NOT_PRESENT) { 409 pr_info("Toshiba SCI is not present\n"); 410 } 411 412 return 0; 413 } 414 415 static void sci_close(struct toshiba_acpi_dev *dev) 416 { 417 u32 in[TCI_WORDS] = { SCI_CLOSE, 0, 0, 0, 0, 0 }; 418 u32 out[TCI_WORDS]; 419 acpi_status status = tci_raw(dev, in, out); 420 421 if (ACPI_FAILURE(status)) { 422 pr_err("ACPI call to close SCI failed\n"); 423 return; 424 } 425 426 if (out[0] == TOS_OPEN_CLOSE_OK) 427 return; 428 else if (out[0] == TOS_NOT_OPENED) 429 pr_info("Toshiba SCI not opened\n"); 430 else if (out[0] == TOS_NOT_PRESENT) 431 pr_info("Toshiba SCI is not present\n"); 432 } 433 434 static u32 sci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1) 435 { 436 u32 in[TCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 }; 437 u32 out[TCI_WORDS]; 438 acpi_status status = tci_raw(dev, in, out); 439 440 if (ACPI_FAILURE(status)) 441 return TOS_FAILURE; 442 443 *out1 = out[2]; 444 445 return out[0]; 446 } 447 448 static u32 sci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1) 449 { 450 u32 in[TCI_WORDS] = { SCI_SET, reg, in1, 0, 0, 0 }; 451 u32 out[TCI_WORDS]; 452 acpi_status status = tci_raw(dev, in, out); 453 454 return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE; 455 } 456 457 /* Illumination support */ 458 static void toshiba_illumination_available(struct toshiba_acpi_dev *dev) 459 { 460 u32 in[TCI_WORDS] = { SCI_GET, SCI_ILLUMINATION, 0, 0, 0, 0 }; 461 u32 out[TCI_WORDS]; 462 acpi_status status; 463 464 dev->illumination_supported = 0; 465 466 if (!sci_open(dev)) 467 return; 468 469 status = tci_raw(dev, in, out); 470 sci_close(dev); 471 if (ACPI_FAILURE(status)) { 472 pr_err("ACPI call to query Illumination support failed\n"); 473 return; 474 } 475 476 if (out[0] != TOS_SUCCESS) 477 return; 478 479 dev->illumination_supported = 1; 480 } 481 482 static void toshiba_illumination_set(struct led_classdev *cdev, 483 enum led_brightness brightness) 484 { 485 struct toshiba_acpi_dev *dev = container_of(cdev, 486 struct toshiba_acpi_dev, led_dev); 487 u32 result; 488 u32 state; 489 490 /* First request : initialize communication. */ 491 if (!sci_open(dev)) 492 return; 493 494 /* Switch the illumination on/off */ 495 state = brightness ? 1 : 0; 496 result = sci_write(dev, SCI_ILLUMINATION, state); 497 sci_close(dev); 498 if (result == TOS_FAILURE) 499 pr_err("ACPI call for illumination failed\n"); 500 } 501 502 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev) 503 { 504 struct toshiba_acpi_dev *dev = container_of(cdev, 505 struct toshiba_acpi_dev, led_dev); 506 u32 result; 507 u32 state; 508 509 /* First request : initialize communication. */ 510 if (!sci_open(dev)) 511 return LED_OFF; 512 513 /* Check the illumination */ 514 result = sci_read(dev, SCI_ILLUMINATION, &state); 515 sci_close(dev); 516 if (result == TOS_FAILURE) { 517 pr_err("ACPI call for illumination failed\n"); 518 return LED_OFF; 519 } else if (result != TOS_SUCCESS) { 520 return LED_OFF; 521 } 522 523 return state ? LED_FULL : LED_OFF; 524 } 525 526 /* KBD Illumination */ 527 static void toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev) 528 { 529 u32 in[TCI_WORDS] = { SCI_GET, SCI_KBD_ILLUM_STATUS, 0, 0, 0, 0 }; 530 u32 out[TCI_WORDS]; 531 acpi_status status; 532 533 dev->kbd_illum_supported = 0; 534 dev->kbd_event_generated = false; 535 536 if (!sci_open(dev)) 537 return; 538 539 status = tci_raw(dev, in, out); 540 sci_close(dev); 541 if (ACPI_FAILURE(status)) { 542 pr_err("ACPI call to query kbd illumination support failed\n"); 543 return; 544 } 545 546 if (out[0] != TOS_SUCCESS) 547 return; 548 549 /* 550 * Check for keyboard backlight timeout max value, 551 * previous kbd backlight implementation set this to 552 * 0x3c0003, and now the new implementation set this 553 * to 0x3c001a, use this to distinguish between them. 554 */ 555 if (out[3] == SCI_KBD_TIME_MAX) 556 dev->kbd_type = 2; 557 else 558 dev->kbd_type = 1; 559 /* Get the current keyboard backlight mode */ 560 dev->kbd_mode = out[2] & SCI_KBD_MODE_MASK; 561 /* Get the current time (1-60 seconds) */ 562 dev->kbd_time = out[2] >> HCI_MISC_SHIFT; 563 /* Flag as supported */ 564 dev->kbd_illum_supported = 1; 565 } 566 567 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time) 568 { 569 u32 result; 570 571 if (!sci_open(dev)) 572 return -EIO; 573 574 result = sci_write(dev, SCI_KBD_ILLUM_STATUS, time); 575 sci_close(dev); 576 if (result == TOS_FAILURE) 577 pr_err("ACPI call to set KBD backlight status failed\n"); 578 else if (result == TOS_NOT_SUPPORTED) 579 return -ENODEV; 580 581 return result == TOS_SUCCESS ? 0 : -EIO; 582 } 583 584 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time) 585 { 586 u32 result; 587 588 if (!sci_open(dev)) 589 return -EIO; 590 591 result = sci_read(dev, SCI_KBD_ILLUM_STATUS, time); 592 sci_close(dev); 593 if (result == TOS_FAILURE) 594 pr_err("ACPI call to get KBD backlight status failed\n"); 595 else if (result == TOS_NOT_SUPPORTED) 596 return -ENODEV; 597 598 return result == TOS_SUCCESS ? 0 : -EIO; 599 } 600 601 static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev) 602 { 603 struct toshiba_acpi_dev *dev = container_of(cdev, 604 struct toshiba_acpi_dev, kbd_led); 605 u32 result; 606 u32 state; 607 608 /* Check the keyboard backlight state */ 609 result = hci_read(dev, HCI_KBD_ILLUMINATION, &state); 610 if (result == TOS_FAILURE) { 611 pr_err("ACPI call to get the keyboard backlight failed\n"); 612 return LED_OFF; 613 } else if (result != TOS_SUCCESS) { 614 return LED_OFF; 615 } 616 617 return state ? LED_FULL : LED_OFF; 618 } 619 620 static void toshiba_kbd_backlight_set(struct led_classdev *cdev, 621 enum led_brightness brightness) 622 { 623 struct toshiba_acpi_dev *dev = container_of(cdev, 624 struct toshiba_acpi_dev, kbd_led); 625 u32 result; 626 u32 state; 627 628 /* Set the keyboard backlight state */ 629 state = brightness ? 1 : 0; 630 result = hci_write(dev, HCI_KBD_ILLUMINATION, state); 631 if (result == TOS_FAILURE) 632 pr_err("ACPI call to set KBD Illumination mode failed\n"); 633 } 634 635 /* TouchPad support */ 636 static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state) 637 { 638 u32 result; 639 640 if (!sci_open(dev)) 641 return -EIO; 642 643 result = sci_write(dev, SCI_TOUCHPAD, state); 644 sci_close(dev); 645 if (result == TOS_FAILURE) 646 pr_err("ACPI call to set the touchpad failed\n"); 647 else if (result == TOS_NOT_SUPPORTED) 648 return -ENODEV; 649 650 return result == TOS_SUCCESS ? 0 : -EIO; 651 } 652 653 static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state) 654 { 655 u32 result; 656 657 if (!sci_open(dev)) 658 return -EIO; 659 660 result = sci_read(dev, SCI_TOUCHPAD, state); 661 sci_close(dev); 662 if (result == TOS_FAILURE) 663 pr_err("ACPI call to query the touchpad failed\n"); 664 else if (result == TOS_NOT_SUPPORTED) 665 return -ENODEV; 666 667 return result == TOS_SUCCESS ? 0 : -EIO; 668 } 669 670 /* Eco Mode support */ 671 static void toshiba_eco_mode_available(struct toshiba_acpi_dev *dev) 672 { 673 u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 }; 674 u32 out[TCI_WORDS]; 675 acpi_status status; 676 677 dev->eco_supported = 0; 678 679 status = tci_raw(dev, in, out); 680 if (ACPI_FAILURE(status)) { 681 pr_err("ACPI call to get ECO led failed\n"); 682 return; 683 } 684 685 if (out[0] == TOS_INPUT_DATA_ERROR || out[0] == TOS_NOT_SUPPORTED) { 686 /* 687 * If we receive 0x8300 (Input Data Error), it means that the 688 * LED device is present, but that we just screwed the input 689 * parameters. 690 * 691 * On some laptops 0x8000 (Not supported) is also returned in 692 * this case, so we need to allow for that as well. 693 * 694 * Let's query the status of the LED to see if we really have a 695 * success response, indicating the actual presense of the LED, 696 * bail out otherwise. 697 */ 698 in[3] = 1; 699 status = tci_raw(dev, in, out); 700 if (ACPI_FAILURE(status)) { 701 pr_err("ACPI call to get ECO led failed\n"); 702 return; 703 } 704 705 if (out[0] != TOS_SUCCESS) 706 return; 707 708 dev->eco_supported = 1; 709 } 710 } 711 712 static enum led_brightness 713 toshiba_eco_mode_get_status(struct led_classdev *cdev) 714 { 715 struct toshiba_acpi_dev *dev = container_of(cdev, 716 struct toshiba_acpi_dev, eco_led); 717 u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 }; 718 u32 out[TCI_WORDS]; 719 acpi_status status; 720 721 status = tci_raw(dev, in, out); 722 if (ACPI_FAILURE(status)) { 723 pr_err("ACPI call to get ECO led failed\n"); 724 return LED_OFF; 725 } 726 727 if (out[0] != TOS_SUCCESS) 728 return LED_OFF; 729 730 return out[2] ? LED_FULL : LED_OFF; 731 } 732 733 static void toshiba_eco_mode_set_status(struct led_classdev *cdev, 734 enum led_brightness brightness) 735 { 736 struct toshiba_acpi_dev *dev = container_of(cdev, 737 struct toshiba_acpi_dev, eco_led); 738 u32 in[TCI_WORDS] = { HCI_SET, HCI_ECO_MODE, 0, 1, 0, 0 }; 739 u32 out[TCI_WORDS]; 740 acpi_status status; 741 742 /* Switch the Eco Mode led on/off */ 743 in[2] = (brightness) ? 1 : 0; 744 status = tci_raw(dev, in, out); 745 if (ACPI_FAILURE(status)) 746 pr_err("ACPI call to set ECO led failed\n"); 747 } 748 749 /* Accelerometer support */ 750 static void toshiba_accelerometer_available(struct toshiba_acpi_dev *dev) 751 { 752 u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER2, 0, 0, 0, 0 }; 753 u32 out[TCI_WORDS]; 754 acpi_status status; 755 756 dev->accelerometer_supported = 0; 757 758 /* 759 * Check if the accelerometer call exists, 760 * this call also serves as initialization 761 */ 762 status = tci_raw(dev, in, out); 763 if (ACPI_FAILURE(status)) { 764 pr_err("ACPI call to query the accelerometer failed\n"); 765 return; 766 } 767 768 if (out[0] != TOS_SUCCESS) 769 return; 770 771 dev->accelerometer_supported = 1; 772 } 773 774 static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev, 775 u32 *xy, u32 *z) 776 { 777 u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER, 0, 1, 0, 0 }; 778 u32 out[TCI_WORDS]; 779 acpi_status status; 780 781 /* Check the Accelerometer status */ 782 status = tci_raw(dev, in, out); 783 if (ACPI_FAILURE(status)) { 784 pr_err("ACPI call to query the accelerometer failed\n"); 785 return -EIO; 786 } 787 788 if (out[0] == TOS_NOT_SUPPORTED) 789 return -ENODEV; 790 791 if (out[0] != TOS_SUCCESS) 792 return -EIO; 793 794 *xy = out[2]; 795 *z = out[4]; 796 797 return 0; 798 } 799 800 /* Sleep (Charge and Music) utilities support */ 801 static void toshiba_usb_sleep_charge_available(struct toshiba_acpi_dev *dev) 802 { 803 u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 804 u32 out[TCI_WORDS]; 805 acpi_status status; 806 807 dev->usb_sleep_charge_supported = 0; 808 809 if (!sci_open(dev)) 810 return; 811 812 status = tci_raw(dev, in, out); 813 if (ACPI_FAILURE(status)) { 814 pr_err("ACPI call to get USB Sleep and Charge mode failed\n"); 815 sci_close(dev); 816 return; 817 } 818 819 if (out[0] != TOS_SUCCESS) { 820 sci_close(dev); 821 return; 822 } 823 824 dev->usbsc_mode_base = out[4]; 825 826 in[5] = SCI_USB_CHARGE_BAT_LVL; 827 status = tci_raw(dev, in, out); 828 sci_close(dev); 829 if (ACPI_FAILURE(status)) { 830 pr_err("ACPI call to get USB Sleep and Charge mode failed\n"); 831 return; 832 } 833 834 if (out[0] != TOS_SUCCESS) 835 return; 836 837 dev->usbsc_bat_level = out[2]; 838 /* Flag as supported */ 839 dev->usb_sleep_charge_supported = 1; 840 } 841 842 static int toshiba_usb_sleep_charge_get(struct toshiba_acpi_dev *dev, 843 u32 *mode) 844 { 845 u32 result; 846 847 if (!sci_open(dev)) 848 return -EIO; 849 850 result = sci_read(dev, SCI_USB_SLEEP_CHARGE, mode); 851 sci_close(dev); 852 if (result == TOS_FAILURE) 853 pr_err("ACPI call to set USB S&C mode failed\n"); 854 else if (result == TOS_NOT_SUPPORTED) 855 return -ENODEV; 856 857 return result == TOS_SUCCESS ? 0 : -EIO; 858 } 859 860 static int toshiba_usb_sleep_charge_set(struct toshiba_acpi_dev *dev, 861 u32 mode) 862 { 863 u32 result; 864 865 if (!sci_open(dev)) 866 return -EIO; 867 868 result = sci_write(dev, SCI_USB_SLEEP_CHARGE, mode); 869 sci_close(dev); 870 if (result == TOS_FAILURE) 871 pr_err("ACPI call to set USB S&C mode failed\n"); 872 else if (result == TOS_NOT_SUPPORTED) 873 return -ENODEV; 874 875 return result == TOS_SUCCESS ? 0 : -EIO; 876 } 877 878 static int toshiba_sleep_functions_status_get(struct toshiba_acpi_dev *dev, 879 u32 *mode) 880 { 881 u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 882 u32 out[TCI_WORDS]; 883 acpi_status status; 884 885 if (!sci_open(dev)) 886 return -EIO; 887 888 in[5] = SCI_USB_CHARGE_BAT_LVL; 889 status = tci_raw(dev, in, out); 890 sci_close(dev); 891 if (ACPI_FAILURE(status)) { 892 pr_err("ACPI call to get USB S&C battery level failed\n"); 893 return -EIO; 894 } 895 896 if (out[0] == TOS_NOT_SUPPORTED) 897 return -ENODEV; 898 899 if (out[0] != TOS_SUCCESS) 900 return -EIO; 901 902 *mode = out[2]; 903 904 return 0; 905 906 } 907 908 static int toshiba_sleep_functions_status_set(struct toshiba_acpi_dev *dev, 909 u32 mode) 910 { 911 u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 912 u32 out[TCI_WORDS]; 913 acpi_status status; 914 915 if (!sci_open(dev)) 916 return -EIO; 917 918 in[2] = mode; 919 in[5] = SCI_USB_CHARGE_BAT_LVL; 920 status = tci_raw(dev, in, out); 921 sci_close(dev); 922 if (ACPI_FAILURE(status)) { 923 pr_err("ACPI call to set USB S&C battery level failed\n"); 924 return -EIO; 925 } 926 927 if (out[0] == TOS_NOT_SUPPORTED) 928 return -ENODEV; 929 930 return out[0] == TOS_SUCCESS ? 0 : -EIO; 931 } 932 933 static int toshiba_usb_rapid_charge_get(struct toshiba_acpi_dev *dev, 934 u32 *state) 935 { 936 u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 937 u32 out[TCI_WORDS]; 938 acpi_status status; 939 940 if (!sci_open(dev)) 941 return -EIO; 942 943 in[5] = SCI_USB_CHARGE_RAPID_DSP; 944 status = tci_raw(dev, in, out); 945 sci_close(dev); 946 if (ACPI_FAILURE(status)) { 947 pr_err("ACPI call to get USB Rapid Charge failed\n"); 948 return -EIO; 949 } 950 951 if (out[0] == TOS_NOT_SUPPORTED) 952 return -ENODEV; 953 954 if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2) 955 return -EIO; 956 957 *state = out[2]; 958 959 return 0; 960 } 961 962 static int toshiba_usb_rapid_charge_set(struct toshiba_acpi_dev *dev, 963 u32 state) 964 { 965 u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 }; 966 u32 out[TCI_WORDS]; 967 acpi_status status; 968 969 if (!sci_open(dev)) 970 return -EIO; 971 972 in[2] = state; 973 in[5] = SCI_USB_CHARGE_RAPID_DSP; 974 status = tci_raw(dev, in, out); 975 sci_close(dev); 976 if (ACPI_FAILURE(status)) { 977 pr_err("ACPI call to set USB Rapid Charge failed\n"); 978 return -EIO; 979 } 980 981 if (out[0] == TOS_NOT_SUPPORTED) 982 return -ENODEV; 983 984 return (out[0] == TOS_SUCCESS || out[0] == TOS_SUCCESS2) ? 0 : -EIO; 985 } 986 987 static int toshiba_usb_sleep_music_get(struct toshiba_acpi_dev *dev, u32 *state) 988 { 989 u32 result; 990 991 if (!sci_open(dev)) 992 return -EIO; 993 994 result = sci_read(dev, SCI_USB_SLEEP_MUSIC, state); 995 sci_close(dev); 996 if (result == TOS_FAILURE) 997 pr_err("ACPI call to get Sleep and Music failed\n"); 998 else if (result == TOS_NOT_SUPPORTED) 999 return -ENODEV; 1000 1001 return result == TOS_SUCCESS ? 0 : -EIO; 1002 } 1003 1004 static int toshiba_usb_sleep_music_set(struct toshiba_acpi_dev *dev, u32 state) 1005 { 1006 u32 result; 1007 1008 if (!sci_open(dev)) 1009 return -EIO; 1010 1011 result = sci_write(dev, SCI_USB_SLEEP_MUSIC, state); 1012 sci_close(dev); 1013 if (result == TOS_FAILURE) 1014 pr_err("ACPI call to set Sleep and Music failed\n"); 1015 else if (result == TOS_NOT_SUPPORTED) 1016 return -ENODEV; 1017 1018 return result == TOS_SUCCESS ? 0 : -EIO; 1019 } 1020 1021 /* Keyboard function keys */ 1022 static int toshiba_function_keys_get(struct toshiba_acpi_dev *dev, u32 *mode) 1023 { 1024 u32 result; 1025 1026 if (!sci_open(dev)) 1027 return -EIO; 1028 1029 result = sci_read(dev, SCI_KBD_FUNCTION_KEYS, mode); 1030 sci_close(dev); 1031 if (result == TOS_FAILURE) 1032 pr_err("ACPI call to get KBD function keys failed\n"); 1033 else if (result == TOS_NOT_SUPPORTED) 1034 return -ENODEV; 1035 1036 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1037 } 1038 1039 static int toshiba_function_keys_set(struct toshiba_acpi_dev *dev, u32 mode) 1040 { 1041 u32 result; 1042 1043 if (!sci_open(dev)) 1044 return -EIO; 1045 1046 result = sci_write(dev, SCI_KBD_FUNCTION_KEYS, mode); 1047 sci_close(dev); 1048 if (result == TOS_FAILURE) 1049 pr_err("ACPI call to set KBD function keys failed\n"); 1050 else if (result == TOS_NOT_SUPPORTED) 1051 return -ENODEV; 1052 1053 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1054 } 1055 1056 /* Panel Power ON */ 1057 static int toshiba_panel_power_on_get(struct toshiba_acpi_dev *dev, u32 *state) 1058 { 1059 u32 result; 1060 1061 if (!sci_open(dev)) 1062 return -EIO; 1063 1064 result = sci_read(dev, SCI_PANEL_POWER_ON, state); 1065 sci_close(dev); 1066 if (result == TOS_FAILURE) 1067 pr_err("ACPI call to get Panel Power ON failed\n"); 1068 else if (result == TOS_NOT_SUPPORTED) 1069 return -ENODEV; 1070 1071 return result == TOS_SUCCESS ? 0 : -EIO; 1072 } 1073 1074 static int toshiba_panel_power_on_set(struct toshiba_acpi_dev *dev, u32 state) 1075 { 1076 u32 result; 1077 1078 if (!sci_open(dev)) 1079 return -EIO; 1080 1081 result = sci_write(dev, SCI_PANEL_POWER_ON, state); 1082 sci_close(dev); 1083 if (result == TOS_FAILURE) 1084 pr_err("ACPI call to set Panel Power ON failed\n"); 1085 else if (result == TOS_NOT_SUPPORTED) 1086 return -ENODEV; 1087 1088 return result == TOS_SUCCESS ? 0 : -EIO; 1089 } 1090 1091 /* USB Three */ 1092 static int toshiba_usb_three_get(struct toshiba_acpi_dev *dev, u32 *state) 1093 { 1094 u32 result; 1095 1096 if (!sci_open(dev)) 1097 return -EIO; 1098 1099 result = sci_read(dev, SCI_USB_THREE, state); 1100 sci_close(dev); 1101 if (result == TOS_FAILURE) 1102 pr_err("ACPI call to get USB 3 failed\n"); 1103 else if (result == TOS_NOT_SUPPORTED) 1104 return -ENODEV; 1105 1106 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1107 } 1108 1109 static int toshiba_usb_three_set(struct toshiba_acpi_dev *dev, u32 state) 1110 { 1111 u32 result; 1112 1113 if (!sci_open(dev)) 1114 return -EIO; 1115 1116 result = sci_write(dev, SCI_USB_THREE, state); 1117 sci_close(dev); 1118 if (result == TOS_FAILURE) 1119 pr_err("ACPI call to set USB 3 failed\n"); 1120 else if (result == TOS_NOT_SUPPORTED) 1121 return -ENODEV; 1122 1123 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1124 } 1125 1126 /* Hotkey Event type */ 1127 static int toshiba_hotkey_event_type_get(struct toshiba_acpi_dev *dev, 1128 u32 *type) 1129 { 1130 u32 in[TCI_WORDS] = { HCI_GET, HCI_SYSTEM_INFO, 0x03, 0, 0, 0 }; 1131 u32 out[TCI_WORDS]; 1132 acpi_status status; 1133 1134 status = tci_raw(dev, in, out); 1135 if (ACPI_FAILURE(status)) { 1136 pr_err("ACPI call to get System type failed\n"); 1137 return -EIO; 1138 } 1139 1140 if (out[0] == TOS_NOT_SUPPORTED) 1141 return -ENODEV; 1142 1143 if (out[0] != TOS_SUCCESS) 1144 return -EIO; 1145 1146 *type = out[3]; 1147 1148 return 0; 1149 } 1150 1151 /* Wireless status (RFKill, WLAN, BT, WWAN) */ 1152 static int toshiba_wireless_status(struct toshiba_acpi_dev *dev) 1153 { 1154 u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 }; 1155 u32 out[TCI_WORDS]; 1156 acpi_status status; 1157 1158 in[3] = HCI_WIRELESS_STATUS; 1159 status = tci_raw(dev, in, out); 1160 1161 if (ACPI_FAILURE(status)) { 1162 pr_err("ACPI call to get Wireless status failed\n"); 1163 return -EIO; 1164 } 1165 1166 if (out[0] == TOS_NOT_SUPPORTED) 1167 return -ENODEV; 1168 1169 if (out[0] != TOS_SUCCESS) 1170 return -EIO; 1171 1172 dev->killswitch = !!(out[2] & HCI_WIRELESS_STATUS); 1173 1174 return 0; 1175 } 1176 1177 /* WWAN */ 1178 static void toshiba_wwan_available(struct toshiba_acpi_dev *dev) 1179 { 1180 u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 }; 1181 u32 out[TCI_WORDS]; 1182 acpi_status status; 1183 1184 dev->wwan_supported = 0; 1185 1186 /* 1187 * WWAN support can be queried by setting the in[3] value to 1188 * HCI_WIRELESS_WWAN (0x03). 1189 * 1190 * If supported, out[0] contains TOS_SUCCESS and out[2] contains 1191 * HCI_WIRELESS_WWAN_STATUS (0x2000). 1192 * 1193 * If not supported, out[0] contains TOS_INPUT_DATA_ERROR (0x8300) 1194 * or TOS_NOT_SUPPORTED (0x8000). 1195 */ 1196 in[3] = HCI_WIRELESS_WWAN; 1197 status = tci_raw(dev, in, out); 1198 if (ACPI_FAILURE(status)) { 1199 pr_err("ACPI call to get WWAN status failed\n"); 1200 return; 1201 } 1202 1203 if (out[0] != TOS_SUCCESS) 1204 return; 1205 1206 dev->wwan_supported = (out[2] == HCI_WIRELESS_WWAN_STATUS); 1207 } 1208 1209 static int toshiba_wwan_set(struct toshiba_acpi_dev *dev, u32 state) 1210 { 1211 u32 in[TCI_WORDS] = { HCI_SET, HCI_WIRELESS, state, 0, 0, 0 }; 1212 u32 out[TCI_WORDS]; 1213 acpi_status status; 1214 1215 in[3] = HCI_WIRELESS_WWAN_STATUS; 1216 status = tci_raw(dev, in, out); 1217 if (ACPI_FAILURE(status)) { 1218 pr_err("ACPI call to set WWAN status failed\n"); 1219 return -EIO; 1220 } 1221 1222 if (out[0] == TOS_NOT_SUPPORTED) 1223 return -ENODEV; 1224 1225 if (out[0] != TOS_SUCCESS) 1226 return -EIO; 1227 1228 /* 1229 * Some devices only need to call HCI_WIRELESS_WWAN_STATUS to 1230 * (de)activate the device, but some others need the 1231 * HCI_WIRELESS_WWAN_POWER call as well. 1232 */ 1233 in[3] = HCI_WIRELESS_WWAN_POWER; 1234 status = tci_raw(dev, in, out); 1235 if (ACPI_FAILURE(status)) { 1236 pr_err("ACPI call to set WWAN power failed\n"); 1237 return -EIO; 1238 } 1239 1240 if (out[0] == TOS_NOT_SUPPORTED) 1241 return -ENODEV; 1242 1243 return out[0] == TOS_SUCCESS ? 0 : -EIO; 1244 } 1245 1246 /* Cooling Method */ 1247 static void toshiba_cooling_method_available(struct toshiba_acpi_dev *dev) 1248 { 1249 u32 in[TCI_WORDS] = { HCI_GET, HCI_COOLING_METHOD, 0, 0, 0, 0 }; 1250 u32 out[TCI_WORDS]; 1251 acpi_status status; 1252 1253 dev->cooling_method_supported = 0; 1254 dev->max_cooling_method = 0; 1255 1256 status = tci_raw(dev, in, out); 1257 if (ACPI_FAILURE(status)) { 1258 pr_err("ACPI call to get Cooling Method failed\n"); 1259 return; 1260 } 1261 1262 if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2) 1263 return; 1264 1265 dev->cooling_method_supported = 1; 1266 dev->max_cooling_method = out[3]; 1267 } 1268 1269 static int toshiba_cooling_method_get(struct toshiba_acpi_dev *dev, u32 *state) 1270 { 1271 u32 result = hci_read(dev, HCI_COOLING_METHOD, state); 1272 1273 if (result == TOS_FAILURE) 1274 pr_err("ACPI call to get Cooling Method failed\n"); 1275 1276 if (result == TOS_NOT_SUPPORTED) 1277 return -ENODEV; 1278 1279 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1280 } 1281 1282 static int toshiba_cooling_method_set(struct toshiba_acpi_dev *dev, u32 state) 1283 { 1284 u32 result = hci_write(dev, HCI_COOLING_METHOD, state); 1285 1286 if (result == TOS_FAILURE) 1287 pr_err("ACPI call to set Cooling Method failed\n"); 1288 1289 if (result == TOS_NOT_SUPPORTED) 1290 return -ENODEV; 1291 1292 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1293 } 1294 1295 /* Battery charge control */ 1296 static void toshiba_battery_charge_mode_available(struct toshiba_acpi_dev *dev) 1297 { 1298 u32 in[TCI_WORDS] = { HCI_GET, HCI_BATTERY_CHARGE_MODE, 0, 0, 0, 0 }; 1299 u32 out[TCI_WORDS]; 1300 acpi_status status; 1301 1302 dev->battery_charge_mode_supported = 0; 1303 1304 status = tci_raw(dev, in, out); 1305 if (ACPI_FAILURE(status)) { 1306 pr_err("ACPI call to get Battery Charge Mode failed\n"); 1307 return; 1308 } 1309 1310 if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2) 1311 return; 1312 1313 dev->battery_charge_mode_supported = 1; 1314 } 1315 1316 static int toshiba_battery_charge_mode_get(struct toshiba_acpi_dev *dev, u32 *state) 1317 { 1318 u32 in[TCI_WORDS] = { HCI_GET, HCI_BATTERY_CHARGE_MODE, 0, 0, 0, 0x1 }; 1319 u32 out[TCI_WORDS]; 1320 int retries = 3; 1321 1322 do { 1323 acpi_status status = tci_raw(dev, in, out); 1324 1325 if (ACPI_FAILURE(status)) 1326 pr_err("ACPI call to get Battery Charge Mode failed\n"); 1327 switch (out[0]) { 1328 case TOS_SUCCESS: 1329 case TOS_SUCCESS2: 1330 *state = out[2]; 1331 return 0; 1332 case TOS_NOT_SUPPORTED: 1333 return -ENODEV; 1334 case TOS_DATA_NOT_AVAILABLE: 1335 retries--; 1336 break; 1337 default: 1338 return -EIO; 1339 } 1340 } while (retries); 1341 1342 return -EIO; 1343 } 1344 1345 static int toshiba_battery_charge_mode_set(struct toshiba_acpi_dev *dev, u32 state) 1346 { 1347 u32 result = hci_write(dev, HCI_BATTERY_CHARGE_MODE, state); 1348 1349 if (result == TOS_FAILURE) 1350 pr_err("ACPI call to set Battery Charge Mode failed\n"); 1351 1352 if (result == TOS_NOT_SUPPORTED) 1353 return -ENODEV; 1354 1355 return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO; 1356 } 1357 1358 /* Transflective Backlight */ 1359 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 *status) 1360 { 1361 u32 result = hci_read(dev, HCI_TR_BACKLIGHT, status); 1362 1363 if (result == TOS_FAILURE) 1364 pr_err("ACPI call to get Transflective Backlight failed\n"); 1365 else if (result == TOS_NOT_SUPPORTED) 1366 return -ENODEV; 1367 1368 return result == TOS_SUCCESS ? 0 : -EIO; 1369 } 1370 1371 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 status) 1372 { 1373 u32 result = hci_write(dev, HCI_TR_BACKLIGHT, !status); 1374 1375 if (result == TOS_FAILURE) 1376 pr_err("ACPI call to set Transflective Backlight failed\n"); 1377 else if (result == TOS_NOT_SUPPORTED) 1378 return -ENODEV; 1379 1380 return result == TOS_SUCCESS ? 0 : -EIO; 1381 } 1382 1383 static struct proc_dir_entry *toshiba_proc_dir; 1384 1385 /* LCD Brightness */ 1386 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev) 1387 { 1388 int brightness = 0; 1389 u32 result; 1390 u32 value; 1391 1392 if (dev->tr_backlight_supported) { 1393 int ret = get_tr_backlight_status(dev, &value); 1394 1395 if (ret) 1396 return ret; 1397 if (value) 1398 return 0; 1399 brightness++; 1400 } 1401 1402 result = hci_read(dev, HCI_LCD_BRIGHTNESS, &value); 1403 if (result == TOS_FAILURE) 1404 pr_err("ACPI call to get LCD Brightness failed\n"); 1405 else if (result == TOS_NOT_SUPPORTED) 1406 return -ENODEV; 1407 1408 return result == TOS_SUCCESS ? 1409 brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT) : 1410 -EIO; 1411 } 1412 1413 static int get_lcd_brightness(struct backlight_device *bd) 1414 { 1415 struct toshiba_acpi_dev *dev = bl_get_data(bd); 1416 1417 return __get_lcd_brightness(dev); 1418 } 1419 1420 static int lcd_proc_show(struct seq_file *m, void *v) 1421 { 1422 struct toshiba_acpi_dev *dev = m->private; 1423 int levels; 1424 int value; 1425 1426 if (!dev->backlight_dev) 1427 return -ENODEV; 1428 1429 levels = dev->backlight_dev->props.max_brightness + 1; 1430 value = get_lcd_brightness(dev->backlight_dev); 1431 if (value < 0) { 1432 pr_err("Error reading LCD brightness\n"); 1433 return value; 1434 } 1435 1436 seq_printf(m, "brightness: %d\n", value); 1437 seq_printf(m, "brightness_levels: %d\n", levels); 1438 1439 return 0; 1440 } 1441 1442 static int lcd_proc_open(struct inode *inode, struct file *file) 1443 { 1444 return single_open(file, lcd_proc_show, pde_data(inode)); 1445 } 1446 1447 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value) 1448 { 1449 u32 result; 1450 1451 if (dev->tr_backlight_supported) { 1452 int ret = set_tr_backlight_status(dev, !value); 1453 1454 if (ret) 1455 return ret; 1456 if (value) 1457 value--; 1458 } 1459 1460 value = value << HCI_LCD_BRIGHTNESS_SHIFT; 1461 result = hci_write(dev, HCI_LCD_BRIGHTNESS, value); 1462 if (result == TOS_FAILURE) 1463 pr_err("ACPI call to set LCD Brightness failed\n"); 1464 else if (result == TOS_NOT_SUPPORTED) 1465 return -ENODEV; 1466 1467 return result == TOS_SUCCESS ? 0 : -EIO; 1468 } 1469 1470 static int set_lcd_status(struct backlight_device *bd) 1471 { 1472 struct toshiba_acpi_dev *dev = bl_get_data(bd); 1473 1474 return set_lcd_brightness(dev, bd->props.brightness); 1475 } 1476 1477 static ssize_t lcd_proc_write(struct file *file, const char __user *buf, 1478 size_t count, loff_t *pos) 1479 { 1480 struct toshiba_acpi_dev *dev = pde_data(file_inode(file)); 1481 char cmd[42]; 1482 size_t len; 1483 int levels; 1484 int value; 1485 1486 len = min(count, sizeof(cmd) - 1); 1487 if (copy_from_user(cmd, buf, len)) 1488 return -EFAULT; 1489 cmd[len] = '\0'; 1490 1491 levels = dev->backlight_dev->props.max_brightness + 1; 1492 if (sscanf(cmd, " brightness : %i", &value) != 1 && 1493 value < 0 && value > levels) 1494 return -EINVAL; 1495 1496 if (set_lcd_brightness(dev, value)) 1497 return -EIO; 1498 1499 return count; 1500 } 1501 1502 static const struct proc_ops lcd_proc_ops = { 1503 .proc_open = lcd_proc_open, 1504 .proc_read = seq_read, 1505 .proc_lseek = seq_lseek, 1506 .proc_release = single_release, 1507 .proc_write = lcd_proc_write, 1508 }; 1509 1510 /* Video-Out */ 1511 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status) 1512 { 1513 u32 result = hci_read(dev, HCI_VIDEO_OUT, status); 1514 1515 if (result == TOS_FAILURE) 1516 pr_err("ACPI call to get Video-Out failed\n"); 1517 else if (result == TOS_NOT_SUPPORTED) 1518 return -ENODEV; 1519 1520 return result == TOS_SUCCESS ? 0 : -EIO; 1521 } 1522 1523 static int video_proc_show(struct seq_file *m, void *v) 1524 { 1525 struct toshiba_acpi_dev *dev = m->private; 1526 int is_lcd, is_crt, is_tv; 1527 u32 value; 1528 1529 if (get_video_status(dev, &value)) 1530 return -EIO; 1531 1532 is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0; 1533 is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0; 1534 is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0; 1535 1536 seq_printf(m, "lcd_out: %d\n", is_lcd); 1537 seq_printf(m, "crt_out: %d\n", is_crt); 1538 seq_printf(m, "tv_out: %d\n", is_tv); 1539 1540 return 0; 1541 } 1542 1543 static int video_proc_open(struct inode *inode, struct file *file) 1544 { 1545 return single_open(file, video_proc_show, pde_data(inode)); 1546 } 1547 1548 static ssize_t video_proc_write(struct file *file, const char __user *buf, 1549 size_t count, loff_t *pos) 1550 { 1551 struct toshiba_acpi_dev *dev = pde_data(file_inode(file)); 1552 char *buffer; 1553 char *cmd; 1554 int lcd_out = -1, crt_out = -1, tv_out = -1; 1555 int remain = count; 1556 int value; 1557 int ret; 1558 u32 video_out; 1559 1560 cmd = memdup_user_nul(buf, count); 1561 if (IS_ERR(cmd)) 1562 return PTR_ERR(cmd); 1563 1564 buffer = cmd; 1565 1566 /* 1567 * Scan expression. Multiple expressions may be delimited with ; 1568 * NOTE: To keep scanning simple, invalid fields are ignored. 1569 */ 1570 while (remain) { 1571 if (sscanf(buffer, " lcd_out : %i", &value) == 1) 1572 lcd_out = value & 1; 1573 else if (sscanf(buffer, " crt_out : %i", &value) == 1) 1574 crt_out = value & 1; 1575 else if (sscanf(buffer, " tv_out : %i", &value) == 1) 1576 tv_out = value & 1; 1577 /* Advance to one character past the next ; */ 1578 do { 1579 ++buffer; 1580 --remain; 1581 } while (remain && *(buffer - 1) != ';'); 1582 } 1583 1584 kfree(cmd); 1585 1586 ret = get_video_status(dev, &video_out); 1587 if (!ret) { 1588 unsigned int new_video_out = video_out; 1589 1590 if (lcd_out != -1) 1591 _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out); 1592 if (crt_out != -1) 1593 _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out); 1594 if (tv_out != -1) 1595 _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out); 1596 /* 1597 * To avoid unnecessary video disruption, only write the new 1598 * video setting if something changed. 1599 */ 1600 if (new_video_out != video_out) 1601 ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out); 1602 } 1603 1604 return ret ? -EIO : count; 1605 } 1606 1607 static const struct proc_ops video_proc_ops = { 1608 .proc_open = video_proc_open, 1609 .proc_read = seq_read, 1610 .proc_lseek = seq_lseek, 1611 .proc_release = single_release, 1612 .proc_write = video_proc_write, 1613 }; 1614 1615 /* Fan status */ 1616 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status) 1617 { 1618 u32 result = hci_read(dev, HCI_FAN, status); 1619 1620 if (result == TOS_FAILURE) 1621 pr_err("ACPI call to get Fan status failed\n"); 1622 else if (result == TOS_NOT_SUPPORTED) 1623 return -ENODEV; 1624 1625 return result == TOS_SUCCESS ? 0 : -EIO; 1626 } 1627 1628 static int set_fan_status(struct toshiba_acpi_dev *dev, u32 status) 1629 { 1630 u32 result = hci_write(dev, HCI_FAN, status); 1631 1632 if (result == TOS_FAILURE) 1633 pr_err("ACPI call to set Fan status failed\n"); 1634 else if (result == TOS_NOT_SUPPORTED) 1635 return -ENODEV; 1636 1637 return result == TOS_SUCCESS ? 0 : -EIO; 1638 } 1639 1640 static int fan_proc_show(struct seq_file *m, void *v) 1641 { 1642 struct toshiba_acpi_dev *dev = m->private; 1643 u32 value; 1644 1645 if (get_fan_status(dev, &value)) 1646 return -EIO; 1647 1648 seq_printf(m, "running: %d\n", (value > 0)); 1649 seq_printf(m, "force_on: %d\n", dev->force_fan); 1650 1651 return 0; 1652 } 1653 1654 static int fan_proc_open(struct inode *inode, struct file *file) 1655 { 1656 return single_open(file, fan_proc_show, pde_data(inode)); 1657 } 1658 1659 static ssize_t fan_proc_write(struct file *file, const char __user *buf, 1660 size_t count, loff_t *pos) 1661 { 1662 struct toshiba_acpi_dev *dev = pde_data(file_inode(file)); 1663 char cmd[42]; 1664 size_t len; 1665 int value; 1666 1667 len = min(count, sizeof(cmd) - 1); 1668 if (copy_from_user(cmd, buf, len)) 1669 return -EFAULT; 1670 cmd[len] = '\0'; 1671 1672 if (sscanf(cmd, " force_on : %i", &value) != 1 && 1673 value != 0 && value != 1) 1674 return -EINVAL; 1675 1676 if (set_fan_status(dev, value)) 1677 return -EIO; 1678 1679 dev->force_fan = value; 1680 1681 return count; 1682 } 1683 1684 static const struct proc_ops fan_proc_ops = { 1685 .proc_open = fan_proc_open, 1686 .proc_read = seq_read, 1687 .proc_lseek = seq_lseek, 1688 .proc_release = single_release, 1689 .proc_write = fan_proc_write, 1690 }; 1691 1692 /* Fan RPM */ 1693 static int get_fan_rpm(struct toshiba_acpi_dev *dev, u32 *rpm) 1694 { 1695 u32 in[TCI_WORDS] = { HCI_GET, HCI_FAN_RPM, 0, 1, 0, 0 }; 1696 u32 out[TCI_WORDS]; 1697 acpi_status status = tci_raw(dev, in, out); 1698 1699 if (ACPI_FAILURE(status)) { 1700 pr_err("ACPI call to get Fan speed failed\n"); 1701 return -EIO; 1702 } 1703 1704 if (out[0] == TOS_NOT_SUPPORTED) 1705 return -ENODEV; 1706 1707 if (out[0] == TOS_SUCCESS) { 1708 *rpm = out[2]; 1709 return 0; 1710 } 1711 1712 return -EIO; 1713 } 1714 1715 static int keys_proc_show(struct seq_file *m, void *v) 1716 { 1717 struct toshiba_acpi_dev *dev = m->private; 1718 1719 seq_printf(m, "hotkey_ready: %d\n", dev->key_event_valid); 1720 seq_printf(m, "hotkey: 0x%04x\n", dev->last_key_event); 1721 1722 return 0; 1723 } 1724 1725 static int keys_proc_open(struct inode *inode, struct file *file) 1726 { 1727 return single_open(file, keys_proc_show, pde_data(inode)); 1728 } 1729 1730 static ssize_t keys_proc_write(struct file *file, const char __user *buf, 1731 size_t count, loff_t *pos) 1732 { 1733 struct toshiba_acpi_dev *dev = pde_data(file_inode(file)); 1734 char cmd[42]; 1735 size_t len; 1736 int value; 1737 1738 len = min(count, sizeof(cmd) - 1); 1739 if (copy_from_user(cmd, buf, len)) 1740 return -EFAULT; 1741 cmd[len] = '\0'; 1742 1743 if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) 1744 dev->key_event_valid = 0; 1745 else 1746 return -EINVAL; 1747 1748 return count; 1749 } 1750 1751 static const struct proc_ops keys_proc_ops = { 1752 .proc_open = keys_proc_open, 1753 .proc_read = seq_read, 1754 .proc_lseek = seq_lseek, 1755 .proc_release = single_release, 1756 .proc_write = keys_proc_write, 1757 }; 1758 1759 static int __maybe_unused version_proc_show(struct seq_file *m, void *v) 1760 { 1761 seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION); 1762 seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION); 1763 return 0; 1764 } 1765 1766 /* 1767 * Proc and module init 1768 */ 1769 1770 #define PROC_TOSHIBA "toshiba" 1771 1772 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1773 { 1774 if (dev->backlight_dev) 1775 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1776 &lcd_proc_ops, dev); 1777 if (dev->video_supported) 1778 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1779 &video_proc_ops, dev); 1780 if (dev->fan_supported) 1781 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1782 &fan_proc_ops, dev); 1783 if (dev->hotkey_dev) 1784 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1785 &keys_proc_ops, dev); 1786 proc_create_single_data("version", S_IRUGO, toshiba_proc_dir, 1787 version_proc_show, dev); 1788 } 1789 1790 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1791 { 1792 if (dev->backlight_dev) 1793 remove_proc_entry("lcd", toshiba_proc_dir); 1794 if (dev->video_supported) 1795 remove_proc_entry("video", toshiba_proc_dir); 1796 if (dev->fan_supported) 1797 remove_proc_entry("fan", toshiba_proc_dir); 1798 if (dev->hotkey_dev) 1799 remove_proc_entry("keys", toshiba_proc_dir); 1800 remove_proc_entry("version", toshiba_proc_dir); 1801 } 1802 1803 static const struct backlight_ops toshiba_backlight_data = { 1804 .options = BL_CORE_SUSPENDRESUME, 1805 .get_brightness = get_lcd_brightness, 1806 .update_status = set_lcd_status, 1807 }; 1808 1809 /* Keyboard backlight work */ 1810 static void toshiba_acpi_kbd_bl_work(struct work_struct *work); 1811 1812 static DECLARE_WORK(kbd_bl_work, toshiba_acpi_kbd_bl_work); 1813 1814 /* 1815 * Sysfs files 1816 */ 1817 static ssize_t version_show(struct device *dev, 1818 struct device_attribute *attr, char *buf) 1819 { 1820 return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION); 1821 } 1822 static DEVICE_ATTR_RO(version); 1823 1824 static ssize_t fan_store(struct device *dev, 1825 struct device_attribute *attr, 1826 const char *buf, size_t count) 1827 { 1828 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1829 int state; 1830 int ret; 1831 1832 ret = kstrtoint(buf, 0, &state); 1833 if (ret) 1834 return ret; 1835 1836 if (state != 0 && state != 1) 1837 return -EINVAL; 1838 1839 ret = set_fan_status(toshiba, state); 1840 if (ret) 1841 return ret; 1842 1843 return count; 1844 } 1845 1846 static ssize_t fan_show(struct device *dev, 1847 struct device_attribute *attr, char *buf) 1848 { 1849 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1850 u32 value; 1851 int ret; 1852 1853 ret = get_fan_status(toshiba, &value); 1854 if (ret) 1855 return ret; 1856 1857 return sprintf(buf, "%d\n", value); 1858 } 1859 static DEVICE_ATTR_RW(fan); 1860 1861 static ssize_t kbd_backlight_mode_store(struct device *dev, 1862 struct device_attribute *attr, 1863 const char *buf, size_t count) 1864 { 1865 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1866 int mode; 1867 int ret; 1868 1869 1870 ret = kstrtoint(buf, 0, &mode); 1871 if (ret) 1872 return ret; 1873 1874 /* Check for supported modes depending on keyboard backlight type */ 1875 if (toshiba->kbd_type == 1) { 1876 /* Type 1 supports SCI_KBD_MODE_FNZ and SCI_KBD_MODE_AUTO */ 1877 if (mode != SCI_KBD_MODE_FNZ && mode != SCI_KBD_MODE_AUTO) 1878 return -EINVAL; 1879 } else if (toshiba->kbd_type == 2) { 1880 /* Type 2 doesn't support SCI_KBD_MODE_FNZ */ 1881 if (mode != SCI_KBD_MODE_AUTO && mode != SCI_KBD_MODE_ON && 1882 mode != SCI_KBD_MODE_OFF) 1883 return -EINVAL; 1884 } 1885 1886 /* 1887 * Set the Keyboard Backlight Mode where: 1888 * Auto - KBD backlight turns off automatically in given time 1889 * FN-Z - KBD backlight "toggles" when hotkey pressed 1890 * ON - KBD backlight is always on 1891 * OFF - KBD backlight is always off 1892 */ 1893 1894 /* Only make a change if the actual mode has changed */ 1895 if (toshiba->kbd_mode != mode) { 1896 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */ 1897 int time = toshiba->kbd_time << HCI_MISC_SHIFT; 1898 1899 /* OR the "base time" to the actual method format */ 1900 if (toshiba->kbd_type == 1) { 1901 /* Type 1 requires the current mode */ 1902 time |= toshiba->kbd_mode; 1903 } else if (toshiba->kbd_type == 2) { 1904 /* Type 2 requires the desired mode */ 1905 time |= mode; 1906 } 1907 1908 ret = toshiba_kbd_illum_status_set(toshiba, time); 1909 if (ret) 1910 return ret; 1911 1912 toshiba->kbd_mode = mode; 1913 toshiba_acpi->kbd_mode = mode; 1914 1915 /* 1916 * Some laptop models with the second generation backlit 1917 * keyboard (type 2) do not generate the keyboard backlight 1918 * changed event (0x92), and thus, the driver will never update 1919 * the sysfs entries. 1920 * 1921 * The event is generated right when changing the keyboard 1922 * backlight mode and the *notify function will set the 1923 * kbd_event_generated to true. 1924 * 1925 * In case the event is not generated, schedule the keyboard 1926 * backlight work to update the sysfs entries and emulate the 1927 * event via genetlink. 1928 */ 1929 if (toshiba->kbd_type == 2 && 1930 !toshiba->kbd_event_generated) 1931 schedule_work(&kbd_bl_work); 1932 } 1933 1934 return count; 1935 } 1936 1937 static ssize_t kbd_backlight_mode_show(struct device *dev, 1938 struct device_attribute *attr, 1939 char *buf) 1940 { 1941 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1942 u32 time; 1943 1944 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 1945 return -EIO; 1946 1947 return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK); 1948 } 1949 static DEVICE_ATTR_RW(kbd_backlight_mode); 1950 1951 static ssize_t kbd_type_show(struct device *dev, 1952 struct device_attribute *attr, char *buf) 1953 { 1954 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1955 1956 return sprintf(buf, "%d\n", toshiba->kbd_type); 1957 } 1958 static DEVICE_ATTR_RO(kbd_type); 1959 1960 static ssize_t available_kbd_modes_show(struct device *dev, 1961 struct device_attribute *attr, 1962 char *buf) 1963 { 1964 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1965 1966 if (toshiba->kbd_type == 1) 1967 return sprintf(buf, "0x%x 0x%x\n", 1968 SCI_KBD_MODE_FNZ, SCI_KBD_MODE_AUTO); 1969 1970 return sprintf(buf, "0x%x 0x%x 0x%x\n", 1971 SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF); 1972 } 1973 static DEVICE_ATTR_RO(available_kbd_modes); 1974 1975 static ssize_t kbd_backlight_timeout_store(struct device *dev, 1976 struct device_attribute *attr, 1977 const char *buf, size_t count) 1978 { 1979 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1980 int time; 1981 int ret; 1982 1983 ret = kstrtoint(buf, 0, &time); 1984 if (ret) 1985 return ret; 1986 1987 /* Check for supported values depending on kbd_type */ 1988 if (toshiba->kbd_type == 1) { 1989 if (time < 0 || time > 60) 1990 return -EINVAL; 1991 } else if (toshiba->kbd_type == 2) { 1992 if (time < 1 || time > 60) 1993 return -EINVAL; 1994 } 1995 1996 /* Set the Keyboard Backlight Timeout */ 1997 1998 /* Only make a change if the actual timeout has changed */ 1999 if (toshiba->kbd_time != time) { 2000 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */ 2001 time = time << HCI_MISC_SHIFT; 2002 /* OR the "base time" to the actual method format */ 2003 if (toshiba->kbd_type == 1) 2004 time |= SCI_KBD_MODE_FNZ; 2005 else if (toshiba->kbd_type == 2) 2006 time |= SCI_KBD_MODE_AUTO; 2007 2008 ret = toshiba_kbd_illum_status_set(toshiba, time); 2009 if (ret) 2010 return ret; 2011 2012 toshiba->kbd_time = time >> HCI_MISC_SHIFT; 2013 } 2014 2015 return count; 2016 } 2017 2018 static ssize_t kbd_backlight_timeout_show(struct device *dev, 2019 struct device_attribute *attr, 2020 char *buf) 2021 { 2022 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2023 u32 time; 2024 2025 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 2026 return -EIO; 2027 2028 return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT); 2029 } 2030 static DEVICE_ATTR_RW(kbd_backlight_timeout); 2031 2032 static ssize_t touchpad_store(struct device *dev, 2033 struct device_attribute *attr, 2034 const char *buf, size_t count) 2035 { 2036 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2037 int state; 2038 int ret; 2039 2040 /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */ 2041 ret = kstrtoint(buf, 0, &state); 2042 if (ret) 2043 return ret; 2044 if (state != 0 && state != 1) 2045 return -EINVAL; 2046 2047 ret = toshiba_touchpad_set(toshiba, state); 2048 if (ret) 2049 return ret; 2050 2051 return count; 2052 } 2053 2054 static ssize_t touchpad_show(struct device *dev, 2055 struct device_attribute *attr, char *buf) 2056 { 2057 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2058 u32 state; 2059 int ret; 2060 2061 ret = toshiba_touchpad_get(toshiba, &state); 2062 if (ret < 0) 2063 return ret; 2064 2065 return sprintf(buf, "%i\n", state); 2066 } 2067 static DEVICE_ATTR_RW(touchpad); 2068 2069 static ssize_t usb_sleep_charge_show(struct device *dev, 2070 struct device_attribute *attr, char *buf) 2071 { 2072 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2073 u32 mode; 2074 int ret; 2075 2076 ret = toshiba_usb_sleep_charge_get(toshiba, &mode); 2077 if (ret < 0) 2078 return ret; 2079 2080 return sprintf(buf, "%x\n", mode & SCI_USB_CHARGE_MODE_MASK); 2081 } 2082 2083 static ssize_t usb_sleep_charge_store(struct device *dev, 2084 struct device_attribute *attr, 2085 const char *buf, size_t count) 2086 { 2087 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2088 int state; 2089 u32 mode; 2090 int ret; 2091 2092 ret = kstrtoint(buf, 0, &state); 2093 if (ret) 2094 return ret; 2095 /* 2096 * Check for supported values, where: 2097 * 0 - Disabled 2098 * 1 - Alternate (Non USB conformant devices that require more power) 2099 * 2 - Auto (USB conformant devices) 2100 * 3 - Typical 2101 */ 2102 if (state != 0 && state != 1 && state != 2 && state != 3) 2103 return -EINVAL; 2104 2105 /* Set the USB charging mode to internal value */ 2106 mode = toshiba->usbsc_mode_base; 2107 if (state == 0) 2108 mode |= SCI_USB_CHARGE_DISABLED; 2109 else if (state == 1) 2110 mode |= SCI_USB_CHARGE_ALTERNATE; 2111 else if (state == 2) 2112 mode |= SCI_USB_CHARGE_AUTO; 2113 else if (state == 3) 2114 mode |= SCI_USB_CHARGE_TYPICAL; 2115 2116 ret = toshiba_usb_sleep_charge_set(toshiba, mode); 2117 if (ret) 2118 return ret; 2119 2120 return count; 2121 } 2122 static DEVICE_ATTR_RW(usb_sleep_charge); 2123 2124 static ssize_t sleep_functions_on_battery_show(struct device *dev, 2125 struct device_attribute *attr, 2126 char *buf) 2127 { 2128 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2129 int bat_lvl, status; 2130 u32 state; 2131 int ret; 2132 int tmp; 2133 2134 ret = toshiba_sleep_functions_status_get(toshiba, &state); 2135 if (ret < 0) 2136 return ret; 2137 2138 /* Determine the status: 0x4 - Enabled | 0x1 - Disabled */ 2139 tmp = state & SCI_USB_CHARGE_BAT_MASK; 2140 status = (tmp == 0x4) ? 1 : 0; 2141 /* Determine the battery level set */ 2142 bat_lvl = state >> HCI_MISC_SHIFT; 2143 2144 return sprintf(buf, "%d %d\n", status, bat_lvl); 2145 } 2146 2147 static ssize_t sleep_functions_on_battery_store(struct device *dev, 2148 struct device_attribute *attr, 2149 const char *buf, size_t count) 2150 { 2151 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2152 u32 status; 2153 int value; 2154 int ret; 2155 int tmp; 2156 2157 ret = kstrtoint(buf, 0, &value); 2158 if (ret) 2159 return ret; 2160 2161 /* 2162 * Set the status of the function: 2163 * 0 - Disabled 2164 * 1-100 - Enabled 2165 */ 2166 if (value < 0 || value > 100) 2167 return -EINVAL; 2168 2169 if (value == 0) { 2170 tmp = toshiba->usbsc_bat_level << HCI_MISC_SHIFT; 2171 status = tmp | SCI_USB_CHARGE_BAT_LVL_OFF; 2172 } else { 2173 tmp = value << HCI_MISC_SHIFT; 2174 status = tmp | SCI_USB_CHARGE_BAT_LVL_ON; 2175 } 2176 ret = toshiba_sleep_functions_status_set(toshiba, status); 2177 if (ret < 0) 2178 return ret; 2179 2180 toshiba->usbsc_bat_level = status >> HCI_MISC_SHIFT; 2181 2182 return count; 2183 } 2184 static DEVICE_ATTR_RW(sleep_functions_on_battery); 2185 2186 static ssize_t usb_rapid_charge_show(struct device *dev, 2187 struct device_attribute *attr, char *buf) 2188 { 2189 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2190 u32 state; 2191 int ret; 2192 2193 ret = toshiba_usb_rapid_charge_get(toshiba, &state); 2194 if (ret < 0) 2195 return ret; 2196 2197 return sprintf(buf, "%d\n", state); 2198 } 2199 2200 static ssize_t usb_rapid_charge_store(struct device *dev, 2201 struct device_attribute *attr, 2202 const char *buf, size_t count) 2203 { 2204 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2205 int state; 2206 int ret; 2207 2208 ret = kstrtoint(buf, 0, &state); 2209 if (ret) 2210 return ret; 2211 if (state != 0 && state != 1) 2212 return -EINVAL; 2213 2214 ret = toshiba_usb_rapid_charge_set(toshiba, state); 2215 if (ret) 2216 return ret; 2217 2218 return count; 2219 } 2220 static DEVICE_ATTR_RW(usb_rapid_charge); 2221 2222 static ssize_t usb_sleep_music_show(struct device *dev, 2223 struct device_attribute *attr, char *buf) 2224 { 2225 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2226 u32 state; 2227 int ret; 2228 2229 ret = toshiba_usb_sleep_music_get(toshiba, &state); 2230 if (ret < 0) 2231 return ret; 2232 2233 return sprintf(buf, "%d\n", state); 2234 } 2235 2236 static ssize_t usb_sleep_music_store(struct device *dev, 2237 struct device_attribute *attr, 2238 const char *buf, size_t count) 2239 { 2240 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2241 int state; 2242 int ret; 2243 2244 ret = kstrtoint(buf, 0, &state); 2245 if (ret) 2246 return ret; 2247 if (state != 0 && state != 1) 2248 return -EINVAL; 2249 2250 ret = toshiba_usb_sleep_music_set(toshiba, state); 2251 if (ret) 2252 return ret; 2253 2254 return count; 2255 } 2256 static DEVICE_ATTR_RW(usb_sleep_music); 2257 2258 static ssize_t kbd_function_keys_show(struct device *dev, 2259 struct device_attribute *attr, char *buf) 2260 { 2261 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2262 int mode; 2263 int ret; 2264 2265 ret = toshiba_function_keys_get(toshiba, &mode); 2266 if (ret < 0) 2267 return ret; 2268 2269 return sprintf(buf, "%d\n", mode); 2270 } 2271 2272 static ssize_t kbd_function_keys_store(struct device *dev, 2273 struct device_attribute *attr, 2274 const char *buf, size_t count) 2275 { 2276 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2277 int mode; 2278 int ret; 2279 2280 ret = kstrtoint(buf, 0, &mode); 2281 if (ret) 2282 return ret; 2283 /* 2284 * Check for the function keys mode where: 2285 * 0 - Normal operation (F{1-12} as usual and hotkeys via FN-F{1-12}) 2286 * 1 - Special functions (Opposite of the above setting) 2287 */ 2288 if (mode != 0 && mode != 1) 2289 return -EINVAL; 2290 2291 ret = toshiba_function_keys_set(toshiba, mode); 2292 if (ret) 2293 return ret; 2294 2295 pr_info("Reboot for changes to KBD Function Keys to take effect"); 2296 2297 return count; 2298 } 2299 static DEVICE_ATTR_RW(kbd_function_keys); 2300 2301 static ssize_t panel_power_on_show(struct device *dev, 2302 struct device_attribute *attr, char *buf) 2303 { 2304 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2305 u32 state; 2306 int ret; 2307 2308 ret = toshiba_panel_power_on_get(toshiba, &state); 2309 if (ret < 0) 2310 return ret; 2311 2312 return sprintf(buf, "%d\n", state); 2313 } 2314 2315 static ssize_t panel_power_on_store(struct device *dev, 2316 struct device_attribute *attr, 2317 const char *buf, size_t count) 2318 { 2319 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2320 int state; 2321 int ret; 2322 2323 ret = kstrtoint(buf, 0, &state); 2324 if (ret) 2325 return ret; 2326 if (state != 0 && state != 1) 2327 return -EINVAL; 2328 2329 ret = toshiba_panel_power_on_set(toshiba, state); 2330 if (ret) 2331 return ret; 2332 2333 pr_info("Reboot for changes to Panel Power ON to take effect"); 2334 2335 return count; 2336 } 2337 static DEVICE_ATTR_RW(panel_power_on); 2338 2339 static ssize_t usb_three_show(struct device *dev, 2340 struct device_attribute *attr, char *buf) 2341 { 2342 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2343 u32 state; 2344 int ret; 2345 2346 ret = toshiba_usb_three_get(toshiba, &state); 2347 if (ret < 0) 2348 return ret; 2349 2350 return sprintf(buf, "%d\n", state); 2351 } 2352 2353 static ssize_t usb_three_store(struct device *dev, 2354 struct device_attribute *attr, 2355 const char *buf, size_t count) 2356 { 2357 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2358 int state; 2359 int ret; 2360 2361 ret = kstrtoint(buf, 0, &state); 2362 if (ret) 2363 return ret; 2364 /* 2365 * Check for USB 3 mode where: 2366 * 0 - Disabled (Acts like a USB 2 port, saving power) 2367 * 1 - Enabled 2368 */ 2369 if (state != 0 && state != 1) 2370 return -EINVAL; 2371 2372 ret = toshiba_usb_three_set(toshiba, state); 2373 if (ret) 2374 return ret; 2375 2376 pr_info("Reboot for changes to USB 3 to take effect"); 2377 2378 return count; 2379 } 2380 static DEVICE_ATTR_RW(usb_three); 2381 2382 static ssize_t cooling_method_show(struct device *dev, 2383 struct device_attribute *attr, char *buf) 2384 { 2385 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2386 int state; 2387 int ret; 2388 2389 ret = toshiba_cooling_method_get(toshiba, &state); 2390 if (ret < 0) 2391 return ret; 2392 2393 return sprintf(buf, "%d %d\n", state, toshiba->max_cooling_method); 2394 } 2395 2396 static ssize_t cooling_method_store(struct device *dev, 2397 struct device_attribute *attr, 2398 const char *buf, size_t count) 2399 { 2400 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2401 int state; 2402 int ret; 2403 2404 ret = kstrtoint(buf, 0, &state); 2405 if (ret) 2406 return ret; 2407 2408 /* 2409 * Check for supported values 2410 * Depending on the laptop model, some only support these two: 2411 * 0 - Maximum Performance 2412 * 1 - Battery Optimized 2413 * 2414 * While some others support all three methods: 2415 * 0 - Maximum Performance 2416 * 1 - Performance 2417 * 2 - Battery Optimized 2418 */ 2419 if (state < 0 || state > toshiba->max_cooling_method) 2420 return -EINVAL; 2421 2422 ret = toshiba_cooling_method_set(toshiba, state); 2423 if (ret) 2424 return ret; 2425 2426 return count; 2427 } 2428 static DEVICE_ATTR_RW(cooling_method); 2429 2430 static struct attribute *toshiba_attributes[] = { 2431 &dev_attr_version.attr, 2432 &dev_attr_fan.attr, 2433 &dev_attr_kbd_backlight_mode.attr, 2434 &dev_attr_kbd_type.attr, 2435 &dev_attr_available_kbd_modes.attr, 2436 &dev_attr_kbd_backlight_timeout.attr, 2437 &dev_attr_touchpad.attr, 2438 &dev_attr_usb_sleep_charge.attr, 2439 &dev_attr_sleep_functions_on_battery.attr, 2440 &dev_attr_usb_rapid_charge.attr, 2441 &dev_attr_usb_sleep_music.attr, 2442 &dev_attr_kbd_function_keys.attr, 2443 &dev_attr_panel_power_on.attr, 2444 &dev_attr_usb_three.attr, 2445 &dev_attr_cooling_method.attr, 2446 NULL, 2447 }; 2448 2449 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj, 2450 struct attribute *attr, int idx) 2451 { 2452 struct device *dev = kobj_to_dev(kobj); 2453 struct toshiba_acpi_dev *drv = dev_get_drvdata(dev); 2454 bool exists = true; 2455 2456 if (attr == &dev_attr_fan.attr) 2457 exists = (drv->fan_supported) ? true : false; 2458 else if (attr == &dev_attr_kbd_backlight_mode.attr) 2459 exists = (drv->kbd_illum_supported) ? true : false; 2460 else if (attr == &dev_attr_kbd_backlight_timeout.attr) 2461 exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false; 2462 else if (attr == &dev_attr_touchpad.attr) 2463 exists = (drv->touchpad_supported) ? true : false; 2464 else if (attr == &dev_attr_usb_sleep_charge.attr) 2465 exists = (drv->usb_sleep_charge_supported) ? true : false; 2466 else if (attr == &dev_attr_sleep_functions_on_battery.attr) 2467 exists = (drv->usb_sleep_charge_supported) ? true : false; 2468 else if (attr == &dev_attr_usb_rapid_charge.attr) 2469 exists = (drv->usb_rapid_charge_supported) ? true : false; 2470 else if (attr == &dev_attr_usb_sleep_music.attr) 2471 exists = (drv->usb_sleep_music_supported) ? true : false; 2472 else if (attr == &dev_attr_kbd_function_keys.attr) 2473 exists = (drv->kbd_function_keys_supported) ? true : false; 2474 else if (attr == &dev_attr_panel_power_on.attr) 2475 exists = (drv->panel_power_on_supported) ? true : false; 2476 else if (attr == &dev_attr_usb_three.attr) 2477 exists = (drv->usb_three_supported) ? true : false; 2478 else if (attr == &dev_attr_cooling_method.attr) 2479 exists = (drv->cooling_method_supported) ? true : false; 2480 2481 return exists ? attr->mode : 0; 2482 } 2483 2484 static const struct attribute_group toshiba_attr_group = { 2485 .is_visible = toshiba_sysfs_is_visible, 2486 .attrs = toshiba_attributes, 2487 }; 2488 2489 static void toshiba_acpi_kbd_bl_work(struct work_struct *work) 2490 { 2491 /* Update the sysfs entries */ 2492 if (sysfs_update_group(&toshiba_acpi->acpi_dev->dev.kobj, 2493 &toshiba_attr_group)) 2494 pr_err("Unable to update sysfs entries\n"); 2495 2496 /* Notify LED subsystem about keyboard backlight change */ 2497 if (toshiba_acpi->kbd_type == 2 && 2498 toshiba_acpi->kbd_mode != SCI_KBD_MODE_AUTO) 2499 led_classdev_notify_brightness_hw_changed(&toshiba_acpi->kbd_led, 2500 (toshiba_acpi->kbd_mode == SCI_KBD_MODE_ON) ? 2501 LED_FULL : LED_OFF); 2502 2503 /* Emulate the keyboard backlight event */ 2504 acpi_bus_generate_netlink_event(toshiba_acpi->acpi_dev->pnp.device_class, 2505 dev_name(&toshiba_acpi->acpi_dev->dev), 2506 0x92, 0); 2507 } 2508 2509 /* 2510 * IIO device 2511 */ 2512 2513 enum toshiba_iio_accel_chan { 2514 AXIS_X, 2515 AXIS_Y, 2516 AXIS_Z 2517 }; 2518 2519 static int toshiba_iio_accel_get_axis(enum toshiba_iio_accel_chan chan) 2520 { 2521 u32 xyval, zval; 2522 int ret; 2523 2524 ret = toshiba_accelerometer_get(toshiba_acpi, &xyval, &zval); 2525 if (ret < 0) 2526 return ret; 2527 2528 switch (chan) { 2529 case AXIS_X: 2530 return xyval & HCI_ACCEL_DIRECTION_MASK ? 2531 -(xyval & HCI_ACCEL_MASK) : xyval & HCI_ACCEL_MASK; 2532 case AXIS_Y: 2533 return (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_DIRECTION_MASK ? 2534 -((xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK) : 2535 (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK; 2536 case AXIS_Z: 2537 return zval & HCI_ACCEL_DIRECTION_MASK ? 2538 -(zval & HCI_ACCEL_MASK) : zval & HCI_ACCEL_MASK; 2539 } 2540 2541 return ret; 2542 } 2543 2544 static int toshiba_iio_accel_read_raw(struct iio_dev *indio_dev, 2545 struct iio_chan_spec const *chan, 2546 int *val, int *val2, long mask) 2547 { 2548 int ret; 2549 2550 switch (mask) { 2551 case IIO_CHAN_INFO_RAW: 2552 ret = toshiba_iio_accel_get_axis(chan->channel); 2553 if (ret == -EIO || ret == -ENODEV) 2554 return ret; 2555 2556 *val = ret; 2557 2558 return IIO_VAL_INT; 2559 } 2560 2561 return -EINVAL; 2562 } 2563 2564 #define TOSHIBA_IIO_ACCEL_CHANNEL(axis, chan) { \ 2565 .type = IIO_ACCEL, \ 2566 .modified = 1, \ 2567 .channel = chan, \ 2568 .channel2 = IIO_MOD_##axis, \ 2569 .output = 1, \ 2570 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 2571 } 2572 2573 static const struct iio_chan_spec toshiba_iio_accel_channels[] = { 2574 TOSHIBA_IIO_ACCEL_CHANNEL(X, AXIS_X), 2575 TOSHIBA_IIO_ACCEL_CHANNEL(Y, AXIS_Y), 2576 TOSHIBA_IIO_ACCEL_CHANNEL(Z, AXIS_Z), 2577 }; 2578 2579 static const struct iio_info toshiba_iio_accel_info = { 2580 .read_raw = &toshiba_iio_accel_read_raw, 2581 }; 2582 2583 /* 2584 * Misc device 2585 */ 2586 static int toshiba_acpi_smm_bridge(SMMRegisters *regs) 2587 { 2588 u32 in[TCI_WORDS] = { regs->eax, regs->ebx, regs->ecx, 2589 regs->edx, regs->esi, regs->edi }; 2590 u32 out[TCI_WORDS]; 2591 acpi_status status; 2592 2593 status = tci_raw(toshiba_acpi, in, out); 2594 if (ACPI_FAILURE(status)) { 2595 pr_err("ACPI call to query SMM registers failed\n"); 2596 return -EIO; 2597 } 2598 2599 /* Fillout the SMM struct with the TCI call results */ 2600 regs->eax = out[0]; 2601 regs->ebx = out[1]; 2602 regs->ecx = out[2]; 2603 regs->edx = out[3]; 2604 regs->esi = out[4]; 2605 regs->edi = out[5]; 2606 2607 return 0; 2608 } 2609 2610 static long toshiba_acpi_ioctl(struct file *fp, unsigned int cmd, 2611 unsigned long arg) 2612 { 2613 SMMRegisters __user *argp = (SMMRegisters __user *)arg; 2614 SMMRegisters regs; 2615 int ret; 2616 2617 if (!argp) 2618 return -EINVAL; 2619 2620 switch (cmd) { 2621 case TOSH_SMM: 2622 if (copy_from_user(®s, argp, sizeof(SMMRegisters))) 2623 return -EFAULT; 2624 ret = toshiba_acpi_smm_bridge(®s); 2625 if (ret) 2626 return ret; 2627 if (copy_to_user(argp, ®s, sizeof(SMMRegisters))) 2628 return -EFAULT; 2629 break; 2630 case TOSHIBA_ACPI_SCI: 2631 if (copy_from_user(®s, argp, sizeof(SMMRegisters))) 2632 return -EFAULT; 2633 /* Ensure we are being called with a SCI_{GET, SET} register */ 2634 if (regs.eax != SCI_GET && regs.eax != SCI_SET) 2635 return -EINVAL; 2636 if (!sci_open(toshiba_acpi)) 2637 return -EIO; 2638 ret = toshiba_acpi_smm_bridge(®s); 2639 sci_close(toshiba_acpi); 2640 if (ret) 2641 return ret; 2642 if (copy_to_user(argp, ®s, sizeof(SMMRegisters))) 2643 return -EFAULT; 2644 break; 2645 default: 2646 return -EINVAL; 2647 } 2648 2649 return 0; 2650 } 2651 2652 static const struct file_operations toshiba_acpi_fops = { 2653 .owner = THIS_MODULE, 2654 .unlocked_ioctl = toshiba_acpi_ioctl, 2655 .llseek = noop_llseek, 2656 }; 2657 2658 /* 2659 * WWAN RFKill handlers 2660 */ 2661 static int toshiba_acpi_wwan_set_block(void *data, bool blocked) 2662 { 2663 struct toshiba_acpi_dev *dev = data; 2664 int ret; 2665 2666 ret = toshiba_wireless_status(dev); 2667 if (ret) 2668 return ret; 2669 2670 if (!dev->killswitch) 2671 return 0; 2672 2673 return toshiba_wwan_set(dev, !blocked); 2674 } 2675 2676 static void toshiba_acpi_wwan_poll(struct rfkill *rfkill, void *data) 2677 { 2678 struct toshiba_acpi_dev *dev = data; 2679 2680 if (toshiba_wireless_status(dev)) 2681 return; 2682 2683 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 2684 } 2685 2686 static const struct rfkill_ops wwan_rfk_ops = { 2687 .set_block = toshiba_acpi_wwan_set_block, 2688 .poll = toshiba_acpi_wwan_poll, 2689 }; 2690 2691 static int toshiba_acpi_setup_wwan_rfkill(struct toshiba_acpi_dev *dev) 2692 { 2693 int ret = toshiba_wireless_status(dev); 2694 2695 if (ret) 2696 return ret; 2697 2698 dev->wwan_rfk = rfkill_alloc("Toshiba WWAN", 2699 &dev->acpi_dev->dev, 2700 RFKILL_TYPE_WWAN, 2701 &wwan_rfk_ops, 2702 dev); 2703 if (!dev->wwan_rfk) { 2704 pr_err("Unable to allocate WWAN rfkill device\n"); 2705 return -ENOMEM; 2706 } 2707 2708 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 2709 2710 ret = rfkill_register(dev->wwan_rfk); 2711 if (ret) { 2712 pr_err("Unable to register WWAN rfkill device\n"); 2713 rfkill_destroy(dev->wwan_rfk); 2714 } 2715 2716 return ret; 2717 } 2718 2719 /* 2720 * Hotkeys 2721 */ 2722 static int toshiba_acpi_enable_hotkeys(struct toshiba_acpi_dev *dev) 2723 { 2724 acpi_status status; 2725 u32 result; 2726 2727 status = acpi_evaluate_object(dev->acpi_dev->handle, 2728 "ENAB", NULL, NULL); 2729 if (ACPI_FAILURE(status)) 2730 return -ENODEV; 2731 2732 /* 2733 * Enable the "Special Functions" mode only if they are 2734 * supported and if they are activated. 2735 */ 2736 if (dev->kbd_function_keys_supported && dev->special_functions) 2737 result = hci_write(dev, HCI_HOTKEY_EVENT, 2738 HCI_HOTKEY_SPECIAL_FUNCTIONS); 2739 else 2740 result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE); 2741 2742 if (result == TOS_FAILURE) 2743 return -EIO; 2744 else if (result == TOS_NOT_SUPPORTED) 2745 return -ENODEV; 2746 2747 return 0; 2748 } 2749 2750 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str, 2751 struct serio *port) 2752 { 2753 if (str & I8042_STR_AUXDATA) 2754 return false; 2755 2756 if (unlikely(data == 0xe0)) 2757 return false; 2758 2759 if ((data & 0x7f) == TOS1900_FN_SCAN) { 2760 schedule_work(&toshiba_acpi->hotkey_work); 2761 return true; 2762 } 2763 2764 return false; 2765 } 2766 2767 static void toshiba_acpi_hotkey_work(struct work_struct *work) 2768 { 2769 acpi_handle ec_handle = ec_get_handle(); 2770 acpi_status status; 2771 2772 if (!ec_handle) 2773 return; 2774 2775 status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL); 2776 if (ACPI_FAILURE(status)) 2777 pr_err("ACPI NTFY method execution failed\n"); 2778 } 2779 2780 /* 2781 * Returns hotkey scancode, or < 0 on failure. 2782 */ 2783 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev) 2784 { 2785 unsigned long long value; 2786 acpi_status status; 2787 2788 status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO", 2789 NULL, &value); 2790 if (ACPI_FAILURE(status)) { 2791 pr_err("ACPI INFO method execution failed\n"); 2792 return -EIO; 2793 } 2794 2795 return value; 2796 } 2797 2798 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev, 2799 int scancode) 2800 { 2801 if (scancode == 0x100) 2802 return; 2803 2804 /* Act on key press; ignore key release */ 2805 if (scancode & 0x80) 2806 return; 2807 2808 if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true)) 2809 pr_info("Unknown key %x\n", scancode); 2810 } 2811 2812 static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev) 2813 { 2814 if (dev->info_supported) { 2815 int scancode = toshiba_acpi_query_hotkey(dev); 2816 2817 if (scancode < 0) { 2818 pr_err("Failed to query hotkey event\n"); 2819 } else if (scancode != 0) { 2820 toshiba_acpi_report_hotkey(dev, scancode); 2821 dev->key_event_valid = 1; 2822 dev->last_key_event = scancode; 2823 } 2824 } else if (dev->system_event_supported) { 2825 u32 result; 2826 u32 value; 2827 int retries = 3; 2828 2829 do { 2830 result = hci_read(dev, HCI_SYSTEM_EVENT, &value); 2831 switch (result) { 2832 case TOS_SUCCESS: 2833 toshiba_acpi_report_hotkey(dev, (int)value); 2834 dev->key_event_valid = 1; 2835 dev->last_key_event = value; 2836 break; 2837 case TOS_NOT_SUPPORTED: 2838 /* 2839 * This is a workaround for an unresolved 2840 * issue on some machines where system events 2841 * sporadically become disabled. 2842 */ 2843 result = hci_write(dev, HCI_SYSTEM_EVENT, 1); 2844 if (result == TOS_SUCCESS) 2845 pr_notice("Re-enabled hotkeys\n"); 2846 fallthrough; 2847 default: 2848 retries--; 2849 break; 2850 } 2851 } while (retries && result != TOS_FIFO_EMPTY); 2852 } 2853 } 2854 2855 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev) 2856 { 2857 const struct key_entry *keymap = toshiba_acpi_keymap; 2858 acpi_handle ec_handle; 2859 int error; 2860 2861 if (disable_hotkeys) { 2862 pr_info("Hotkeys disabled by module parameter\n"); 2863 return 0; 2864 } 2865 2866 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) { 2867 pr_info("WMI event detected, hotkeys will not be monitored\n"); 2868 return 0; 2869 } 2870 2871 error = toshiba_acpi_enable_hotkeys(dev); 2872 if (error) 2873 return error; 2874 2875 if (toshiba_hotkey_event_type_get(dev, &dev->hotkey_event_type)) 2876 pr_notice("Unable to query Hotkey Event Type\n"); 2877 2878 dev->hotkey_dev = input_allocate_device(); 2879 if (!dev->hotkey_dev) 2880 return -ENOMEM; 2881 2882 dev->hotkey_dev->name = "Toshiba input device"; 2883 dev->hotkey_dev->phys = "toshiba_acpi/input0"; 2884 dev->hotkey_dev->id.bustype = BUS_HOST; 2885 dev->hotkey_dev->dev.parent = &dev->acpi_dev->dev; 2886 2887 if (dev->hotkey_event_type == HCI_SYSTEM_TYPE1 || 2888 !dev->kbd_function_keys_supported) 2889 keymap = toshiba_acpi_keymap; 2890 else if (dev->hotkey_event_type == HCI_SYSTEM_TYPE2 || 2891 dev->kbd_function_keys_supported) 2892 keymap = toshiba_acpi_alt_keymap; 2893 else 2894 pr_info("Unknown event type received %x\n", 2895 dev->hotkey_event_type); 2896 error = sparse_keymap_setup(dev->hotkey_dev, keymap, NULL); 2897 if (error) 2898 goto err_free_dev; 2899 2900 /* 2901 * For some machines the SCI responsible for providing hotkey 2902 * notification doesn't fire. We can trigger the notification 2903 * whenever the Fn key is pressed using the NTFY method, if 2904 * supported, so if it's present set up an i8042 key filter 2905 * for this purpose. 2906 */ 2907 ec_handle = ec_get_handle(); 2908 if (ec_handle && acpi_has_method(ec_handle, "NTFY")) { 2909 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work); 2910 2911 error = i8042_install_filter(toshiba_acpi_i8042_filter); 2912 if (error) { 2913 pr_err("Error installing key filter\n"); 2914 goto err_free_dev; 2915 } 2916 2917 dev->ntfy_supported = 1; 2918 } 2919 2920 /* 2921 * Determine hotkey query interface. Prefer using the INFO 2922 * method when it is available. 2923 */ 2924 if (acpi_has_method(dev->acpi_dev->handle, "INFO")) 2925 dev->info_supported = 1; 2926 else if (hci_write(dev, HCI_SYSTEM_EVENT, 1) == TOS_SUCCESS) 2927 dev->system_event_supported = 1; 2928 2929 if (!dev->info_supported && !dev->system_event_supported) { 2930 pr_warn("No hotkey query interface found\n"); 2931 error = -EINVAL; 2932 goto err_remove_filter; 2933 } 2934 2935 error = input_register_device(dev->hotkey_dev); 2936 if (error) { 2937 pr_info("Unable to register input device\n"); 2938 goto err_remove_filter; 2939 } 2940 2941 return 0; 2942 2943 err_remove_filter: 2944 if (dev->ntfy_supported) 2945 i8042_remove_filter(toshiba_acpi_i8042_filter); 2946 err_free_dev: 2947 input_free_device(dev->hotkey_dev); 2948 dev->hotkey_dev = NULL; 2949 return error; 2950 } 2951 2952 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev) 2953 { 2954 struct backlight_properties props; 2955 int brightness; 2956 int ret; 2957 2958 /* 2959 * Some machines don't support the backlight methods at all, and 2960 * others support it read-only. Either of these is pretty useless, 2961 * so only register the backlight device if the backlight method 2962 * supports both reads and writes. 2963 */ 2964 brightness = __get_lcd_brightness(dev); 2965 if (brightness < 0) 2966 return 0; 2967 /* 2968 * If transflective backlight is supported and the brightness is zero 2969 * (lowest brightness level), the set_lcd_brightness function will 2970 * activate the transflective backlight, making the LCD appear to be 2971 * turned off, simply increment the brightness level to avoid that. 2972 */ 2973 if (dev->tr_backlight_supported && brightness == 0) 2974 brightness++; 2975 ret = set_lcd_brightness(dev, brightness); 2976 if (ret) { 2977 pr_debug("Backlight method is read-only, disabling backlight support\n"); 2978 return 0; 2979 } 2980 2981 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) 2982 return 0; 2983 2984 memset(&props, 0, sizeof(props)); 2985 props.type = BACKLIGHT_PLATFORM; 2986 props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1; 2987 2988 /* Adding an extra level and having 0 change to transflective mode */ 2989 if (dev->tr_backlight_supported) 2990 props.max_brightness++; 2991 2992 dev->backlight_dev = backlight_device_register("toshiba", 2993 &dev->acpi_dev->dev, 2994 dev, 2995 &toshiba_backlight_data, 2996 &props); 2997 if (IS_ERR(dev->backlight_dev)) { 2998 ret = PTR_ERR(dev->backlight_dev); 2999 pr_err("Could not register toshiba backlight device\n"); 3000 dev->backlight_dev = NULL; 3001 return ret; 3002 } 3003 3004 dev->backlight_dev->props.brightness = brightness; 3005 return 0; 3006 } 3007 3008 /* HWMON support for fan */ 3009 #if IS_ENABLED(CONFIG_HWMON) 3010 static umode_t toshiba_acpi_hwmon_is_visible(const void *drvdata, 3011 enum hwmon_sensor_types type, 3012 u32 attr, int channel) 3013 { 3014 return 0444; 3015 } 3016 3017 static int toshiba_acpi_hwmon_read(struct device *dev, enum hwmon_sensor_types type, 3018 u32 attr, int channel, long *val) 3019 { 3020 /* 3021 * There is only a single channel and single attribute (for the 3022 * fan) at this point. 3023 * This can be replaced with more advanced logic in the future, 3024 * should the need arise. 3025 */ 3026 if (type == hwmon_fan && channel == 0 && attr == hwmon_fan_input) { 3027 u32 value; 3028 int ret; 3029 3030 ret = get_fan_rpm(toshiba_acpi, &value); 3031 if (ret) 3032 return ret; 3033 3034 *val = value; 3035 return 0; 3036 } 3037 return -EOPNOTSUPP; 3038 } 3039 3040 static const struct hwmon_channel_info *toshiba_acpi_hwmon_info[] = { 3041 HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT), 3042 NULL 3043 }; 3044 3045 static const struct hwmon_ops toshiba_acpi_hwmon_ops = { 3046 .is_visible = toshiba_acpi_hwmon_is_visible, 3047 .read = toshiba_acpi_hwmon_read, 3048 }; 3049 3050 static const struct hwmon_chip_info toshiba_acpi_hwmon_chip_info = { 3051 .ops = &toshiba_acpi_hwmon_ops, 3052 .info = toshiba_acpi_hwmon_info, 3053 }; 3054 #endif 3055 3056 /* ACPI battery hooking */ 3057 static ssize_t charge_control_end_threshold_show(struct device *device, 3058 struct device_attribute *attr, 3059 char *buf) 3060 { 3061 u32 state; 3062 int status; 3063 3064 if (toshiba_acpi == NULL) { 3065 pr_err("Toshiba ACPI object invalid\n"); 3066 return -ENODEV; 3067 } 3068 3069 status = toshiba_battery_charge_mode_get(toshiba_acpi, &state); 3070 3071 if (status != 0) 3072 return status; 3073 3074 if (state == 1) 3075 return sprintf(buf, "80\n"); 3076 else 3077 return sprintf(buf, "100\n"); 3078 } 3079 3080 static ssize_t charge_control_end_threshold_store(struct device *dev, 3081 struct device_attribute *attr, 3082 const char *buf, 3083 size_t count) 3084 { 3085 u32 value; 3086 int rval; 3087 3088 if (toshiba_acpi == NULL) { 3089 pr_err("Toshiba ACPI object invalid\n"); 3090 return -ENODEV; 3091 } 3092 3093 rval = kstrtou32(buf, 10, &value); 3094 if (rval) 3095 return rval; 3096 3097 if (value < 1 || value > 100) 3098 return -EINVAL; 3099 rval = toshiba_battery_charge_mode_set(toshiba_acpi, 3100 (value < 90) ? 1 : 0); 3101 if (rval < 0) 3102 return rval; 3103 else 3104 return count; 3105 } 3106 3107 static DEVICE_ATTR_RW(charge_control_end_threshold); 3108 3109 static struct attribute *toshiba_acpi_battery_attrs[] = { 3110 &dev_attr_charge_control_end_threshold.attr, 3111 NULL, 3112 }; 3113 3114 ATTRIBUTE_GROUPS(toshiba_acpi_battery); 3115 3116 static int toshiba_acpi_battery_add(struct power_supply *battery, struct acpi_battery_hook *hook) 3117 { 3118 if (toshiba_acpi == NULL) { 3119 pr_err("Init order issue\n"); 3120 return -ENODEV; 3121 } 3122 if (!toshiba_acpi->battery_charge_mode_supported) 3123 return -ENODEV; 3124 if (device_add_groups(&battery->dev, toshiba_acpi_battery_groups)) 3125 return -ENODEV; 3126 return 0; 3127 } 3128 3129 static int toshiba_acpi_battery_remove(struct power_supply *battery, struct acpi_battery_hook *hook) 3130 { 3131 device_remove_groups(&battery->dev, toshiba_acpi_battery_groups); 3132 return 0; 3133 } 3134 3135 static struct acpi_battery_hook battery_hook = { 3136 .add_battery = toshiba_acpi_battery_add, 3137 .remove_battery = toshiba_acpi_battery_remove, 3138 .name = "Toshiba Battery Extension", 3139 }; 3140 3141 static void print_supported_features(struct toshiba_acpi_dev *dev) 3142 { 3143 pr_info("Supported laptop features:"); 3144 3145 if (dev->hotkey_dev) 3146 pr_cont(" hotkeys"); 3147 if (dev->backlight_dev) 3148 pr_cont(" backlight"); 3149 if (dev->video_supported) 3150 pr_cont(" video-out"); 3151 if (dev->fan_supported) 3152 pr_cont(" fan"); 3153 if (dev->fan_rpm_supported) 3154 pr_cont(" fan-rpm"); 3155 if (dev->tr_backlight_supported) 3156 pr_cont(" transflective-backlight"); 3157 if (dev->illumination_supported) 3158 pr_cont(" illumination"); 3159 if (dev->kbd_illum_supported) 3160 pr_cont(" keyboard-backlight"); 3161 if (dev->touchpad_supported) 3162 pr_cont(" touchpad"); 3163 if (dev->eco_supported) 3164 pr_cont(" eco-led"); 3165 if (dev->accelerometer_supported) 3166 pr_cont(" accelerometer-axes"); 3167 if (dev->usb_sleep_charge_supported) 3168 pr_cont(" usb-sleep-charge"); 3169 if (dev->usb_rapid_charge_supported) 3170 pr_cont(" usb-rapid-charge"); 3171 if (dev->usb_sleep_music_supported) 3172 pr_cont(" usb-sleep-music"); 3173 if (dev->kbd_function_keys_supported) 3174 pr_cont(" special-function-keys"); 3175 if (dev->panel_power_on_supported) 3176 pr_cont(" panel-power-on"); 3177 if (dev->usb_three_supported) 3178 pr_cont(" usb3"); 3179 if (dev->wwan_supported) 3180 pr_cont(" wwan"); 3181 if (dev->cooling_method_supported) 3182 pr_cont(" cooling-method"); 3183 if (dev->battery_charge_mode_supported) 3184 pr_cont(" battery-charge-mode"); 3185 3186 pr_cont("\n"); 3187 } 3188 3189 static void toshiba_acpi_remove(struct acpi_device *acpi_dev) 3190 { 3191 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 3192 3193 misc_deregister(&dev->miscdev); 3194 3195 remove_toshiba_proc_entries(dev); 3196 3197 #if IS_ENABLED(CONFIG_HWMON) 3198 if (dev->hwmon_device) 3199 hwmon_device_unregister(dev->hwmon_device); 3200 #endif 3201 3202 if (dev->accelerometer_supported && dev->indio_dev) { 3203 iio_device_unregister(dev->indio_dev); 3204 iio_device_free(dev->indio_dev); 3205 } 3206 3207 if (dev->sysfs_created) 3208 sysfs_remove_group(&dev->acpi_dev->dev.kobj, 3209 &toshiba_attr_group); 3210 3211 if (dev->ntfy_supported) { 3212 i8042_remove_filter(toshiba_acpi_i8042_filter); 3213 cancel_work_sync(&dev->hotkey_work); 3214 } 3215 3216 if (dev->hotkey_dev) 3217 input_unregister_device(dev->hotkey_dev); 3218 3219 backlight_device_unregister(dev->backlight_dev); 3220 3221 led_classdev_unregister(&dev->led_dev); 3222 led_classdev_unregister(&dev->kbd_led); 3223 led_classdev_unregister(&dev->eco_led); 3224 3225 if (dev->wwan_rfk) { 3226 rfkill_unregister(dev->wwan_rfk); 3227 rfkill_destroy(dev->wwan_rfk); 3228 } 3229 3230 if (dev->battery_charge_mode_supported) 3231 battery_hook_unregister(&battery_hook); 3232 3233 if (toshiba_acpi) 3234 toshiba_acpi = NULL; 3235 3236 kfree(dev); 3237 } 3238 3239 static const char *find_hci_method(acpi_handle handle) 3240 { 3241 if (acpi_has_method(handle, "GHCI")) 3242 return "GHCI"; 3243 3244 if (acpi_has_method(handle, "SPFC")) 3245 return "SPFC"; 3246 3247 return NULL; 3248 } 3249 3250 /* 3251 * Some Toshibas have a broken acpi-video interface for brightness control, 3252 * these are quirked in drivers/acpi/video_detect.c to use the GPU native 3253 * (/sys/class/backlight/intel_backlight) instead. 3254 * But these need a HCI_SET call to actually turn the panel back on at resume, 3255 * without this call the screen stays black at resume. 3256 * Either HCI_LCD_BRIGHTNESS (used by acpi_video's _BCM) or HCI_PANEL_POWER_ON 3257 * works. toshiba_acpi_resume() uses HCI_PANEL_POWER_ON to avoid changing 3258 * the configured brightness level. 3259 */ 3260 static const struct dmi_system_id turn_on_panel_on_resume_dmi_ids[] = { 3261 { 3262 /* Toshiba Portégé R700 */ 3263 /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */ 3264 .matches = { 3265 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 3266 DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"), 3267 }, 3268 }, 3269 { 3270 /* Toshiba Satellite/Portégé R830 */ 3271 /* Portégé: https://bugs.freedesktop.org/show_bug.cgi?id=82634 */ 3272 /* Satellite: https://bugzilla.kernel.org/show_bug.cgi?id=21012 */ 3273 .matches = { 3274 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 3275 DMI_MATCH(DMI_PRODUCT_NAME, "R830"), 3276 }, 3277 }, 3278 { 3279 /* Toshiba Satellite/Portégé Z830 */ 3280 .matches = { 3281 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 3282 DMI_MATCH(DMI_PRODUCT_NAME, "Z830"), 3283 }, 3284 }, 3285 }; 3286 3287 static int toshiba_acpi_add(struct acpi_device *acpi_dev) 3288 { 3289 struct toshiba_acpi_dev *dev; 3290 const char *hci_method; 3291 u32 dummy; 3292 int ret = 0; 3293 3294 if (toshiba_acpi) 3295 return -EBUSY; 3296 3297 pr_info("Toshiba Laptop ACPI Extras version %s\n", 3298 TOSHIBA_ACPI_VERSION); 3299 3300 hci_method = find_hci_method(acpi_dev->handle); 3301 if (!hci_method) { 3302 pr_err("HCI interface not found\n"); 3303 return -ENODEV; 3304 } 3305 3306 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 3307 if (!dev) 3308 return -ENOMEM; 3309 dev->acpi_dev = acpi_dev; 3310 dev->method_hci = hci_method; 3311 dev->miscdev.minor = MISC_DYNAMIC_MINOR; 3312 dev->miscdev.name = "toshiba_acpi"; 3313 dev->miscdev.fops = &toshiba_acpi_fops; 3314 3315 ret = misc_register(&dev->miscdev); 3316 if (ret) { 3317 pr_err("Failed to register miscdevice\n"); 3318 kfree(dev); 3319 return ret; 3320 } 3321 3322 acpi_dev->driver_data = dev; 3323 dev_set_drvdata(&acpi_dev->dev, dev); 3324 3325 /* Query the BIOS for supported features */ 3326 3327 /* 3328 * The "Special Functions" are always supported by the laptops 3329 * with the new keyboard layout, query for its presence to help 3330 * determine the keymap layout to use. 3331 */ 3332 ret = toshiba_function_keys_get(dev, &dev->special_functions); 3333 dev->kbd_function_keys_supported = !ret; 3334 3335 dev->hotkey_event_type = 0; 3336 if (toshiba_acpi_setup_keyboard(dev)) 3337 pr_info("Unable to activate hotkeys\n"); 3338 3339 /* Determine whether or not BIOS supports transflective backlight */ 3340 ret = get_tr_backlight_status(dev, &dummy); 3341 dev->tr_backlight_supported = !ret; 3342 3343 ret = toshiba_acpi_setup_backlight(dev); 3344 if (ret) 3345 goto error; 3346 3347 toshiba_illumination_available(dev); 3348 if (dev->illumination_supported) { 3349 dev->led_dev.name = "toshiba::illumination"; 3350 dev->led_dev.max_brightness = 1; 3351 dev->led_dev.brightness_set = toshiba_illumination_set; 3352 dev->led_dev.brightness_get = toshiba_illumination_get; 3353 led_classdev_register(&acpi_dev->dev, &dev->led_dev); 3354 } 3355 3356 toshiba_eco_mode_available(dev); 3357 if (dev->eco_supported) { 3358 dev->eco_led.name = "toshiba::eco_mode"; 3359 dev->eco_led.max_brightness = 1; 3360 dev->eco_led.brightness_set = toshiba_eco_mode_set_status; 3361 dev->eco_led.brightness_get = toshiba_eco_mode_get_status; 3362 led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led); 3363 } 3364 3365 toshiba_kbd_illum_available(dev); 3366 /* 3367 * Only register the LED if KBD illumination is supported 3368 * and the keyboard backlight operation mode is set to FN-Z 3369 * or we detect a second gen keyboard backlight 3370 */ 3371 if (dev->kbd_illum_supported && 3372 (dev->kbd_mode == SCI_KBD_MODE_FNZ || dev->kbd_type == 2)) { 3373 dev->kbd_led.name = "toshiba::kbd_backlight"; 3374 dev->kbd_led.flags = LED_BRIGHT_HW_CHANGED; 3375 dev->kbd_led.max_brightness = 1; 3376 dev->kbd_led.brightness_set = toshiba_kbd_backlight_set; 3377 dev->kbd_led.brightness_get = toshiba_kbd_backlight_get; 3378 led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led); 3379 } 3380 3381 ret = toshiba_touchpad_get(dev, &dummy); 3382 dev->touchpad_supported = !ret; 3383 3384 toshiba_accelerometer_available(dev); 3385 if (dev->accelerometer_supported) { 3386 dev->indio_dev = iio_device_alloc(&acpi_dev->dev, sizeof(*dev)); 3387 if (!dev->indio_dev) { 3388 pr_err("Unable to allocate iio device\n"); 3389 goto iio_error; 3390 } 3391 3392 pr_info("Registering Toshiba accelerometer iio device\n"); 3393 3394 dev->indio_dev->info = &toshiba_iio_accel_info; 3395 dev->indio_dev->name = "Toshiba accelerometer"; 3396 dev->indio_dev->modes = INDIO_DIRECT_MODE; 3397 dev->indio_dev->channels = toshiba_iio_accel_channels; 3398 dev->indio_dev->num_channels = 3399 ARRAY_SIZE(toshiba_iio_accel_channels); 3400 3401 ret = iio_device_register(dev->indio_dev); 3402 if (ret < 0) { 3403 pr_err("Unable to register iio device\n"); 3404 iio_device_free(dev->indio_dev); 3405 } 3406 } 3407 iio_error: 3408 3409 toshiba_usb_sleep_charge_available(dev); 3410 3411 ret = toshiba_usb_rapid_charge_get(dev, &dummy); 3412 dev->usb_rapid_charge_supported = !ret; 3413 3414 ret = toshiba_usb_sleep_music_get(dev, &dummy); 3415 dev->usb_sleep_music_supported = !ret; 3416 3417 ret = toshiba_panel_power_on_get(dev, &dummy); 3418 dev->panel_power_on_supported = !ret; 3419 3420 ret = toshiba_usb_three_get(dev, &dummy); 3421 dev->usb_three_supported = !ret; 3422 3423 ret = get_video_status(dev, &dummy); 3424 dev->video_supported = !ret; 3425 3426 ret = get_fan_status(dev, &dummy); 3427 dev->fan_supported = !ret; 3428 3429 ret = get_fan_rpm(dev, &dummy); 3430 dev->fan_rpm_supported = !ret; 3431 3432 #if IS_ENABLED(CONFIG_HWMON) 3433 if (dev->fan_rpm_supported) { 3434 dev->hwmon_device = hwmon_device_register_with_info( 3435 &dev->acpi_dev->dev, "toshiba_acpi_sensors", NULL, 3436 &toshiba_acpi_hwmon_chip_info, NULL); 3437 if (IS_ERR(dev->hwmon_device)) { 3438 dev->hwmon_device = NULL; 3439 pr_warn("unable to register hwmon device, skipping\n"); 3440 } 3441 } 3442 #endif 3443 3444 if (turn_on_panel_on_resume == -1) 3445 turn_on_panel_on_resume = dmi_check_system(turn_on_panel_on_resume_dmi_ids); 3446 3447 toshiba_wwan_available(dev); 3448 if (dev->wwan_supported) 3449 toshiba_acpi_setup_wwan_rfkill(dev); 3450 3451 toshiba_cooling_method_available(dev); 3452 3453 toshiba_battery_charge_mode_available(dev); 3454 3455 print_supported_features(dev); 3456 3457 ret = sysfs_create_group(&dev->acpi_dev->dev.kobj, 3458 &toshiba_attr_group); 3459 if (ret) { 3460 dev->sysfs_created = 0; 3461 goto error; 3462 } 3463 dev->sysfs_created = !ret; 3464 3465 create_toshiba_proc_entries(dev); 3466 3467 toshiba_acpi = dev; 3468 3469 /* 3470 * As the battery hook relies on the static variable toshiba_acpi being 3471 * set, this must be done after toshiba_acpi is assigned. 3472 */ 3473 if (dev->battery_charge_mode_supported) 3474 battery_hook_register(&battery_hook); 3475 3476 return 0; 3477 3478 error: 3479 toshiba_acpi_remove(acpi_dev); 3480 return ret; 3481 } 3482 3483 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event) 3484 { 3485 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 3486 3487 switch (event) { 3488 case 0x80: /* Hotkeys and some system events */ 3489 /* 3490 * Machines with this WMI GUID aren't supported due to bugs in 3491 * their AML. 3492 * 3493 * Return silently to avoid triggering a netlink event. 3494 */ 3495 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) 3496 return; 3497 toshiba_acpi_process_hotkeys(dev); 3498 break; 3499 case 0x81: /* Dock events */ 3500 case 0x82: 3501 case 0x83: 3502 pr_info("Dock event received %x\n", event); 3503 break; 3504 case 0x88: /* Thermal events */ 3505 pr_info("Thermal event received\n"); 3506 break; 3507 case 0x8f: /* LID closed */ 3508 case 0x90: /* LID is closed and Dock has been ejected */ 3509 break; 3510 case 0x8c: /* SATA power events */ 3511 case 0x8b: 3512 pr_info("SATA power event received %x\n", event); 3513 break; 3514 case 0x92: /* Keyboard backlight mode changed */ 3515 dev->kbd_event_generated = true; 3516 /* Update sysfs entries */ 3517 if (sysfs_update_group(&acpi_dev->dev.kobj, 3518 &toshiba_attr_group)) 3519 pr_err("Unable to update sysfs entries\n"); 3520 /* Notify LED subsystem about keyboard backlight change */ 3521 if (dev->kbd_type == 2 && dev->kbd_mode != SCI_KBD_MODE_AUTO) 3522 led_classdev_notify_brightness_hw_changed(&dev->kbd_led, 3523 (dev->kbd_mode == SCI_KBD_MODE_ON) ? 3524 LED_FULL : LED_OFF); 3525 break; 3526 case 0x85: /* Unknown */ 3527 case 0x8d: /* Unknown */ 3528 case 0x8e: /* Unknown */ 3529 case 0x94: /* Unknown */ 3530 case 0x95: /* Unknown */ 3531 default: 3532 pr_info("Unknown event received %x\n", event); 3533 break; 3534 } 3535 3536 acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class, 3537 dev_name(&acpi_dev->dev), 3538 event, (event == 0x80) ? 3539 dev->last_key_event : 0); 3540 } 3541 3542 #ifdef CONFIG_PM_SLEEP 3543 static int toshiba_acpi_suspend(struct device *device) 3544 { 3545 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 3546 3547 if (dev->hotkey_dev) { 3548 u32 result; 3549 3550 result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE); 3551 if (result != TOS_SUCCESS) 3552 pr_info("Unable to disable hotkeys\n"); 3553 } 3554 3555 return 0; 3556 } 3557 3558 static int toshiba_acpi_resume(struct device *device) 3559 { 3560 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 3561 3562 if (dev->hotkey_dev) { 3563 if (toshiba_acpi_enable_hotkeys(dev)) 3564 pr_info("Unable to re-enable hotkeys\n"); 3565 } 3566 3567 if (dev->wwan_rfk) { 3568 if (!toshiba_wireless_status(dev)) 3569 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 3570 } 3571 3572 if (turn_on_panel_on_resume) 3573 hci_write(dev, HCI_PANEL_POWER_ON, 1); 3574 3575 return 0; 3576 } 3577 #endif 3578 3579 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm, 3580 toshiba_acpi_suspend, toshiba_acpi_resume); 3581 3582 static struct acpi_driver toshiba_acpi_driver = { 3583 .name = "Toshiba ACPI driver", 3584 .owner = THIS_MODULE, 3585 .ids = toshiba_device_ids, 3586 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 3587 .ops = { 3588 .add = toshiba_acpi_add, 3589 .remove = toshiba_acpi_remove, 3590 .notify = toshiba_acpi_notify, 3591 }, 3592 .drv.pm = &toshiba_acpi_pm, 3593 }; 3594 3595 static int __init toshiba_acpi_init(void) 3596 { 3597 int ret; 3598 3599 toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir); 3600 if (!toshiba_proc_dir) { 3601 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n"); 3602 return -ENODEV; 3603 } 3604 3605 ret = acpi_bus_register_driver(&toshiba_acpi_driver); 3606 if (ret) { 3607 pr_err("Failed to register ACPI driver: %d\n", ret); 3608 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 3609 } 3610 3611 return ret; 3612 } 3613 3614 static void __exit toshiba_acpi_exit(void) 3615 { 3616 acpi_bus_unregister_driver(&toshiba_acpi_driver); 3617 if (toshiba_proc_dir) 3618 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 3619 } 3620 3621 module_init(toshiba_acpi_init); 3622 module_exit(toshiba_acpi_exit); 3623