1 /* 2 * toshiba_acpi.c - Toshiba Laptop ACPI Extras 3 * 4 * Copyright (C) 2002-2004 John Belmonte 5 * Copyright (C) 2008 Philip Langdale 6 * Copyright (C) 2010 Pierre Ducroquet 7 * Copyright (C) 2014-2016 Azael Avalos 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * The full GNU General Public License is included in this distribution in 20 * the file called "COPYING". 21 * 22 * The devolpment page for this driver is located at 23 * http://memebeam.org/toys/ToshibaAcpiDriver. 24 * 25 * Credits: 26 * Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse 27 * engineering the Windows drivers 28 * Yasushi Nagato - changes for linux kernel 2.4 -> 2.5 29 * Rob Miller - TV out and hotkeys help 30 */ 31 32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 33 34 #define TOSHIBA_ACPI_VERSION "0.24" 35 #define PROC_INTERFACE_VERSION 1 36 37 #include <linux/kernel.h> 38 #include <linux/module.h> 39 #include <linux/moduleparam.h> 40 #include <linux/init.h> 41 #include <linux/types.h> 42 #include <linux/proc_fs.h> 43 #include <linux/seq_file.h> 44 #include <linux/backlight.h> 45 #include <linux/input.h> 46 #include <linux/input/sparse-keymap.h> 47 #include <linux/leds.h> 48 #include <linux/slab.h> 49 #include <linux/workqueue.h> 50 #include <linux/i8042.h> 51 #include <linux/acpi.h> 52 #include <linux/dmi.h> 53 #include <linux/uaccess.h> 54 #include <linux/miscdevice.h> 55 #include <linux/rfkill.h> 56 #include <linux/iio/iio.h> 57 #include <linux/toshiba.h> 58 #include <acpi/video.h> 59 60 MODULE_AUTHOR("John Belmonte"); 61 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver"); 62 MODULE_LICENSE("GPL"); 63 64 #define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100" 65 66 /* Scan code for Fn key on TOS1900 models */ 67 #define TOS1900_FN_SCAN 0x6e 68 69 /* Toshiba ACPI method paths */ 70 #define METHOD_VIDEO_OUT "\\_SB_.VALX.DSSX" 71 72 /* 73 * The Toshiba configuration interface is composed of the HCI and the SCI, 74 * which are defined as follows: 75 * 76 * HCI is Toshiba's "Hardware Control Interface" which is supposed to 77 * be uniform across all their models. Ideally we would just call 78 * dedicated ACPI methods instead of using this primitive interface. 79 * However the ACPI methods seem to be incomplete in some areas (for 80 * example they allow setting, but not reading, the LCD brightness value), 81 * so this is still useful. 82 * 83 * SCI stands for "System Configuration Interface" which aim is to 84 * conceal differences in hardware between different models. 85 */ 86 87 #define TCI_WORDS 6 88 89 /* Operations */ 90 #define HCI_SET 0xff00 91 #define HCI_GET 0xfe00 92 #define SCI_OPEN 0xf100 93 #define SCI_CLOSE 0xf200 94 #define SCI_GET 0xf300 95 #define SCI_SET 0xf400 96 97 /* Return codes */ 98 #define TOS_SUCCESS 0x0000 99 #define TOS_SUCCESS2 0x0001 100 #define TOS_OPEN_CLOSE_OK 0x0044 101 #define TOS_FAILURE 0x1000 102 #define TOS_NOT_SUPPORTED 0x8000 103 #define TOS_ALREADY_OPEN 0x8100 104 #define TOS_NOT_OPENED 0x8200 105 #define TOS_INPUT_DATA_ERROR 0x8300 106 #define TOS_WRITE_PROTECTED 0x8400 107 #define TOS_NOT_PRESENT 0x8600 108 #define TOS_FIFO_EMPTY 0x8c00 109 #define TOS_DATA_NOT_AVAILABLE 0x8d20 110 #define TOS_NOT_INITIALIZED 0x8d50 111 #define TOS_NOT_INSTALLED 0x8e00 112 113 /* Registers */ 114 #define HCI_FAN 0x0004 115 #define HCI_TR_BACKLIGHT 0x0005 116 #define HCI_SYSTEM_EVENT 0x0016 117 #define HCI_VIDEO_OUT 0x001c 118 #define HCI_HOTKEY_EVENT 0x001e 119 #define HCI_LCD_BRIGHTNESS 0x002a 120 #define HCI_WIRELESS 0x0056 121 #define HCI_ACCELEROMETER 0x006d 122 #define HCI_COOLING_METHOD 0x007f 123 #define HCI_KBD_ILLUMINATION 0x0095 124 #define HCI_ECO_MODE 0x0097 125 #define HCI_ACCELEROMETER2 0x00a6 126 #define HCI_SYSTEM_INFO 0xc000 127 #define SCI_PANEL_POWER_ON 0x010d 128 #define SCI_ILLUMINATION 0x014e 129 #define SCI_USB_SLEEP_CHARGE 0x0150 130 #define SCI_KBD_ILLUM_STATUS 0x015c 131 #define SCI_USB_SLEEP_MUSIC 0x015e 132 #define SCI_USB_THREE 0x0169 133 #define SCI_TOUCHPAD 0x050e 134 #define SCI_KBD_FUNCTION_KEYS 0x0522 135 136 /* Field definitions */ 137 #define HCI_ACCEL_MASK 0x7fff 138 #define HCI_ACCEL_DIRECTION_MASK 0x8000 139 #define HCI_HOTKEY_DISABLE 0x0b 140 #define HCI_HOTKEY_ENABLE 0x09 141 #define HCI_HOTKEY_SPECIAL_FUNCTIONS 0x10 142 #define HCI_LCD_BRIGHTNESS_BITS 3 143 #define HCI_LCD_BRIGHTNESS_SHIFT (16-HCI_LCD_BRIGHTNESS_BITS) 144 #define HCI_LCD_BRIGHTNESS_LEVELS (1 << HCI_LCD_BRIGHTNESS_BITS) 145 #define HCI_MISC_SHIFT 0x10 146 #define HCI_SYSTEM_TYPE1 0x10 147 #define HCI_SYSTEM_TYPE2 0x11 148 #define HCI_VIDEO_OUT_LCD 0x1 149 #define HCI_VIDEO_OUT_CRT 0x2 150 #define HCI_VIDEO_OUT_TV 0x4 151 #define SCI_KBD_MODE_MASK 0x1f 152 #define SCI_KBD_MODE_FNZ 0x1 153 #define SCI_KBD_MODE_AUTO 0x2 154 #define SCI_KBD_MODE_ON 0x8 155 #define SCI_KBD_MODE_OFF 0x10 156 #define SCI_KBD_TIME_MAX 0x3c001a 157 #define HCI_WIRELESS_STATUS 0x1 158 #define HCI_WIRELESS_WWAN 0x3 159 #define HCI_WIRELESS_WWAN_STATUS 0x2000 160 #define HCI_WIRELESS_WWAN_POWER 0x4000 161 #define SCI_USB_CHARGE_MODE_MASK 0xff 162 #define SCI_USB_CHARGE_DISABLED 0x00 163 #define SCI_USB_CHARGE_ALTERNATE 0x09 164 #define SCI_USB_CHARGE_TYPICAL 0x11 165 #define SCI_USB_CHARGE_AUTO 0x21 166 #define SCI_USB_CHARGE_BAT_MASK 0x7 167 #define SCI_USB_CHARGE_BAT_LVL_OFF 0x1 168 #define SCI_USB_CHARGE_BAT_LVL_ON 0x4 169 #define SCI_USB_CHARGE_BAT_LVL 0x0200 170 #define SCI_USB_CHARGE_RAPID_DSP 0x0300 171 172 struct toshiba_acpi_dev { 173 struct acpi_device *acpi_dev; 174 const char *method_hci; 175 struct input_dev *hotkey_dev; 176 struct work_struct hotkey_work; 177 struct backlight_device *backlight_dev; 178 struct led_classdev led_dev; 179 struct led_classdev kbd_led; 180 struct led_classdev eco_led; 181 struct miscdevice miscdev; 182 struct rfkill *wwan_rfk; 183 struct iio_dev *indio_dev; 184 185 int force_fan; 186 int last_key_event; 187 int key_event_valid; 188 int kbd_type; 189 int kbd_mode; 190 int kbd_time; 191 int usbsc_bat_level; 192 int usbsc_mode_base; 193 int hotkey_event_type; 194 int max_cooling_method; 195 196 unsigned int illumination_supported:1; 197 unsigned int video_supported:1; 198 unsigned int fan_supported:1; 199 unsigned int system_event_supported:1; 200 unsigned int ntfy_supported:1; 201 unsigned int info_supported:1; 202 unsigned int tr_backlight_supported:1; 203 unsigned int kbd_illum_supported:1; 204 unsigned int touchpad_supported:1; 205 unsigned int eco_supported:1; 206 unsigned int accelerometer_supported:1; 207 unsigned int usb_sleep_charge_supported:1; 208 unsigned int usb_rapid_charge_supported:1; 209 unsigned int usb_sleep_music_supported:1; 210 unsigned int kbd_function_keys_supported:1; 211 unsigned int panel_power_on_supported:1; 212 unsigned int usb_three_supported:1; 213 unsigned int wwan_supported:1; 214 unsigned int cooling_method_supported:1; 215 unsigned int sysfs_created:1; 216 unsigned int special_functions; 217 218 bool kbd_event_generated; 219 bool kbd_led_registered; 220 bool illumination_led_registered; 221 bool eco_led_registered; 222 bool killswitch; 223 }; 224 225 static struct toshiba_acpi_dev *toshiba_acpi; 226 227 static bool disable_hotkeys; 228 module_param(disable_hotkeys, bool, 0444); 229 MODULE_PARM_DESC(disable_hotkeys, "Disables the hotkeys activation"); 230 231 static const struct acpi_device_id toshiba_device_ids[] = { 232 {"TOS6200", 0}, 233 {"TOS6207", 0}, 234 {"TOS6208", 0}, 235 {"TOS1900", 0}, 236 {"", 0}, 237 }; 238 MODULE_DEVICE_TABLE(acpi, toshiba_device_ids); 239 240 static const struct key_entry toshiba_acpi_keymap[] = { 241 { KE_KEY, 0x9e, { KEY_RFKILL } }, 242 { KE_KEY, 0x101, { KEY_MUTE } }, 243 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 244 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 245 { KE_KEY, 0x10f, { KEY_TAB } }, 246 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 247 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 248 { KE_KEY, 0x13b, { KEY_COFFEE } }, 249 { KE_KEY, 0x13c, { KEY_BATTERY } }, 250 { KE_KEY, 0x13d, { KEY_SLEEP } }, 251 { KE_KEY, 0x13e, { KEY_SUSPEND } }, 252 { KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } }, 253 { KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } }, 254 { KE_KEY, 0x141, { KEY_BRIGHTNESSUP } }, 255 { KE_KEY, 0x142, { KEY_WLAN } }, 256 { KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } }, 257 { KE_KEY, 0x17f, { KEY_FN } }, 258 { KE_KEY, 0xb05, { KEY_PROG2 } }, 259 { KE_KEY, 0xb06, { KEY_WWW } }, 260 { KE_KEY, 0xb07, { KEY_MAIL } }, 261 { KE_KEY, 0xb30, { KEY_STOP } }, 262 { KE_KEY, 0xb31, { KEY_PREVIOUSSONG } }, 263 { KE_KEY, 0xb32, { KEY_NEXTSONG } }, 264 { KE_KEY, 0xb33, { KEY_PLAYPAUSE } }, 265 { KE_KEY, 0xb5a, { KEY_MEDIA } }, 266 { KE_IGNORE, 0x1430, { KEY_RESERVED } }, /* Wake from sleep */ 267 { KE_IGNORE, 0x1501, { KEY_RESERVED } }, /* Output changed */ 268 { KE_IGNORE, 0x1502, { KEY_RESERVED } }, /* HDMI plugged/unplugged */ 269 { KE_IGNORE, 0x1ABE, { KEY_RESERVED } }, /* Protection level set */ 270 { KE_IGNORE, 0x1ABF, { KEY_RESERVED } }, /* Protection level off */ 271 { KE_END, 0 }, 272 }; 273 274 static const struct key_entry toshiba_acpi_alt_keymap[] = { 275 { KE_KEY, 0x102, { KEY_ZOOMOUT } }, 276 { KE_KEY, 0x103, { KEY_ZOOMIN } }, 277 { KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } }, 278 { KE_KEY, 0x139, { KEY_ZOOMRESET } }, 279 { KE_KEY, 0x13c, { KEY_BRIGHTNESSDOWN } }, 280 { KE_KEY, 0x13d, { KEY_BRIGHTNESSUP } }, 281 { KE_KEY, 0x13e, { KEY_SWITCHVIDEOMODE } }, 282 { KE_KEY, 0x13f, { KEY_TOUCHPAD_TOGGLE } }, 283 { KE_KEY, 0x157, { KEY_MUTE } }, 284 { KE_KEY, 0x158, { KEY_WLAN } }, 285 { KE_END, 0 }, 286 }; 287 288 /* 289 * List of models which have a broken acpi-video backlight interface and thus 290 * need to use the toshiba (vendor) interface instead. 291 */ 292 static const struct dmi_system_id toshiba_vendor_backlight_dmi[] = { 293 {} 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 dev->illumination_led_registered = false; 473 474 if (!sci_open(dev)) 475 return; 476 477 status = tci_raw(dev, in, out); 478 sci_close(dev); 479 if (ACPI_FAILURE(status)) { 480 pr_err("ACPI call to query Illumination support failed\n"); 481 return; 482 } 483 484 if (out[0] != TOS_SUCCESS) 485 return; 486 487 dev->illumination_supported = 1; 488 } 489 490 static void toshiba_illumination_set(struct led_classdev *cdev, 491 enum led_brightness brightness) 492 { 493 struct toshiba_acpi_dev *dev = container_of(cdev, 494 struct toshiba_acpi_dev, led_dev); 495 u32 result; 496 u32 state; 497 498 /* First request : initialize communication. */ 499 if (!sci_open(dev)) 500 return; 501 502 /* Switch the illumination on/off */ 503 state = brightness ? 1 : 0; 504 result = sci_write(dev, SCI_ILLUMINATION, state); 505 sci_close(dev); 506 if (result == TOS_FAILURE) 507 pr_err("ACPI call for illumination failed\n"); 508 } 509 510 static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev) 511 { 512 struct toshiba_acpi_dev *dev = container_of(cdev, 513 struct toshiba_acpi_dev, led_dev); 514 u32 result; 515 u32 state; 516 517 /* First request : initialize communication. */ 518 if (!sci_open(dev)) 519 return LED_OFF; 520 521 /* Check the illumination */ 522 result = sci_read(dev, SCI_ILLUMINATION, &state); 523 sci_close(dev); 524 if (result == TOS_FAILURE) { 525 pr_err("ACPI call for illumination failed\n"); 526 return LED_OFF; 527 } else if (result != TOS_SUCCESS) { 528 return LED_OFF; 529 } 530 531 return state ? LED_FULL : LED_OFF; 532 } 533 534 /* KBD Illumination */ 535 static void toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev) 536 { 537 u32 in[TCI_WORDS] = { SCI_GET, SCI_KBD_ILLUM_STATUS, 0, 0, 0, 0 }; 538 u32 out[TCI_WORDS]; 539 acpi_status status; 540 541 dev->kbd_illum_supported = 0; 542 dev->kbd_led_registered = false; 543 dev->kbd_event_generated = false; 544 545 if (!sci_open(dev)) 546 return; 547 548 status = tci_raw(dev, in, out); 549 sci_close(dev); 550 if (ACPI_FAILURE(status)) { 551 pr_err("ACPI call to query kbd illumination support failed\n"); 552 return; 553 } 554 555 if (out[0] != TOS_SUCCESS) 556 return; 557 558 /* 559 * Check for keyboard backlight timeout max value, 560 * previous kbd backlight implementation set this to 561 * 0x3c0003, and now the new implementation set this 562 * to 0x3c001a, use this to distinguish between them. 563 */ 564 if (out[3] == SCI_KBD_TIME_MAX) 565 dev->kbd_type = 2; 566 else 567 dev->kbd_type = 1; 568 /* Get the current keyboard backlight mode */ 569 dev->kbd_mode = out[2] & SCI_KBD_MODE_MASK; 570 /* Get the current time (1-60 seconds) */ 571 dev->kbd_time = out[2] >> HCI_MISC_SHIFT; 572 /* Flag as supported */ 573 dev->kbd_illum_supported = 1; 574 } 575 576 static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time) 577 { 578 u32 result; 579 580 if (!sci_open(dev)) 581 return -EIO; 582 583 result = sci_write(dev, SCI_KBD_ILLUM_STATUS, time); 584 sci_close(dev); 585 if (result == TOS_FAILURE) 586 pr_err("ACPI call to set KBD backlight status failed\n"); 587 else if (result == TOS_NOT_SUPPORTED) 588 return -ENODEV; 589 590 return result == TOS_SUCCESS ? 0 : -EIO; 591 } 592 593 static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time) 594 { 595 u32 result; 596 597 if (!sci_open(dev)) 598 return -EIO; 599 600 result = sci_read(dev, SCI_KBD_ILLUM_STATUS, time); 601 sci_close(dev); 602 if (result == TOS_FAILURE) 603 pr_err("ACPI call to get KBD backlight status failed\n"); 604 else if (result == TOS_NOT_SUPPORTED) 605 return -ENODEV; 606 607 return result == TOS_SUCCESS ? 0 : -EIO; 608 } 609 610 static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev) 611 { 612 struct toshiba_acpi_dev *dev = container_of(cdev, 613 struct toshiba_acpi_dev, kbd_led); 614 u32 result; 615 u32 state; 616 617 /* Check the keyboard backlight state */ 618 result = hci_read(dev, HCI_KBD_ILLUMINATION, &state); 619 if (result == TOS_FAILURE) { 620 pr_err("ACPI call to get the keyboard backlight failed\n"); 621 return LED_OFF; 622 } else if (result != TOS_SUCCESS) { 623 return LED_OFF; 624 } 625 626 return state ? LED_FULL : LED_OFF; 627 } 628 629 static void toshiba_kbd_backlight_set(struct led_classdev *cdev, 630 enum led_brightness brightness) 631 { 632 struct toshiba_acpi_dev *dev = container_of(cdev, 633 struct toshiba_acpi_dev, kbd_led); 634 u32 result; 635 u32 state; 636 637 /* Set the keyboard backlight state */ 638 state = brightness ? 1 : 0; 639 result = hci_write(dev, HCI_KBD_ILLUMINATION, state); 640 if (result == TOS_FAILURE) 641 pr_err("ACPI call to set KBD Illumination mode failed\n"); 642 } 643 644 /* TouchPad support */ 645 static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state) 646 { 647 u32 result; 648 649 if (!sci_open(dev)) 650 return -EIO; 651 652 result = sci_write(dev, SCI_TOUCHPAD, state); 653 sci_close(dev); 654 if (result == TOS_FAILURE) 655 pr_err("ACPI call to set the touchpad failed\n"); 656 else if (result == TOS_NOT_SUPPORTED) 657 return -ENODEV; 658 659 return result == TOS_SUCCESS ? 0 : -EIO; 660 } 661 662 static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state) 663 { 664 u32 result; 665 666 if (!sci_open(dev)) 667 return -EIO; 668 669 result = sci_read(dev, SCI_TOUCHPAD, state); 670 sci_close(dev); 671 if (result == TOS_FAILURE) 672 pr_err("ACPI call to query the touchpad failed\n"); 673 else if (result == TOS_NOT_SUPPORTED) 674 return -ENODEV; 675 676 return result == TOS_SUCCESS ? 0 : -EIO; 677 } 678 679 /* Eco Mode support */ 680 static void toshiba_eco_mode_available(struct toshiba_acpi_dev *dev) 681 { 682 u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 }; 683 u32 out[TCI_WORDS]; 684 acpi_status status; 685 686 dev->eco_supported = 0; 687 dev->eco_led_registered = false; 688 689 status = tci_raw(dev, in, out); 690 if (ACPI_FAILURE(status)) { 691 pr_err("ACPI call to get ECO led failed\n"); 692 return; 693 } 694 695 if (out[0] == TOS_INPUT_DATA_ERROR) { 696 /* 697 * If we receive 0x8300 (Input Data Error), it means that the 698 * LED device is present, but that we just screwed the input 699 * parameters. 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 /* Transflective Backlight */ 1303 static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 *status) 1304 { 1305 u32 result = hci_read(dev, HCI_TR_BACKLIGHT, status); 1306 1307 if (result == TOS_FAILURE) 1308 pr_err("ACPI call to get Transflective Backlight failed\n"); 1309 else if (result == TOS_NOT_SUPPORTED) 1310 return -ENODEV; 1311 1312 return result == TOS_SUCCESS ? 0 : -EIO; 1313 } 1314 1315 static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 status) 1316 { 1317 u32 result = hci_write(dev, HCI_TR_BACKLIGHT, !status); 1318 1319 if (result == TOS_FAILURE) 1320 pr_err("ACPI call to set Transflective Backlight failed\n"); 1321 else if (result == TOS_NOT_SUPPORTED) 1322 return -ENODEV; 1323 1324 return result == TOS_SUCCESS ? 0 : -EIO; 1325 } 1326 1327 static struct proc_dir_entry *toshiba_proc_dir; 1328 1329 /* LCD Brightness */ 1330 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev) 1331 { 1332 int brightness = 0; 1333 u32 result; 1334 u32 value; 1335 1336 if (dev->tr_backlight_supported) { 1337 int ret = get_tr_backlight_status(dev, &value); 1338 1339 if (ret) 1340 return ret; 1341 if (value) 1342 return 0; 1343 brightness++; 1344 } 1345 1346 result = hci_read(dev, HCI_LCD_BRIGHTNESS, &value); 1347 if (result == TOS_FAILURE) 1348 pr_err("ACPI call to get LCD Brightness failed\n"); 1349 else if (result == TOS_NOT_SUPPORTED) 1350 return -ENODEV; 1351 1352 return result == TOS_SUCCESS ? 1353 brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT) : 1354 -EIO; 1355 } 1356 1357 static int get_lcd_brightness(struct backlight_device *bd) 1358 { 1359 struct toshiba_acpi_dev *dev = bl_get_data(bd); 1360 1361 return __get_lcd_brightness(dev); 1362 } 1363 1364 static int lcd_proc_show(struct seq_file *m, void *v) 1365 { 1366 struct toshiba_acpi_dev *dev = m->private; 1367 int levels; 1368 int value; 1369 1370 if (!dev->backlight_dev) 1371 return -ENODEV; 1372 1373 levels = dev->backlight_dev->props.max_brightness + 1; 1374 value = get_lcd_brightness(dev->backlight_dev); 1375 if (value < 0) { 1376 pr_err("Error reading LCD brightness\n"); 1377 return value; 1378 } 1379 1380 seq_printf(m, "brightness: %d\n", value); 1381 seq_printf(m, "brightness_levels: %d\n", levels); 1382 1383 return 0; 1384 } 1385 1386 static int lcd_proc_open(struct inode *inode, struct file *file) 1387 { 1388 return single_open(file, lcd_proc_show, PDE_DATA(inode)); 1389 } 1390 1391 static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value) 1392 { 1393 u32 result; 1394 1395 if (dev->tr_backlight_supported) { 1396 int ret = set_tr_backlight_status(dev, !value); 1397 1398 if (ret) 1399 return ret; 1400 if (value) 1401 value--; 1402 } 1403 1404 value = value << HCI_LCD_BRIGHTNESS_SHIFT; 1405 result = hci_write(dev, HCI_LCD_BRIGHTNESS, value); 1406 if (result == TOS_FAILURE) 1407 pr_err("ACPI call to set LCD Brightness failed\n"); 1408 else if (result == TOS_NOT_SUPPORTED) 1409 return -ENODEV; 1410 1411 return result == TOS_SUCCESS ? 0 : -EIO; 1412 } 1413 1414 static int set_lcd_status(struct backlight_device *bd) 1415 { 1416 struct toshiba_acpi_dev *dev = bl_get_data(bd); 1417 1418 return set_lcd_brightness(dev, bd->props.brightness); 1419 } 1420 1421 static ssize_t lcd_proc_write(struct file *file, const char __user *buf, 1422 size_t count, loff_t *pos) 1423 { 1424 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1425 char cmd[42]; 1426 size_t len; 1427 int levels; 1428 int value; 1429 1430 len = min(count, sizeof(cmd) - 1); 1431 if (copy_from_user(cmd, buf, len)) 1432 return -EFAULT; 1433 cmd[len] = '\0'; 1434 1435 levels = dev->backlight_dev->props.max_brightness + 1; 1436 if (sscanf(cmd, " brightness : %i", &value) != 1 && 1437 value < 0 && value > levels) 1438 return -EINVAL; 1439 1440 if (set_lcd_brightness(dev, value)) 1441 return -EIO; 1442 1443 return count; 1444 } 1445 1446 static const struct file_operations lcd_proc_fops = { 1447 .owner = THIS_MODULE, 1448 .open = lcd_proc_open, 1449 .read = seq_read, 1450 .llseek = seq_lseek, 1451 .release = single_release, 1452 .write = lcd_proc_write, 1453 }; 1454 1455 /* Video-Out */ 1456 static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status) 1457 { 1458 u32 result = hci_read(dev, HCI_VIDEO_OUT, status); 1459 1460 if (result == TOS_FAILURE) 1461 pr_err("ACPI call to get Video-Out failed\n"); 1462 else if (result == TOS_NOT_SUPPORTED) 1463 return -ENODEV; 1464 1465 return result == TOS_SUCCESS ? 0 : -EIO; 1466 } 1467 1468 static int video_proc_show(struct seq_file *m, void *v) 1469 { 1470 struct toshiba_acpi_dev *dev = m->private; 1471 int is_lcd, is_crt, is_tv; 1472 u32 value; 1473 1474 if (get_video_status(dev, &value)) 1475 return -EIO; 1476 1477 is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0; 1478 is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0; 1479 is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0; 1480 1481 seq_printf(m, "lcd_out: %d\n", is_lcd); 1482 seq_printf(m, "crt_out: %d\n", is_crt); 1483 seq_printf(m, "tv_out: %d\n", is_tv); 1484 1485 return 0; 1486 } 1487 1488 static int video_proc_open(struct inode *inode, struct file *file) 1489 { 1490 return single_open(file, video_proc_show, PDE_DATA(inode)); 1491 } 1492 1493 static ssize_t video_proc_write(struct file *file, const char __user *buf, 1494 size_t count, loff_t *pos) 1495 { 1496 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1497 char *buffer; 1498 char *cmd; 1499 int lcd_out, crt_out, tv_out; 1500 int remain = count; 1501 int value; 1502 int ret; 1503 u32 video_out; 1504 1505 cmd = kmalloc(count + 1, GFP_KERNEL); 1506 if (!cmd) 1507 return -ENOMEM; 1508 if (copy_from_user(cmd, buf, count)) { 1509 kfree(cmd); 1510 return -EFAULT; 1511 } 1512 cmd[count] = '\0'; 1513 1514 buffer = cmd; 1515 1516 /* 1517 * Scan expression. Multiple expressions may be delimited with ; 1518 * NOTE: To keep scanning simple, invalid fields are ignored. 1519 */ 1520 while (remain) { 1521 if (sscanf(buffer, " lcd_out : %i", &value) == 1) 1522 lcd_out = value & 1; 1523 else if (sscanf(buffer, " crt_out : %i", &value) == 1) 1524 crt_out = value & 1; 1525 else if (sscanf(buffer, " tv_out : %i", &value) == 1) 1526 tv_out = value & 1; 1527 /* Advance to one character past the next ; */ 1528 do { 1529 ++buffer; 1530 --remain; 1531 } while (remain && *(buffer - 1) != ';'); 1532 } 1533 1534 kfree(cmd); 1535 1536 lcd_out = crt_out = tv_out = -1; 1537 ret = get_video_status(dev, &video_out); 1538 if (!ret) { 1539 unsigned int new_video_out = video_out; 1540 1541 if (lcd_out != -1) 1542 _set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out); 1543 if (crt_out != -1) 1544 _set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out); 1545 if (tv_out != -1) 1546 _set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out); 1547 /* 1548 * To avoid unnecessary video disruption, only write the new 1549 * video setting if something changed. 1550 */ 1551 if (new_video_out != video_out) 1552 ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out); 1553 } 1554 1555 return ret ? -EIO : count; 1556 } 1557 1558 static const struct file_operations video_proc_fops = { 1559 .owner = THIS_MODULE, 1560 .open = video_proc_open, 1561 .read = seq_read, 1562 .llseek = seq_lseek, 1563 .release = single_release, 1564 .write = video_proc_write, 1565 }; 1566 1567 /* Fan status */ 1568 static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status) 1569 { 1570 u32 result = hci_read(dev, HCI_FAN, status); 1571 1572 if (result == TOS_FAILURE) 1573 pr_err("ACPI call to get Fan status failed\n"); 1574 else if (result == TOS_NOT_SUPPORTED) 1575 return -ENODEV; 1576 1577 return result == TOS_SUCCESS ? 0 : -EIO; 1578 } 1579 1580 static int set_fan_status(struct toshiba_acpi_dev *dev, u32 status) 1581 { 1582 u32 result = hci_write(dev, HCI_FAN, status); 1583 1584 if (result == TOS_FAILURE) 1585 pr_err("ACPI call to set Fan status failed\n"); 1586 else if (result == TOS_NOT_SUPPORTED) 1587 return -ENODEV; 1588 1589 return result == TOS_SUCCESS ? 0 : -EIO; 1590 } 1591 1592 static int fan_proc_show(struct seq_file *m, void *v) 1593 { 1594 struct toshiba_acpi_dev *dev = m->private; 1595 u32 value; 1596 1597 if (get_fan_status(dev, &value)) 1598 return -EIO; 1599 1600 seq_printf(m, "running: %d\n", (value > 0)); 1601 seq_printf(m, "force_on: %d\n", dev->force_fan); 1602 1603 return 0; 1604 } 1605 1606 static int fan_proc_open(struct inode *inode, struct file *file) 1607 { 1608 return single_open(file, fan_proc_show, PDE_DATA(inode)); 1609 } 1610 1611 static ssize_t fan_proc_write(struct file *file, const char __user *buf, 1612 size_t count, loff_t *pos) 1613 { 1614 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1615 char cmd[42]; 1616 size_t len; 1617 int value; 1618 1619 len = min(count, sizeof(cmd) - 1); 1620 if (copy_from_user(cmd, buf, len)) 1621 return -EFAULT; 1622 cmd[len] = '\0'; 1623 1624 if (sscanf(cmd, " force_on : %i", &value) != 1 && 1625 value != 0 && value != 1) 1626 return -EINVAL; 1627 1628 if (set_fan_status(dev, value)) 1629 return -EIO; 1630 1631 dev->force_fan = value; 1632 1633 return count; 1634 } 1635 1636 static const struct file_operations fan_proc_fops = { 1637 .owner = THIS_MODULE, 1638 .open = fan_proc_open, 1639 .read = seq_read, 1640 .llseek = seq_lseek, 1641 .release = single_release, 1642 .write = fan_proc_write, 1643 }; 1644 1645 static int keys_proc_show(struct seq_file *m, void *v) 1646 { 1647 struct toshiba_acpi_dev *dev = m->private; 1648 1649 seq_printf(m, "hotkey_ready: %d\n", dev->key_event_valid); 1650 seq_printf(m, "hotkey: 0x%04x\n", dev->last_key_event); 1651 1652 return 0; 1653 } 1654 1655 static int keys_proc_open(struct inode *inode, struct file *file) 1656 { 1657 return single_open(file, keys_proc_show, PDE_DATA(inode)); 1658 } 1659 1660 static ssize_t keys_proc_write(struct file *file, const char __user *buf, 1661 size_t count, loff_t *pos) 1662 { 1663 struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); 1664 char cmd[42]; 1665 size_t len; 1666 int value; 1667 1668 len = min(count, sizeof(cmd) - 1); 1669 if (copy_from_user(cmd, buf, len)) 1670 return -EFAULT; 1671 cmd[len] = '\0'; 1672 1673 if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) 1674 dev->key_event_valid = 0; 1675 else 1676 return -EINVAL; 1677 1678 return count; 1679 } 1680 1681 static const struct file_operations keys_proc_fops = { 1682 .owner = THIS_MODULE, 1683 .open = keys_proc_open, 1684 .read = seq_read, 1685 .llseek = seq_lseek, 1686 .release = single_release, 1687 .write = keys_proc_write, 1688 }; 1689 1690 static int version_proc_show(struct seq_file *m, void *v) 1691 { 1692 seq_printf(m, "driver: %s\n", TOSHIBA_ACPI_VERSION); 1693 seq_printf(m, "proc_interface: %d\n", PROC_INTERFACE_VERSION); 1694 return 0; 1695 } 1696 1697 static int version_proc_open(struct inode *inode, struct file *file) 1698 { 1699 return single_open(file, version_proc_show, PDE_DATA(inode)); 1700 } 1701 1702 static const struct file_operations version_proc_fops = { 1703 .owner = THIS_MODULE, 1704 .open = version_proc_open, 1705 .read = seq_read, 1706 .llseek = seq_lseek, 1707 .release = single_release, 1708 }; 1709 1710 /* 1711 * Proc and module init 1712 */ 1713 1714 #define PROC_TOSHIBA "toshiba" 1715 1716 static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1717 { 1718 if (dev->backlight_dev) 1719 proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1720 &lcd_proc_fops, dev); 1721 if (dev->video_supported) 1722 proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1723 &video_proc_fops, dev); 1724 if (dev->fan_supported) 1725 proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1726 &fan_proc_fops, dev); 1727 if (dev->hotkey_dev) 1728 proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, 1729 &keys_proc_fops, dev); 1730 proc_create_data("version", S_IRUGO, toshiba_proc_dir, 1731 &version_proc_fops, dev); 1732 } 1733 1734 static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev) 1735 { 1736 if (dev->backlight_dev) 1737 remove_proc_entry("lcd", toshiba_proc_dir); 1738 if (dev->video_supported) 1739 remove_proc_entry("video", toshiba_proc_dir); 1740 if (dev->fan_supported) 1741 remove_proc_entry("fan", toshiba_proc_dir); 1742 if (dev->hotkey_dev) 1743 remove_proc_entry("keys", toshiba_proc_dir); 1744 remove_proc_entry("version", toshiba_proc_dir); 1745 } 1746 1747 static const struct backlight_ops toshiba_backlight_data = { 1748 .options = BL_CORE_SUSPENDRESUME, 1749 .get_brightness = get_lcd_brightness, 1750 .update_status = set_lcd_status, 1751 }; 1752 1753 /* Keyboard backlight work */ 1754 static void toshiba_acpi_kbd_bl_work(struct work_struct *work); 1755 1756 static DECLARE_WORK(kbd_bl_work, toshiba_acpi_kbd_bl_work); 1757 1758 /* 1759 * Sysfs files 1760 */ 1761 static ssize_t version_show(struct device *dev, 1762 struct device_attribute *attr, char *buf) 1763 { 1764 return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION); 1765 } 1766 static DEVICE_ATTR_RO(version); 1767 1768 static ssize_t fan_store(struct device *dev, 1769 struct device_attribute *attr, 1770 const char *buf, size_t count) 1771 { 1772 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1773 int state; 1774 int ret; 1775 1776 ret = kstrtoint(buf, 0, &state); 1777 if (ret) 1778 return ret; 1779 1780 if (state != 0 && state != 1) 1781 return -EINVAL; 1782 1783 ret = set_fan_status(toshiba, state); 1784 if (ret) 1785 return ret; 1786 1787 return count; 1788 } 1789 1790 static ssize_t fan_show(struct device *dev, 1791 struct device_attribute *attr, char *buf) 1792 { 1793 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1794 u32 value; 1795 int ret; 1796 1797 ret = get_fan_status(toshiba, &value); 1798 if (ret) 1799 return ret; 1800 1801 return sprintf(buf, "%d\n", value); 1802 } 1803 static DEVICE_ATTR_RW(fan); 1804 1805 static ssize_t kbd_backlight_mode_store(struct device *dev, 1806 struct device_attribute *attr, 1807 const char *buf, size_t count) 1808 { 1809 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1810 int mode; 1811 int ret; 1812 1813 1814 ret = kstrtoint(buf, 0, &mode); 1815 if (ret) 1816 return ret; 1817 1818 /* Check for supported modes depending on keyboard backlight type */ 1819 if (toshiba->kbd_type == 1) { 1820 /* Type 1 supports SCI_KBD_MODE_FNZ and SCI_KBD_MODE_AUTO */ 1821 if (mode != SCI_KBD_MODE_FNZ && mode != SCI_KBD_MODE_AUTO) 1822 return -EINVAL; 1823 } else if (toshiba->kbd_type == 2) { 1824 /* Type 2 doesn't support SCI_KBD_MODE_FNZ */ 1825 if (mode != SCI_KBD_MODE_AUTO && mode != SCI_KBD_MODE_ON && 1826 mode != SCI_KBD_MODE_OFF) 1827 return -EINVAL; 1828 } 1829 1830 /* 1831 * Set the Keyboard Backlight Mode where: 1832 * Auto - KBD backlight turns off automatically in given time 1833 * FN-Z - KBD backlight "toggles" when hotkey pressed 1834 * ON - KBD backlight is always on 1835 * OFF - KBD backlight is always off 1836 */ 1837 1838 /* Only make a change if the actual mode has changed */ 1839 if (toshiba->kbd_mode != mode) { 1840 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */ 1841 int time = toshiba->kbd_time << HCI_MISC_SHIFT; 1842 1843 /* OR the "base time" to the actual method format */ 1844 if (toshiba->kbd_type == 1) { 1845 /* Type 1 requires the current mode */ 1846 time |= toshiba->kbd_mode; 1847 } else if (toshiba->kbd_type == 2) { 1848 /* Type 2 requires the desired mode */ 1849 time |= mode; 1850 } 1851 1852 ret = toshiba_kbd_illum_status_set(toshiba, time); 1853 if (ret) 1854 return ret; 1855 1856 toshiba->kbd_mode = mode; 1857 1858 /* 1859 * Some laptop models with the second generation backlit 1860 * keyboard (type 2) do not generate the keyboard backlight 1861 * changed event (0x92), and thus, the driver will never update 1862 * the sysfs entries. 1863 * 1864 * The event is generated right when changing the keyboard 1865 * backlight mode and the *notify function will set the 1866 * kbd_event_generated to true. 1867 * 1868 * In case the event is not generated, schedule the keyboard 1869 * backlight work to update the sysfs entries and emulate the 1870 * event via genetlink. 1871 */ 1872 if (toshiba->kbd_type == 2 && 1873 !toshiba_acpi->kbd_event_generated) 1874 schedule_work(&kbd_bl_work); 1875 } 1876 1877 return count; 1878 } 1879 1880 static ssize_t kbd_backlight_mode_show(struct device *dev, 1881 struct device_attribute *attr, 1882 char *buf) 1883 { 1884 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1885 u32 time; 1886 1887 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 1888 return -EIO; 1889 1890 return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK); 1891 } 1892 static DEVICE_ATTR_RW(kbd_backlight_mode); 1893 1894 static ssize_t kbd_type_show(struct device *dev, 1895 struct device_attribute *attr, char *buf) 1896 { 1897 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1898 1899 return sprintf(buf, "%d\n", toshiba->kbd_type); 1900 } 1901 static DEVICE_ATTR_RO(kbd_type); 1902 1903 static ssize_t available_kbd_modes_show(struct device *dev, 1904 struct device_attribute *attr, 1905 char *buf) 1906 { 1907 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1908 1909 if (toshiba->kbd_type == 1) 1910 return sprintf(buf, "0x%x 0x%x\n", 1911 SCI_KBD_MODE_FNZ, SCI_KBD_MODE_AUTO); 1912 1913 return sprintf(buf, "0x%x 0x%x 0x%x\n", 1914 SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF); 1915 } 1916 static DEVICE_ATTR_RO(available_kbd_modes); 1917 1918 static ssize_t kbd_backlight_timeout_store(struct device *dev, 1919 struct device_attribute *attr, 1920 const char *buf, size_t count) 1921 { 1922 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1923 int time; 1924 int ret; 1925 1926 ret = kstrtoint(buf, 0, &time); 1927 if (ret) 1928 return ret; 1929 1930 /* Check for supported values depending on kbd_type */ 1931 if (toshiba->kbd_type == 1) { 1932 if (time < 0 || time > 60) 1933 return -EINVAL; 1934 } else if (toshiba->kbd_type == 2) { 1935 if (time < 1 || time > 60) 1936 return -EINVAL; 1937 } 1938 1939 /* Set the Keyboard Backlight Timeout */ 1940 1941 /* Only make a change if the actual timeout has changed */ 1942 if (toshiba->kbd_time != time) { 1943 /* Shift the time to "base time" (0x3c0000 == 60 seconds) */ 1944 time = time << HCI_MISC_SHIFT; 1945 /* OR the "base time" to the actual method format */ 1946 if (toshiba->kbd_type == 1) 1947 time |= SCI_KBD_MODE_FNZ; 1948 else if (toshiba->kbd_type == 2) 1949 time |= SCI_KBD_MODE_AUTO; 1950 1951 ret = toshiba_kbd_illum_status_set(toshiba, time); 1952 if (ret) 1953 return ret; 1954 1955 toshiba->kbd_time = time >> HCI_MISC_SHIFT; 1956 } 1957 1958 return count; 1959 } 1960 1961 static ssize_t kbd_backlight_timeout_show(struct device *dev, 1962 struct device_attribute *attr, 1963 char *buf) 1964 { 1965 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1966 u32 time; 1967 1968 if (toshiba_kbd_illum_status_get(toshiba, &time) < 0) 1969 return -EIO; 1970 1971 return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT); 1972 } 1973 static DEVICE_ATTR_RW(kbd_backlight_timeout); 1974 1975 static ssize_t touchpad_store(struct device *dev, 1976 struct device_attribute *attr, 1977 const char *buf, size_t count) 1978 { 1979 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 1980 int state; 1981 int ret; 1982 1983 /* Set the TouchPad on/off, 0 - Disable | 1 - Enable */ 1984 ret = kstrtoint(buf, 0, &state); 1985 if (ret) 1986 return ret; 1987 if (state != 0 && state != 1) 1988 return -EINVAL; 1989 1990 ret = toshiba_touchpad_set(toshiba, state); 1991 if (ret) 1992 return ret; 1993 1994 return count; 1995 } 1996 1997 static ssize_t touchpad_show(struct device *dev, 1998 struct device_attribute *attr, char *buf) 1999 { 2000 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2001 u32 state; 2002 int ret; 2003 2004 ret = toshiba_touchpad_get(toshiba, &state); 2005 if (ret < 0) 2006 return ret; 2007 2008 return sprintf(buf, "%i\n", state); 2009 } 2010 static DEVICE_ATTR_RW(touchpad); 2011 2012 static ssize_t usb_sleep_charge_show(struct device *dev, 2013 struct device_attribute *attr, char *buf) 2014 { 2015 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2016 u32 mode; 2017 int ret; 2018 2019 ret = toshiba_usb_sleep_charge_get(toshiba, &mode); 2020 if (ret < 0) 2021 return ret; 2022 2023 return sprintf(buf, "%x\n", mode & SCI_USB_CHARGE_MODE_MASK); 2024 } 2025 2026 static ssize_t usb_sleep_charge_store(struct device *dev, 2027 struct device_attribute *attr, 2028 const char *buf, size_t count) 2029 { 2030 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2031 int state; 2032 u32 mode; 2033 int ret; 2034 2035 ret = kstrtoint(buf, 0, &state); 2036 if (ret) 2037 return ret; 2038 /* 2039 * Check for supported values, where: 2040 * 0 - Disabled 2041 * 1 - Alternate (Non USB conformant devices that require more power) 2042 * 2 - Auto (USB conformant devices) 2043 * 3 - Typical 2044 */ 2045 if (state != 0 && state != 1 && state != 2 && state != 3) 2046 return -EINVAL; 2047 2048 /* Set the USB charging mode to internal value */ 2049 mode = toshiba->usbsc_mode_base; 2050 if (state == 0) 2051 mode |= SCI_USB_CHARGE_DISABLED; 2052 else if (state == 1) 2053 mode |= SCI_USB_CHARGE_ALTERNATE; 2054 else if (state == 2) 2055 mode |= SCI_USB_CHARGE_AUTO; 2056 else if (state == 3) 2057 mode |= SCI_USB_CHARGE_TYPICAL; 2058 2059 ret = toshiba_usb_sleep_charge_set(toshiba, mode); 2060 if (ret) 2061 return ret; 2062 2063 return count; 2064 } 2065 static DEVICE_ATTR_RW(usb_sleep_charge); 2066 2067 static ssize_t sleep_functions_on_battery_show(struct device *dev, 2068 struct device_attribute *attr, 2069 char *buf) 2070 { 2071 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2072 int bat_lvl, status; 2073 u32 state; 2074 int ret; 2075 int tmp; 2076 2077 ret = toshiba_sleep_functions_status_get(toshiba, &state); 2078 if (ret < 0) 2079 return ret; 2080 2081 /* Determine the status: 0x4 - Enabled | 0x1 - Disabled */ 2082 tmp = state & SCI_USB_CHARGE_BAT_MASK; 2083 status = (tmp == 0x4) ? 1 : 0; 2084 /* Determine the battery level set */ 2085 bat_lvl = state >> HCI_MISC_SHIFT; 2086 2087 return sprintf(buf, "%d %d\n", status, bat_lvl); 2088 } 2089 2090 static ssize_t sleep_functions_on_battery_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 u32 status; 2096 int value; 2097 int ret; 2098 int tmp; 2099 2100 ret = kstrtoint(buf, 0, &value); 2101 if (ret) 2102 return ret; 2103 2104 /* 2105 * Set the status of the function: 2106 * 0 - Disabled 2107 * 1-100 - Enabled 2108 */ 2109 if (value < 0 || value > 100) 2110 return -EINVAL; 2111 2112 if (value == 0) { 2113 tmp = toshiba->usbsc_bat_level << HCI_MISC_SHIFT; 2114 status = tmp | SCI_USB_CHARGE_BAT_LVL_OFF; 2115 } else { 2116 tmp = value << HCI_MISC_SHIFT; 2117 status = tmp | SCI_USB_CHARGE_BAT_LVL_ON; 2118 } 2119 ret = toshiba_sleep_functions_status_set(toshiba, status); 2120 if (ret < 0) 2121 return ret; 2122 2123 toshiba->usbsc_bat_level = status >> HCI_MISC_SHIFT; 2124 2125 return count; 2126 } 2127 static DEVICE_ATTR_RW(sleep_functions_on_battery); 2128 2129 static ssize_t usb_rapid_charge_show(struct device *dev, 2130 struct device_attribute *attr, char *buf) 2131 { 2132 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2133 u32 state; 2134 int ret; 2135 2136 ret = toshiba_usb_rapid_charge_get(toshiba, &state); 2137 if (ret < 0) 2138 return ret; 2139 2140 return sprintf(buf, "%d\n", state); 2141 } 2142 2143 static ssize_t usb_rapid_charge_store(struct device *dev, 2144 struct device_attribute *attr, 2145 const char *buf, size_t count) 2146 { 2147 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2148 int state; 2149 int ret; 2150 2151 ret = kstrtoint(buf, 0, &state); 2152 if (ret) 2153 return ret; 2154 if (state != 0 && state != 1) 2155 return -EINVAL; 2156 2157 ret = toshiba_usb_rapid_charge_set(toshiba, state); 2158 if (ret) 2159 return ret; 2160 2161 return count; 2162 } 2163 static DEVICE_ATTR_RW(usb_rapid_charge); 2164 2165 static ssize_t usb_sleep_music_show(struct device *dev, 2166 struct device_attribute *attr, char *buf) 2167 { 2168 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2169 u32 state; 2170 int ret; 2171 2172 ret = toshiba_usb_sleep_music_get(toshiba, &state); 2173 if (ret < 0) 2174 return ret; 2175 2176 return sprintf(buf, "%d\n", state); 2177 } 2178 2179 static ssize_t usb_sleep_music_store(struct device *dev, 2180 struct device_attribute *attr, 2181 const char *buf, size_t count) 2182 { 2183 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2184 int state; 2185 int ret; 2186 2187 ret = kstrtoint(buf, 0, &state); 2188 if (ret) 2189 return ret; 2190 if (state != 0 && state != 1) 2191 return -EINVAL; 2192 2193 ret = toshiba_usb_sleep_music_set(toshiba, state); 2194 if (ret) 2195 return ret; 2196 2197 return count; 2198 } 2199 static DEVICE_ATTR_RW(usb_sleep_music); 2200 2201 static ssize_t kbd_function_keys_show(struct device *dev, 2202 struct device_attribute *attr, char *buf) 2203 { 2204 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2205 int mode; 2206 int ret; 2207 2208 ret = toshiba_function_keys_get(toshiba, &mode); 2209 if (ret < 0) 2210 return ret; 2211 2212 return sprintf(buf, "%d\n", mode); 2213 } 2214 2215 static ssize_t kbd_function_keys_store(struct device *dev, 2216 struct device_attribute *attr, 2217 const char *buf, size_t count) 2218 { 2219 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2220 int mode; 2221 int ret; 2222 2223 ret = kstrtoint(buf, 0, &mode); 2224 if (ret) 2225 return ret; 2226 /* 2227 * Check for the function keys mode where: 2228 * 0 - Normal operation (F{1-12} as usual and hotkeys via FN-F{1-12}) 2229 * 1 - Special functions (Opposite of the above setting) 2230 */ 2231 if (mode != 0 && mode != 1) 2232 return -EINVAL; 2233 2234 ret = toshiba_function_keys_set(toshiba, mode); 2235 if (ret) 2236 return ret; 2237 2238 pr_info("Reboot for changes to KBD Function Keys to take effect"); 2239 2240 return count; 2241 } 2242 static DEVICE_ATTR_RW(kbd_function_keys); 2243 2244 static ssize_t panel_power_on_show(struct device *dev, 2245 struct device_attribute *attr, char *buf) 2246 { 2247 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2248 u32 state; 2249 int ret; 2250 2251 ret = toshiba_panel_power_on_get(toshiba, &state); 2252 if (ret < 0) 2253 return ret; 2254 2255 return sprintf(buf, "%d\n", state); 2256 } 2257 2258 static ssize_t panel_power_on_store(struct device *dev, 2259 struct device_attribute *attr, 2260 const char *buf, size_t count) 2261 { 2262 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2263 int state; 2264 int ret; 2265 2266 ret = kstrtoint(buf, 0, &state); 2267 if (ret) 2268 return ret; 2269 if (state != 0 && state != 1) 2270 return -EINVAL; 2271 2272 ret = toshiba_panel_power_on_set(toshiba, state); 2273 if (ret) 2274 return ret; 2275 2276 pr_info("Reboot for changes to Panel Power ON to take effect"); 2277 2278 return count; 2279 } 2280 static DEVICE_ATTR_RW(panel_power_on); 2281 2282 static ssize_t usb_three_show(struct device *dev, 2283 struct device_attribute *attr, char *buf) 2284 { 2285 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2286 u32 state; 2287 int ret; 2288 2289 ret = toshiba_usb_three_get(toshiba, &state); 2290 if (ret < 0) 2291 return ret; 2292 2293 return sprintf(buf, "%d\n", state); 2294 } 2295 2296 static ssize_t usb_three_store(struct device *dev, 2297 struct device_attribute *attr, 2298 const char *buf, size_t count) 2299 { 2300 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2301 int state; 2302 int ret; 2303 2304 ret = kstrtoint(buf, 0, &state); 2305 if (ret) 2306 return ret; 2307 /* 2308 * Check for USB 3 mode where: 2309 * 0 - Disabled (Acts like a USB 2 port, saving power) 2310 * 1 - Enabled 2311 */ 2312 if (state != 0 && state != 1) 2313 return -EINVAL; 2314 2315 ret = toshiba_usb_three_set(toshiba, state); 2316 if (ret) 2317 return ret; 2318 2319 pr_info("Reboot for changes to USB 3 to take effect"); 2320 2321 return count; 2322 } 2323 static DEVICE_ATTR_RW(usb_three); 2324 2325 static ssize_t cooling_method_show(struct device *dev, 2326 struct device_attribute *attr, char *buf) 2327 { 2328 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2329 int state; 2330 int ret; 2331 2332 ret = toshiba_cooling_method_get(toshiba, &state); 2333 if (ret < 0) 2334 return ret; 2335 2336 return sprintf(buf, "%d %d\n", state, toshiba->max_cooling_method); 2337 } 2338 2339 static ssize_t cooling_method_store(struct device *dev, 2340 struct device_attribute *attr, 2341 const char *buf, size_t count) 2342 { 2343 struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev); 2344 int state; 2345 int ret; 2346 2347 ret = kstrtoint(buf, 0, &state); 2348 if (ret) 2349 return ret; 2350 2351 /* 2352 * Check for supported values 2353 * Depending on the laptop model, some only support these two: 2354 * 0 - Maximum Performance 2355 * 1 - Battery Optimized 2356 * 2357 * While some others support all three methods: 2358 * 0 - Maximum Performance 2359 * 1 - Performance 2360 * 2 - Battery Optimized 2361 */ 2362 if (state < 0 || state > toshiba->max_cooling_method) 2363 return -EINVAL; 2364 2365 ret = toshiba_cooling_method_set(toshiba, state); 2366 if (ret) 2367 return ret; 2368 2369 return count; 2370 } 2371 static DEVICE_ATTR_RW(cooling_method); 2372 2373 static struct attribute *toshiba_attributes[] = { 2374 &dev_attr_version.attr, 2375 &dev_attr_fan.attr, 2376 &dev_attr_kbd_backlight_mode.attr, 2377 &dev_attr_kbd_type.attr, 2378 &dev_attr_available_kbd_modes.attr, 2379 &dev_attr_kbd_backlight_timeout.attr, 2380 &dev_attr_touchpad.attr, 2381 &dev_attr_usb_sleep_charge.attr, 2382 &dev_attr_sleep_functions_on_battery.attr, 2383 &dev_attr_usb_rapid_charge.attr, 2384 &dev_attr_usb_sleep_music.attr, 2385 &dev_attr_kbd_function_keys.attr, 2386 &dev_attr_panel_power_on.attr, 2387 &dev_attr_usb_three.attr, 2388 &dev_attr_cooling_method.attr, 2389 NULL, 2390 }; 2391 2392 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj, 2393 struct attribute *attr, int idx) 2394 { 2395 struct device *dev = container_of(kobj, struct device, kobj); 2396 struct toshiba_acpi_dev *drv = dev_get_drvdata(dev); 2397 bool exists = true; 2398 2399 if (attr == &dev_attr_fan.attr) 2400 exists = (drv->fan_supported) ? true : false; 2401 else if (attr == &dev_attr_kbd_backlight_mode.attr) 2402 exists = (drv->kbd_illum_supported) ? true : false; 2403 else if (attr == &dev_attr_kbd_backlight_timeout.attr) 2404 exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false; 2405 else if (attr == &dev_attr_touchpad.attr) 2406 exists = (drv->touchpad_supported) ? true : false; 2407 else if (attr == &dev_attr_usb_sleep_charge.attr) 2408 exists = (drv->usb_sleep_charge_supported) ? true : false; 2409 else if (attr == &dev_attr_sleep_functions_on_battery.attr) 2410 exists = (drv->usb_sleep_charge_supported) ? true : false; 2411 else if (attr == &dev_attr_usb_rapid_charge.attr) 2412 exists = (drv->usb_rapid_charge_supported) ? true : false; 2413 else if (attr == &dev_attr_usb_sleep_music.attr) 2414 exists = (drv->usb_sleep_music_supported) ? true : false; 2415 else if (attr == &dev_attr_kbd_function_keys.attr) 2416 exists = (drv->kbd_function_keys_supported) ? true : false; 2417 else if (attr == &dev_attr_panel_power_on.attr) 2418 exists = (drv->panel_power_on_supported) ? true : false; 2419 else if (attr == &dev_attr_usb_three.attr) 2420 exists = (drv->usb_three_supported) ? true : false; 2421 else if (attr == &dev_attr_cooling_method.attr) 2422 exists = (drv->cooling_method_supported) ? true : false; 2423 2424 return exists ? attr->mode : 0; 2425 } 2426 2427 static struct attribute_group toshiba_attr_group = { 2428 .is_visible = toshiba_sysfs_is_visible, 2429 .attrs = toshiba_attributes, 2430 }; 2431 2432 static void toshiba_acpi_kbd_bl_work(struct work_struct *work) 2433 { 2434 struct acpi_device *acpi_dev = toshiba_acpi->acpi_dev; 2435 2436 /* Update the sysfs entries */ 2437 if (sysfs_update_group(&acpi_dev->dev.kobj, 2438 &toshiba_attr_group)) 2439 pr_err("Unable to update sysfs entries\n"); 2440 2441 /* Emulate the keyboard backlight event */ 2442 acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class, 2443 dev_name(&acpi_dev->dev), 2444 0x92, 0); 2445 } 2446 2447 /* 2448 * IIO device 2449 */ 2450 2451 enum toshiba_iio_accel_chan { 2452 AXIS_X, 2453 AXIS_Y, 2454 AXIS_Z 2455 }; 2456 2457 static int toshiba_iio_accel_get_axis(enum toshiba_iio_accel_chan chan) 2458 { 2459 u32 xyval, zval; 2460 int ret; 2461 2462 ret = toshiba_accelerometer_get(toshiba_acpi, &xyval, &zval); 2463 if (ret < 0) 2464 return ret; 2465 2466 switch (chan) { 2467 case AXIS_X: 2468 return xyval & HCI_ACCEL_DIRECTION_MASK ? 2469 -(xyval & HCI_ACCEL_MASK) : xyval & HCI_ACCEL_MASK; 2470 case AXIS_Y: 2471 return (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_DIRECTION_MASK ? 2472 -((xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK) : 2473 (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK; 2474 case AXIS_Z: 2475 return zval & HCI_ACCEL_DIRECTION_MASK ? 2476 -(zval & HCI_ACCEL_MASK) : zval & HCI_ACCEL_MASK; 2477 } 2478 2479 return ret; 2480 } 2481 2482 static int toshiba_iio_accel_read_raw(struct iio_dev *indio_dev, 2483 struct iio_chan_spec const *chan, 2484 int *val, int *val2, long mask) 2485 { 2486 int ret; 2487 2488 switch (mask) { 2489 case IIO_CHAN_INFO_RAW: 2490 ret = toshiba_iio_accel_get_axis(chan->channel); 2491 if (ret == -EIO || ret == -ENODEV) 2492 return ret; 2493 2494 *val = ret; 2495 2496 return IIO_VAL_INT; 2497 } 2498 2499 return -EINVAL; 2500 } 2501 2502 #define TOSHIBA_IIO_ACCEL_CHANNEL(axis, chan) { \ 2503 .type = IIO_ACCEL, \ 2504 .modified = 1, \ 2505 .channel = chan, \ 2506 .channel2 = IIO_MOD_##axis, \ 2507 .output = 1, \ 2508 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 2509 } 2510 2511 static const struct iio_chan_spec toshiba_iio_accel_channels[] = { 2512 TOSHIBA_IIO_ACCEL_CHANNEL(X, AXIS_X), 2513 TOSHIBA_IIO_ACCEL_CHANNEL(Y, AXIS_Y), 2514 TOSHIBA_IIO_ACCEL_CHANNEL(Z, AXIS_Z), 2515 }; 2516 2517 static const struct iio_info toshiba_iio_accel_info = { 2518 .driver_module = THIS_MODULE, 2519 .read_raw = &toshiba_iio_accel_read_raw, 2520 }; 2521 2522 /* 2523 * Misc device 2524 */ 2525 static int toshiba_acpi_smm_bridge(SMMRegisters *regs) 2526 { 2527 u32 in[TCI_WORDS] = { regs->eax, regs->ebx, regs->ecx, 2528 regs->edx, regs->esi, regs->edi }; 2529 u32 out[TCI_WORDS]; 2530 acpi_status status; 2531 2532 status = tci_raw(toshiba_acpi, in, out); 2533 if (ACPI_FAILURE(status)) { 2534 pr_err("ACPI call to query SMM registers failed\n"); 2535 return -EIO; 2536 } 2537 2538 /* Fillout the SMM struct with the TCI call results */ 2539 regs->eax = out[0]; 2540 regs->ebx = out[1]; 2541 regs->ecx = out[2]; 2542 regs->edx = out[3]; 2543 regs->esi = out[4]; 2544 regs->edi = out[5]; 2545 2546 return 0; 2547 } 2548 2549 static long toshiba_acpi_ioctl(struct file *fp, unsigned int cmd, 2550 unsigned long arg) 2551 { 2552 SMMRegisters __user *argp = (SMMRegisters __user *)arg; 2553 SMMRegisters regs; 2554 int ret; 2555 2556 if (!argp) 2557 return -EINVAL; 2558 2559 switch (cmd) { 2560 case TOSH_SMM: 2561 if (copy_from_user(®s, argp, sizeof(SMMRegisters))) 2562 return -EFAULT; 2563 ret = toshiba_acpi_smm_bridge(®s); 2564 if (ret) 2565 return ret; 2566 if (copy_to_user(argp, ®s, sizeof(SMMRegisters))) 2567 return -EFAULT; 2568 break; 2569 case TOSHIBA_ACPI_SCI: 2570 if (copy_from_user(®s, argp, sizeof(SMMRegisters))) 2571 return -EFAULT; 2572 /* Ensure we are being called with a SCI_{GET, SET} register */ 2573 if (regs.eax != SCI_GET && regs.eax != SCI_SET) 2574 return -EINVAL; 2575 if (!sci_open(toshiba_acpi)) 2576 return -EIO; 2577 ret = toshiba_acpi_smm_bridge(®s); 2578 sci_close(toshiba_acpi); 2579 if (ret) 2580 return ret; 2581 if (copy_to_user(argp, ®s, sizeof(SMMRegisters))) 2582 return -EFAULT; 2583 break; 2584 default: 2585 return -EINVAL; 2586 } 2587 2588 return 0; 2589 } 2590 2591 static const struct file_operations toshiba_acpi_fops = { 2592 .owner = THIS_MODULE, 2593 .unlocked_ioctl = toshiba_acpi_ioctl, 2594 .llseek = noop_llseek, 2595 }; 2596 2597 /* 2598 * WWAN RFKill handlers 2599 */ 2600 static int toshiba_acpi_wwan_set_block(void *data, bool blocked) 2601 { 2602 struct toshiba_acpi_dev *dev = data; 2603 int ret; 2604 2605 ret = toshiba_wireless_status(dev); 2606 if (ret) 2607 return ret; 2608 2609 if (!dev->killswitch) 2610 return 0; 2611 2612 return toshiba_wwan_set(dev, !blocked); 2613 } 2614 2615 static void toshiba_acpi_wwan_poll(struct rfkill *rfkill, void *data) 2616 { 2617 struct toshiba_acpi_dev *dev = data; 2618 2619 if (toshiba_wireless_status(dev)) 2620 return; 2621 2622 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 2623 } 2624 2625 static const struct rfkill_ops wwan_rfk_ops = { 2626 .set_block = toshiba_acpi_wwan_set_block, 2627 .poll = toshiba_acpi_wwan_poll, 2628 }; 2629 2630 static int toshiba_acpi_setup_wwan_rfkill(struct toshiba_acpi_dev *dev) 2631 { 2632 int ret = toshiba_wireless_status(dev); 2633 2634 if (ret) 2635 return ret; 2636 2637 dev->wwan_rfk = rfkill_alloc("Toshiba WWAN", 2638 &dev->acpi_dev->dev, 2639 RFKILL_TYPE_WWAN, 2640 &wwan_rfk_ops, 2641 dev); 2642 if (!dev->wwan_rfk) { 2643 pr_err("Unable to allocate WWAN rfkill device\n"); 2644 return -ENOMEM; 2645 } 2646 2647 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 2648 2649 ret = rfkill_register(dev->wwan_rfk); 2650 if (ret) { 2651 pr_err("Unable to register WWAN rfkill device\n"); 2652 rfkill_destroy(dev->wwan_rfk); 2653 } 2654 2655 return ret; 2656 } 2657 2658 /* 2659 * Hotkeys 2660 */ 2661 static int toshiba_acpi_enable_hotkeys(struct toshiba_acpi_dev *dev) 2662 { 2663 acpi_status status; 2664 u32 result; 2665 2666 status = acpi_evaluate_object(dev->acpi_dev->handle, 2667 "ENAB", NULL, NULL); 2668 if (ACPI_FAILURE(status)) 2669 return -ENODEV; 2670 2671 /* 2672 * Enable the "Special Functions" mode only if they are 2673 * supported and if they are activated. 2674 */ 2675 if (dev->kbd_function_keys_supported && dev->special_functions) 2676 result = hci_write(dev, HCI_HOTKEY_EVENT, 2677 HCI_HOTKEY_SPECIAL_FUNCTIONS); 2678 else 2679 result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE); 2680 2681 if (result == TOS_FAILURE) 2682 return -EIO; 2683 else if (result == TOS_NOT_SUPPORTED) 2684 return -ENODEV; 2685 2686 return 0; 2687 } 2688 2689 static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str, 2690 struct serio *port) 2691 { 2692 if (str & I8042_STR_AUXDATA) 2693 return false; 2694 2695 if (unlikely(data == 0xe0)) 2696 return false; 2697 2698 if ((data & 0x7f) == TOS1900_FN_SCAN) { 2699 schedule_work(&toshiba_acpi->hotkey_work); 2700 return true; 2701 } 2702 2703 return false; 2704 } 2705 2706 static void toshiba_acpi_hotkey_work(struct work_struct *work) 2707 { 2708 acpi_handle ec_handle = ec_get_handle(); 2709 acpi_status status; 2710 2711 if (!ec_handle) 2712 return; 2713 2714 status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL); 2715 if (ACPI_FAILURE(status)) 2716 pr_err("ACPI NTFY method execution failed\n"); 2717 } 2718 2719 /* 2720 * Returns hotkey scancode, or < 0 on failure. 2721 */ 2722 static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev) 2723 { 2724 unsigned long long value; 2725 acpi_status status; 2726 2727 status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO", 2728 NULL, &value); 2729 if (ACPI_FAILURE(status)) { 2730 pr_err("ACPI INFO method execution failed\n"); 2731 return -EIO; 2732 } 2733 2734 return value; 2735 } 2736 2737 static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev, 2738 int scancode) 2739 { 2740 if (scancode == 0x100) 2741 return; 2742 2743 /* Act on key press; ignore key release */ 2744 if (scancode & 0x80) 2745 return; 2746 2747 if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true)) 2748 pr_info("Unknown key %x\n", scancode); 2749 } 2750 2751 static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev) 2752 { 2753 if (dev->info_supported) { 2754 int scancode = toshiba_acpi_query_hotkey(dev); 2755 2756 if (scancode < 0) { 2757 pr_err("Failed to query hotkey event\n"); 2758 } else if (scancode != 0) { 2759 toshiba_acpi_report_hotkey(dev, scancode); 2760 dev->key_event_valid = 1; 2761 dev->last_key_event = scancode; 2762 } 2763 } else if (dev->system_event_supported) { 2764 u32 result; 2765 u32 value; 2766 int retries = 3; 2767 2768 do { 2769 result = hci_read(dev, HCI_SYSTEM_EVENT, &value); 2770 switch (result) { 2771 case TOS_SUCCESS: 2772 toshiba_acpi_report_hotkey(dev, (int)value); 2773 dev->key_event_valid = 1; 2774 dev->last_key_event = value; 2775 break; 2776 case TOS_NOT_SUPPORTED: 2777 /* 2778 * This is a workaround for an unresolved 2779 * issue on some machines where system events 2780 * sporadically become disabled. 2781 */ 2782 result = hci_write(dev, HCI_SYSTEM_EVENT, 1); 2783 if (result == TOS_SUCCESS) 2784 pr_notice("Re-enabled hotkeys\n"); 2785 /* Fall through */ 2786 default: 2787 retries--; 2788 break; 2789 } 2790 } while (retries && result != TOS_FIFO_EMPTY); 2791 } 2792 } 2793 2794 static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev) 2795 { 2796 const struct key_entry *keymap = toshiba_acpi_keymap; 2797 acpi_handle ec_handle; 2798 int error; 2799 2800 if (disable_hotkeys) { 2801 pr_info("Hotkeys disabled by module parameter\n"); 2802 return 0; 2803 } 2804 2805 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) { 2806 pr_info("WMI event detected, hotkeys will not be monitored\n"); 2807 return 0; 2808 } 2809 2810 error = toshiba_acpi_enable_hotkeys(dev); 2811 if (error) 2812 return error; 2813 2814 if (toshiba_hotkey_event_type_get(dev, &dev->hotkey_event_type)) 2815 pr_notice("Unable to query Hotkey Event Type\n"); 2816 2817 dev->hotkey_dev = input_allocate_device(); 2818 if (!dev->hotkey_dev) 2819 return -ENOMEM; 2820 2821 dev->hotkey_dev->name = "Toshiba input device"; 2822 dev->hotkey_dev->phys = "toshiba_acpi/input0"; 2823 dev->hotkey_dev->id.bustype = BUS_HOST; 2824 2825 if (dev->hotkey_event_type == HCI_SYSTEM_TYPE1 || 2826 !dev->kbd_function_keys_supported) 2827 keymap = toshiba_acpi_keymap; 2828 else if (dev->hotkey_event_type == HCI_SYSTEM_TYPE2 || 2829 dev->kbd_function_keys_supported) 2830 keymap = toshiba_acpi_alt_keymap; 2831 else 2832 pr_info("Unknown event type received %x\n", 2833 dev->hotkey_event_type); 2834 error = sparse_keymap_setup(dev->hotkey_dev, keymap, NULL); 2835 if (error) 2836 goto err_free_dev; 2837 2838 /* 2839 * For some machines the SCI responsible for providing hotkey 2840 * notification doesn't fire. We can trigger the notification 2841 * whenever the Fn key is pressed using the NTFY method, if 2842 * supported, so if it's present set up an i8042 key filter 2843 * for this purpose. 2844 */ 2845 ec_handle = ec_get_handle(); 2846 if (ec_handle && acpi_has_method(ec_handle, "NTFY")) { 2847 INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work); 2848 2849 error = i8042_install_filter(toshiba_acpi_i8042_filter); 2850 if (error) { 2851 pr_err("Error installing key filter\n"); 2852 goto err_free_keymap; 2853 } 2854 2855 dev->ntfy_supported = 1; 2856 } 2857 2858 /* 2859 * Determine hotkey query interface. Prefer using the INFO 2860 * method when it is available. 2861 */ 2862 if (acpi_has_method(dev->acpi_dev->handle, "INFO")) 2863 dev->info_supported = 1; 2864 else if (hci_write(dev, HCI_SYSTEM_EVENT, 1) == TOS_SUCCESS) 2865 dev->system_event_supported = 1; 2866 2867 if (!dev->info_supported && !dev->system_event_supported) { 2868 pr_warn("No hotkey query interface found\n"); 2869 goto err_remove_filter; 2870 } 2871 2872 error = input_register_device(dev->hotkey_dev); 2873 if (error) { 2874 pr_info("Unable to register input device\n"); 2875 goto err_remove_filter; 2876 } 2877 2878 return 0; 2879 2880 err_remove_filter: 2881 if (dev->ntfy_supported) 2882 i8042_remove_filter(toshiba_acpi_i8042_filter); 2883 err_free_keymap: 2884 sparse_keymap_free(dev->hotkey_dev); 2885 err_free_dev: 2886 input_free_device(dev->hotkey_dev); 2887 dev->hotkey_dev = NULL; 2888 return error; 2889 } 2890 2891 static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev) 2892 { 2893 struct backlight_properties props; 2894 int brightness; 2895 int ret; 2896 2897 /* 2898 * Some machines don't support the backlight methods at all, and 2899 * others support it read-only. Either of these is pretty useless, 2900 * so only register the backlight device if the backlight method 2901 * supports both reads and writes. 2902 */ 2903 brightness = __get_lcd_brightness(dev); 2904 if (brightness < 0) 2905 return 0; 2906 /* 2907 * If transflective backlight is supported and the brightness is zero 2908 * (lowest brightness level), the set_lcd_brightness function will 2909 * activate the transflective backlight, making the LCD appear to be 2910 * turned off, simply increment the brightness level to avoid that. 2911 */ 2912 if (dev->tr_backlight_supported && brightness == 0) 2913 brightness++; 2914 ret = set_lcd_brightness(dev, brightness); 2915 if (ret) { 2916 pr_debug("Backlight method is read-only, disabling backlight support\n"); 2917 return 0; 2918 } 2919 2920 /* 2921 * Tell acpi-video-detect code to prefer vendor backlight on all 2922 * systems with transflective backlight and on dmi matched systems. 2923 */ 2924 if (dev->tr_backlight_supported || 2925 dmi_check_system(toshiba_vendor_backlight_dmi)) 2926 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 2927 2928 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) 2929 return 0; 2930 2931 memset(&props, 0, sizeof(props)); 2932 props.type = BACKLIGHT_PLATFORM; 2933 props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1; 2934 2935 /* Adding an extra level and having 0 change to transflective mode */ 2936 if (dev->tr_backlight_supported) 2937 props.max_brightness++; 2938 2939 dev->backlight_dev = backlight_device_register("toshiba", 2940 &dev->acpi_dev->dev, 2941 dev, 2942 &toshiba_backlight_data, 2943 &props); 2944 if (IS_ERR(dev->backlight_dev)) { 2945 ret = PTR_ERR(dev->backlight_dev); 2946 pr_err("Could not register toshiba backlight device\n"); 2947 dev->backlight_dev = NULL; 2948 return ret; 2949 } 2950 2951 dev->backlight_dev->props.brightness = brightness; 2952 return 0; 2953 } 2954 2955 static void print_supported_features(struct toshiba_acpi_dev *dev) 2956 { 2957 pr_info("Supported laptop features:"); 2958 2959 if (dev->hotkey_dev) 2960 pr_cont(" hotkeys"); 2961 if (dev->backlight_dev) 2962 pr_cont(" backlight"); 2963 if (dev->video_supported) 2964 pr_cont(" video-out"); 2965 if (dev->fan_supported) 2966 pr_cont(" fan"); 2967 if (dev->tr_backlight_supported) 2968 pr_cont(" transflective-backlight"); 2969 if (dev->illumination_supported) 2970 pr_cont(" illumination"); 2971 if (dev->kbd_illum_supported) 2972 pr_cont(" keyboard-backlight"); 2973 if (dev->touchpad_supported) 2974 pr_cont(" touchpad"); 2975 if (dev->eco_supported) 2976 pr_cont(" eco-led"); 2977 if (dev->accelerometer_supported) 2978 pr_cont(" accelerometer-axes"); 2979 if (dev->usb_sleep_charge_supported) 2980 pr_cont(" usb-sleep-charge"); 2981 if (dev->usb_rapid_charge_supported) 2982 pr_cont(" usb-rapid-charge"); 2983 if (dev->usb_sleep_music_supported) 2984 pr_cont(" usb-sleep-music"); 2985 if (dev->kbd_function_keys_supported) 2986 pr_cont(" special-function-keys"); 2987 if (dev->panel_power_on_supported) 2988 pr_cont(" panel-power-on"); 2989 if (dev->usb_three_supported) 2990 pr_cont(" usb3"); 2991 if (dev->wwan_supported) 2992 pr_cont(" wwan"); 2993 if (dev->cooling_method_supported) 2994 pr_cont(" cooling-method"); 2995 2996 pr_cont("\n"); 2997 } 2998 2999 static int toshiba_acpi_remove(struct acpi_device *acpi_dev) 3000 { 3001 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 3002 3003 misc_deregister(&dev->miscdev); 3004 3005 remove_toshiba_proc_entries(dev); 3006 3007 if (dev->accelerometer_supported && dev->indio_dev) { 3008 iio_device_unregister(dev->indio_dev); 3009 iio_device_free(dev->indio_dev); 3010 } 3011 3012 if (dev->sysfs_created) 3013 sysfs_remove_group(&dev->acpi_dev->dev.kobj, 3014 &toshiba_attr_group); 3015 3016 if (dev->ntfy_supported) { 3017 i8042_remove_filter(toshiba_acpi_i8042_filter); 3018 cancel_work_sync(&dev->hotkey_work); 3019 } 3020 3021 if (dev->hotkey_dev) { 3022 input_unregister_device(dev->hotkey_dev); 3023 sparse_keymap_free(dev->hotkey_dev); 3024 } 3025 3026 backlight_device_unregister(dev->backlight_dev); 3027 3028 if (dev->illumination_led_registered) 3029 led_classdev_unregister(&dev->led_dev); 3030 3031 if (dev->kbd_led_registered) 3032 led_classdev_unregister(&dev->kbd_led); 3033 3034 if (dev->eco_led_registered) 3035 led_classdev_unregister(&dev->eco_led); 3036 3037 if (dev->wwan_rfk) { 3038 rfkill_unregister(dev->wwan_rfk); 3039 rfkill_destroy(dev->wwan_rfk); 3040 } 3041 3042 if (toshiba_acpi) 3043 toshiba_acpi = NULL; 3044 3045 kfree(dev); 3046 3047 return 0; 3048 } 3049 3050 static const char *find_hci_method(acpi_handle handle) 3051 { 3052 if (acpi_has_method(handle, "GHCI")) 3053 return "GHCI"; 3054 3055 if (acpi_has_method(handle, "SPFC")) 3056 return "SPFC"; 3057 3058 return NULL; 3059 } 3060 3061 static int toshiba_acpi_add(struct acpi_device *acpi_dev) 3062 { 3063 struct toshiba_acpi_dev *dev; 3064 const char *hci_method; 3065 u32 dummy; 3066 int ret = 0; 3067 3068 if (toshiba_acpi) 3069 return -EBUSY; 3070 3071 pr_info("Toshiba Laptop ACPI Extras version %s\n", 3072 TOSHIBA_ACPI_VERSION); 3073 3074 hci_method = find_hci_method(acpi_dev->handle); 3075 if (!hci_method) { 3076 pr_err("HCI interface not found\n"); 3077 return -ENODEV; 3078 } 3079 3080 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 3081 if (!dev) 3082 return -ENOMEM; 3083 dev->acpi_dev = acpi_dev; 3084 dev->method_hci = hci_method; 3085 dev->miscdev.minor = MISC_DYNAMIC_MINOR; 3086 dev->miscdev.name = "toshiba_acpi"; 3087 dev->miscdev.fops = &toshiba_acpi_fops; 3088 3089 ret = misc_register(&dev->miscdev); 3090 if (ret) { 3091 pr_err("Failed to register miscdevice\n"); 3092 kfree(dev); 3093 return ret; 3094 } 3095 3096 acpi_dev->driver_data = dev; 3097 dev_set_drvdata(&acpi_dev->dev, dev); 3098 3099 /* Query the BIOS for supported features */ 3100 3101 /* 3102 * The "Special Functions" are always supported by the laptops 3103 * with the new keyboard layout, query for its presence to help 3104 * determine the keymap layout to use. 3105 */ 3106 ret = toshiba_function_keys_get(dev, &dev->special_functions); 3107 dev->kbd_function_keys_supported = !ret; 3108 3109 dev->hotkey_event_type = 0; 3110 if (toshiba_acpi_setup_keyboard(dev)) 3111 pr_info("Unable to activate hotkeys\n"); 3112 3113 /* Determine whether or not BIOS supports transflective backlight */ 3114 ret = get_tr_backlight_status(dev, &dummy); 3115 dev->tr_backlight_supported = !ret; 3116 3117 ret = toshiba_acpi_setup_backlight(dev); 3118 if (ret) 3119 goto error; 3120 3121 toshiba_illumination_available(dev); 3122 if (dev->illumination_supported) { 3123 dev->led_dev.name = "toshiba::illumination"; 3124 dev->led_dev.max_brightness = 1; 3125 dev->led_dev.brightness_set = toshiba_illumination_set; 3126 dev->led_dev.brightness_get = toshiba_illumination_get; 3127 if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev)) 3128 dev->illumination_led_registered = true; 3129 } 3130 3131 toshiba_eco_mode_available(dev); 3132 if (dev->eco_supported) { 3133 dev->eco_led.name = "toshiba::eco_mode"; 3134 dev->eco_led.max_brightness = 1; 3135 dev->eco_led.brightness_set = toshiba_eco_mode_set_status; 3136 dev->eco_led.brightness_get = toshiba_eco_mode_get_status; 3137 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led)) 3138 dev->eco_led_registered = true; 3139 } 3140 3141 toshiba_kbd_illum_available(dev); 3142 /* 3143 * Only register the LED if KBD illumination is supported 3144 * and the keyboard backlight operation mode is set to FN-Z 3145 */ 3146 if (dev->kbd_illum_supported && dev->kbd_mode == SCI_KBD_MODE_FNZ) { 3147 dev->kbd_led.name = "toshiba::kbd_backlight"; 3148 dev->kbd_led.max_brightness = 1; 3149 dev->kbd_led.brightness_set = toshiba_kbd_backlight_set; 3150 dev->kbd_led.brightness_get = toshiba_kbd_backlight_get; 3151 if (!led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led)) 3152 dev->kbd_led_registered = true; 3153 } 3154 3155 ret = toshiba_touchpad_get(dev, &dummy); 3156 dev->touchpad_supported = !ret; 3157 3158 toshiba_accelerometer_available(dev); 3159 if (dev->accelerometer_supported) { 3160 dev->indio_dev = iio_device_alloc(sizeof(*dev)); 3161 if (!dev->indio_dev) { 3162 pr_err("Unable to allocate iio device\n"); 3163 goto iio_error; 3164 } 3165 3166 pr_info("Registering Toshiba accelerometer iio device\n"); 3167 3168 dev->indio_dev->info = &toshiba_iio_accel_info; 3169 dev->indio_dev->name = "Toshiba accelerometer"; 3170 dev->indio_dev->dev.parent = &acpi_dev->dev; 3171 dev->indio_dev->modes = INDIO_DIRECT_MODE; 3172 dev->indio_dev->channels = toshiba_iio_accel_channels; 3173 dev->indio_dev->num_channels = 3174 ARRAY_SIZE(toshiba_iio_accel_channels); 3175 3176 ret = iio_device_register(dev->indio_dev); 3177 if (ret < 0) { 3178 pr_err("Unable to register iio device\n"); 3179 iio_device_free(dev->indio_dev); 3180 } 3181 } 3182 iio_error: 3183 3184 toshiba_usb_sleep_charge_available(dev); 3185 3186 ret = toshiba_usb_rapid_charge_get(dev, &dummy); 3187 dev->usb_rapid_charge_supported = !ret; 3188 3189 ret = toshiba_usb_sleep_music_get(dev, &dummy); 3190 dev->usb_sleep_music_supported = !ret; 3191 3192 ret = toshiba_panel_power_on_get(dev, &dummy); 3193 dev->panel_power_on_supported = !ret; 3194 3195 ret = toshiba_usb_three_get(dev, &dummy); 3196 dev->usb_three_supported = !ret; 3197 3198 ret = get_video_status(dev, &dummy); 3199 dev->video_supported = !ret; 3200 3201 ret = get_fan_status(dev, &dummy); 3202 dev->fan_supported = !ret; 3203 3204 toshiba_wwan_available(dev); 3205 if (dev->wwan_supported) 3206 toshiba_acpi_setup_wwan_rfkill(dev); 3207 3208 toshiba_cooling_method_available(dev); 3209 3210 print_supported_features(dev); 3211 3212 ret = sysfs_create_group(&dev->acpi_dev->dev.kobj, 3213 &toshiba_attr_group); 3214 if (ret) { 3215 dev->sysfs_created = 0; 3216 goto error; 3217 } 3218 dev->sysfs_created = !ret; 3219 3220 create_toshiba_proc_entries(dev); 3221 3222 toshiba_acpi = dev; 3223 3224 return 0; 3225 3226 error: 3227 toshiba_acpi_remove(acpi_dev); 3228 return ret; 3229 } 3230 3231 static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event) 3232 { 3233 struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); 3234 3235 switch (event) { 3236 case 0x80: /* Hotkeys and some system events */ 3237 /* 3238 * Machines with this WMI GUID aren't supported due to bugs in 3239 * their AML. 3240 * 3241 * Return silently to avoid triggering a netlink event. 3242 */ 3243 if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) 3244 return; 3245 toshiba_acpi_process_hotkeys(dev); 3246 break; 3247 case 0x81: /* Dock events */ 3248 case 0x82: 3249 case 0x83: 3250 pr_info("Dock event received %x\n", event); 3251 break; 3252 case 0x88: /* Thermal events */ 3253 pr_info("Thermal event received\n"); 3254 break; 3255 case 0x8f: /* LID closed */ 3256 case 0x90: /* LID is closed and Dock has been ejected */ 3257 break; 3258 case 0x8c: /* SATA power events */ 3259 case 0x8b: 3260 pr_info("SATA power event received %x\n", event); 3261 break; 3262 case 0x92: /* Keyboard backlight mode changed */ 3263 toshiba_acpi->kbd_event_generated = true; 3264 /* Update sysfs entries */ 3265 if (sysfs_update_group(&acpi_dev->dev.kobj, 3266 &toshiba_attr_group)) 3267 pr_err("Unable to update sysfs entries\n"); 3268 break; 3269 case 0x85: /* Unknown */ 3270 case 0x8d: /* Unknown */ 3271 case 0x8e: /* Unknown */ 3272 case 0x94: /* Unknown */ 3273 case 0x95: /* Unknown */ 3274 default: 3275 pr_info("Unknown event received %x\n", event); 3276 break; 3277 } 3278 3279 acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class, 3280 dev_name(&acpi_dev->dev), 3281 event, (event == 0x80) ? 3282 dev->last_key_event : 0); 3283 } 3284 3285 #ifdef CONFIG_PM_SLEEP 3286 static int toshiba_acpi_suspend(struct device *device) 3287 { 3288 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 3289 3290 if (dev->hotkey_dev) { 3291 u32 result; 3292 3293 result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE); 3294 if (result != TOS_SUCCESS) 3295 pr_info("Unable to disable hotkeys\n"); 3296 } 3297 3298 return 0; 3299 } 3300 3301 static int toshiba_acpi_resume(struct device *device) 3302 { 3303 struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); 3304 3305 if (dev->hotkey_dev) { 3306 if (toshiba_acpi_enable_hotkeys(dev)) 3307 pr_info("Unable to re-enable hotkeys\n"); 3308 } 3309 3310 if (dev->wwan_rfk) { 3311 if (!toshiba_wireless_status(dev)) 3312 rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch); 3313 } 3314 3315 return 0; 3316 } 3317 #endif 3318 3319 static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm, 3320 toshiba_acpi_suspend, toshiba_acpi_resume); 3321 3322 static struct acpi_driver toshiba_acpi_driver = { 3323 .name = "Toshiba ACPI driver", 3324 .owner = THIS_MODULE, 3325 .ids = toshiba_device_ids, 3326 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 3327 .ops = { 3328 .add = toshiba_acpi_add, 3329 .remove = toshiba_acpi_remove, 3330 .notify = toshiba_acpi_notify, 3331 }, 3332 .drv.pm = &toshiba_acpi_pm, 3333 }; 3334 3335 static int __init toshiba_acpi_init(void) 3336 { 3337 int ret; 3338 3339 toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir); 3340 if (!toshiba_proc_dir) { 3341 pr_err("Unable to create proc dir " PROC_TOSHIBA "\n"); 3342 return -ENODEV; 3343 } 3344 3345 ret = acpi_bus_register_driver(&toshiba_acpi_driver); 3346 if (ret) { 3347 pr_err("Failed to register ACPI driver: %d\n", ret); 3348 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 3349 } 3350 3351 return ret; 3352 } 3353 3354 static void __exit toshiba_acpi_exit(void) 3355 { 3356 acpi_bus_unregister_driver(&toshiba_acpi_driver); 3357 if (toshiba_proc_dir) 3358 remove_proc_entry(PROC_TOSHIBA, acpi_root_dir); 3359 } 3360 3361 module_init(toshiba_acpi_init); 3362 module_exit(toshiba_acpi_exit); 3363