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