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