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