1 /*-*-linux-c-*-*/ 2 3 /* 4 Copyright (C) 2007,2008 Jonathan Woithe <jwoithe@just42.net> 5 Copyright (C) 2008 Peter Gruber <nokos@gmx.net> 6 Copyright (C) 2008 Tony Vroon <tony@linx.net> 7 Based on earlier work: 8 Copyright (C) 2003 Shane Spencer <shane@bogomip.com> 9 Adrian Yee <brewt-fujitsu@brewt.org> 10 11 Templated from msi-laptop.c and thinkpad_acpi.c which is copyright 12 by its respective authors. 13 14 This program is free software; you can redistribute it and/or modify 15 it under the terms of the GNU General Public License as published by 16 the Free Software Foundation; either version 2 of the License, or 17 (at your option) any later version. 18 19 This program is distributed in the hope that it will be useful, but 20 WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 22 General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with this program; if not, write to the Free Software 26 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 27 02110-1301, USA. 28 */ 29 30 /* 31 * fujitsu-laptop.c - Fujitsu laptop support, providing access to additional 32 * features made available on a range of Fujitsu laptops including the 33 * P2xxx/P5xxx/S6xxx/S7xxx series. 34 * 35 * This driver implements a vendor-specific backlight control interface for 36 * Fujitsu laptops and provides support for hotkeys present on certain Fujitsu 37 * laptops. 38 * 39 * This driver has been tested on a Fujitsu Lifebook S6410, S7020 and 40 * P8010. It should work on most P-series and S-series Lifebooks, but 41 * YMMV. 42 * 43 * The module parameter use_alt_lcd_levels switches between different ACPI 44 * brightness controls which are used by different Fujitsu laptops. In most 45 * cases the correct method is automatically detected. "use_alt_lcd_levels=1" 46 * is applicable for a Fujitsu Lifebook S6410 if autodetection fails. 47 * 48 */ 49 50 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 51 52 #include <linux/module.h> 53 #include <linux/kernel.h> 54 #include <linux/init.h> 55 #include <linux/acpi.h> 56 #include <linux/dmi.h> 57 #include <linux/backlight.h> 58 #include <linux/fb.h> 59 #include <linux/input.h> 60 #include <linux/input/sparse-keymap.h> 61 #include <linux/kfifo.h> 62 #include <linux/leds.h> 63 #include <linux/platform_device.h> 64 #include <linux/slab.h> 65 #include <acpi/video.h> 66 67 #define FUJITSU_DRIVER_VERSION "0.6.0" 68 69 #define FUJITSU_LCD_N_LEVELS 8 70 71 #define ACPI_FUJITSU_CLASS "fujitsu" 72 #define ACPI_FUJITSU_BL_HID "FUJ02B1" 73 #define ACPI_FUJITSU_BL_DRIVER_NAME "Fujitsu laptop FUJ02B1 ACPI brightness driver" 74 #define ACPI_FUJITSU_BL_DEVICE_NAME "Fujitsu FUJ02B1" 75 #define ACPI_FUJITSU_LAPTOP_HID "FUJ02E3" 76 #define ACPI_FUJITSU_LAPTOP_DRIVER_NAME "Fujitsu laptop FUJ02E3 ACPI hotkeys driver" 77 #define ACPI_FUJITSU_LAPTOP_DEVICE_NAME "Fujitsu FUJ02E3" 78 79 #define ACPI_FUJITSU_NOTIFY_CODE1 0x80 80 81 /* FUNC interface - command values */ 82 #define FUNC_FLAGS 0x1000 83 #define FUNC_LEDS 0x1001 84 #define FUNC_BUTTONS 0x1002 85 #define FUNC_BACKLIGHT 0x1004 86 87 /* FUNC interface - responses */ 88 #define UNSUPPORTED_CMD 0x80000000 89 90 /* FUNC interface - status flags */ 91 #define FLAG_RFKILL 0x020 92 #define FLAG_LID 0x100 93 #define FLAG_DOCK 0x200 94 95 /* FUNC interface - LED control */ 96 #define FUNC_LED_OFF 0x1 97 #define FUNC_LED_ON 0x30001 98 #define KEYBOARD_LAMPS 0x100 99 #define LOGOLAMP_POWERON 0x2000 100 #define LOGOLAMP_ALWAYS 0x4000 101 #define RADIO_LED_ON 0x20 102 #define ECO_LED 0x10000 103 #define ECO_LED_ON 0x80000 104 105 /* Hotkey details */ 106 #define KEY1_CODE 0x410 /* codes for the keys in the GIRB register */ 107 #define KEY2_CODE 0x411 108 #define KEY3_CODE 0x412 109 #define KEY4_CODE 0x413 110 #define KEY5_CODE 0x420 111 112 #define MAX_HOTKEY_RINGBUFFER_SIZE 100 113 #define RINGBUFFERSIZE 40 114 115 /* Device controlling the backlight and associated keys */ 116 struct fujitsu_bl { 117 struct input_dev *input; 118 char phys[32]; 119 struct backlight_device *bl_device; 120 unsigned int max_brightness; 121 unsigned int brightness_level; 122 }; 123 124 static struct fujitsu_bl *fujitsu_bl; 125 static int use_alt_lcd_levels = -1; 126 static bool disable_brightness_adjust; 127 128 /* Device used to access hotkeys and other features on the laptop */ 129 struct fujitsu_laptop { 130 struct input_dev *input; 131 char phys[32]; 132 struct platform_device *pf_device; 133 struct kfifo fifo; 134 spinlock_t fifo_lock; 135 int flags_supported; 136 int flags_state; 137 }; 138 139 static struct acpi_device *fext; 140 141 /* Fujitsu ACPI interface function */ 142 143 static int call_fext_func(struct acpi_device *device, 144 int func, int op, int feature, int state) 145 { 146 union acpi_object params[4] = { 147 { .integer.type = ACPI_TYPE_INTEGER, .integer.value = func }, 148 { .integer.type = ACPI_TYPE_INTEGER, .integer.value = op }, 149 { .integer.type = ACPI_TYPE_INTEGER, .integer.value = feature }, 150 { .integer.type = ACPI_TYPE_INTEGER, .integer.value = state } 151 }; 152 struct acpi_object_list arg_list = { 4, params }; 153 unsigned long long value; 154 acpi_status status; 155 156 status = acpi_evaluate_integer(device->handle, "FUNC", &arg_list, 157 &value); 158 if (ACPI_FAILURE(status)) { 159 acpi_handle_err(device->handle, "Failed to evaluate FUNC\n"); 160 return -ENODEV; 161 } 162 163 acpi_handle_debug(device->handle, 164 "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) returned 0x%x\n", 165 func, op, feature, state, (int)value); 166 return value; 167 } 168 169 /* Hardware access for LCD brightness control */ 170 171 static int set_lcd_level(struct acpi_device *device, int level) 172 { 173 struct fujitsu_bl *priv = acpi_driver_data(device); 174 acpi_status status; 175 char *method; 176 177 switch (use_alt_lcd_levels) { 178 case -1: 179 if (acpi_has_method(device->handle, "SBL2")) 180 method = "SBL2"; 181 else 182 method = "SBLL"; 183 break; 184 case 1: 185 method = "SBL2"; 186 break; 187 default: 188 method = "SBLL"; 189 break; 190 } 191 192 acpi_handle_debug(device->handle, "set lcd level via %s [%d]\n", method, 193 level); 194 195 if (level < 0 || level >= priv->max_brightness) 196 return -EINVAL; 197 198 status = acpi_execute_simple_method(device->handle, method, level); 199 if (ACPI_FAILURE(status)) { 200 acpi_handle_err(device->handle, "Failed to evaluate %s\n", 201 method); 202 return -ENODEV; 203 } 204 205 priv->brightness_level = level; 206 207 return 0; 208 } 209 210 static int get_lcd_level(struct acpi_device *device) 211 { 212 struct fujitsu_bl *priv = acpi_driver_data(device); 213 unsigned long long state = 0; 214 acpi_status status = AE_OK; 215 216 acpi_handle_debug(device->handle, "get lcd level via GBLL\n"); 217 218 status = acpi_evaluate_integer(device->handle, "GBLL", NULL, &state); 219 if (ACPI_FAILURE(status)) 220 return 0; 221 222 priv->brightness_level = state & 0x0fffffff; 223 224 return priv->brightness_level; 225 } 226 227 static int get_max_brightness(struct acpi_device *device) 228 { 229 struct fujitsu_bl *priv = acpi_driver_data(device); 230 unsigned long long state = 0; 231 acpi_status status = AE_OK; 232 233 acpi_handle_debug(device->handle, "get max lcd level via RBLL\n"); 234 235 status = acpi_evaluate_integer(device->handle, "RBLL", NULL, &state); 236 if (ACPI_FAILURE(status)) 237 return -1; 238 239 priv->max_brightness = state; 240 241 return priv->max_brightness; 242 } 243 244 /* Backlight device stuff */ 245 246 static int bl_get_brightness(struct backlight_device *b) 247 { 248 struct acpi_device *device = bl_get_data(b); 249 250 return b->props.power == FB_BLANK_POWERDOWN ? 0 : get_lcd_level(device); 251 } 252 253 static int bl_update_status(struct backlight_device *b) 254 { 255 struct acpi_device *device = bl_get_data(b); 256 257 if (fext) { 258 if (b->props.power == FB_BLANK_POWERDOWN) 259 call_fext_func(fext, FUNC_BACKLIGHT, 0x1, 0x4, 0x3); 260 else 261 call_fext_func(fext, FUNC_BACKLIGHT, 0x1, 0x4, 0x0); 262 } 263 264 return set_lcd_level(device, b->props.brightness); 265 } 266 267 static const struct backlight_ops fujitsu_bl_ops = { 268 .get_brightness = bl_get_brightness, 269 .update_status = bl_update_status, 270 }; 271 272 static ssize_t lid_show(struct device *dev, struct device_attribute *attr, 273 char *buf) 274 { 275 struct fujitsu_laptop *priv = dev_get_drvdata(dev); 276 277 if (!(priv->flags_supported & FLAG_LID)) 278 return sprintf(buf, "unknown\n"); 279 if (priv->flags_state & FLAG_LID) 280 return sprintf(buf, "open\n"); 281 else 282 return sprintf(buf, "closed\n"); 283 } 284 285 static ssize_t dock_show(struct device *dev, struct device_attribute *attr, 286 char *buf) 287 { 288 struct fujitsu_laptop *priv = dev_get_drvdata(dev); 289 290 if (!(priv->flags_supported & FLAG_DOCK)) 291 return sprintf(buf, "unknown\n"); 292 if (priv->flags_state & FLAG_DOCK) 293 return sprintf(buf, "docked\n"); 294 else 295 return sprintf(buf, "undocked\n"); 296 } 297 298 static ssize_t radios_show(struct device *dev, struct device_attribute *attr, 299 char *buf) 300 { 301 struct fujitsu_laptop *priv = dev_get_drvdata(dev); 302 303 if (!(priv->flags_supported & FLAG_RFKILL)) 304 return sprintf(buf, "unknown\n"); 305 if (priv->flags_state & FLAG_RFKILL) 306 return sprintf(buf, "on\n"); 307 else 308 return sprintf(buf, "killed\n"); 309 } 310 311 static DEVICE_ATTR_RO(lid); 312 static DEVICE_ATTR_RO(dock); 313 static DEVICE_ATTR_RO(radios); 314 315 static struct attribute *fujitsu_pf_attributes[] = { 316 &dev_attr_lid.attr, 317 &dev_attr_dock.attr, 318 &dev_attr_radios.attr, 319 NULL 320 }; 321 322 static const struct attribute_group fujitsu_pf_attribute_group = { 323 .attrs = fujitsu_pf_attributes 324 }; 325 326 static struct platform_driver fujitsu_pf_driver = { 327 .driver = { 328 .name = "fujitsu-laptop", 329 } 330 }; 331 332 /* ACPI device for LCD brightness control */ 333 334 static const struct key_entry keymap_backlight[] = { 335 { KE_KEY, true, { KEY_BRIGHTNESSUP } }, 336 { KE_KEY, false, { KEY_BRIGHTNESSDOWN } }, 337 { KE_END, 0 } 338 }; 339 340 static int acpi_fujitsu_bl_input_setup(struct acpi_device *device) 341 { 342 struct fujitsu_bl *priv = acpi_driver_data(device); 343 int ret; 344 345 priv->input = devm_input_allocate_device(&device->dev); 346 if (!priv->input) 347 return -ENOMEM; 348 349 snprintf(priv->phys, sizeof(priv->phys), "%s/video/input0", 350 acpi_device_hid(device)); 351 352 priv->input->name = acpi_device_name(device); 353 priv->input->phys = priv->phys; 354 priv->input->id.bustype = BUS_HOST; 355 priv->input->id.product = 0x06; 356 357 ret = sparse_keymap_setup(priv->input, keymap_backlight, NULL); 358 if (ret) 359 return ret; 360 361 return input_register_device(priv->input); 362 } 363 364 static int fujitsu_backlight_register(struct acpi_device *device) 365 { 366 struct fujitsu_bl *priv = acpi_driver_data(device); 367 const struct backlight_properties props = { 368 .brightness = priv->brightness_level, 369 .max_brightness = priv->max_brightness - 1, 370 .type = BACKLIGHT_PLATFORM 371 }; 372 struct backlight_device *bd; 373 374 bd = devm_backlight_device_register(&device->dev, "fujitsu-laptop", 375 &device->dev, device, 376 &fujitsu_bl_ops, &props); 377 if (IS_ERR(bd)) 378 return PTR_ERR(bd); 379 380 priv->bl_device = bd; 381 382 return 0; 383 } 384 385 static int acpi_fujitsu_bl_add(struct acpi_device *device) 386 { 387 struct fujitsu_bl *priv; 388 int error; 389 390 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) 391 return -ENODEV; 392 393 priv = devm_kzalloc(&device->dev, sizeof(*priv), GFP_KERNEL); 394 if (!priv) 395 return -ENOMEM; 396 397 fujitsu_bl = priv; 398 strcpy(acpi_device_name(device), ACPI_FUJITSU_BL_DEVICE_NAME); 399 strcpy(acpi_device_class(device), ACPI_FUJITSU_CLASS); 400 device->driver_data = priv; 401 402 error = acpi_fujitsu_bl_input_setup(device); 403 if (error) 404 return error; 405 406 pr_info("ACPI: %s [%s]\n", 407 acpi_device_name(device), acpi_device_bid(device)); 408 409 if (get_max_brightness(device) <= 0) 410 priv->max_brightness = FUJITSU_LCD_N_LEVELS; 411 get_lcd_level(device); 412 413 error = fujitsu_backlight_register(device); 414 if (error) 415 return error; 416 417 return 0; 418 } 419 420 /* Brightness notify */ 421 422 static void acpi_fujitsu_bl_notify(struct acpi_device *device, u32 event) 423 { 424 struct fujitsu_bl *priv = acpi_driver_data(device); 425 int oldb, newb; 426 427 if (event != ACPI_FUJITSU_NOTIFY_CODE1) { 428 acpi_handle_info(device->handle, "unsupported event [0x%x]\n", 429 event); 430 sparse_keymap_report_event(priv->input, -1, 1, true); 431 return; 432 } 433 434 oldb = priv->brightness_level; 435 get_lcd_level(device); 436 newb = priv->brightness_level; 437 438 acpi_handle_debug(device->handle, 439 "brightness button event [%i -> %i]\n", oldb, newb); 440 441 if (oldb == newb) 442 return; 443 444 if (!disable_brightness_adjust) 445 set_lcd_level(device, newb); 446 447 sparse_keymap_report_event(priv->input, oldb < newb, 1, true); 448 } 449 450 /* ACPI device for hotkey handling */ 451 452 static const struct key_entry keymap_default[] = { 453 { KE_KEY, KEY1_CODE, { KEY_PROG1 } }, 454 { KE_KEY, KEY2_CODE, { KEY_PROG2 } }, 455 { KE_KEY, KEY3_CODE, { KEY_PROG3 } }, 456 { KE_KEY, KEY4_CODE, { KEY_PROG4 } }, 457 { KE_KEY, KEY5_CODE, { KEY_RFKILL } }, 458 { KE_KEY, BIT(26), { KEY_TOUCHPAD_TOGGLE } }, 459 { KE_END, 0 } 460 }; 461 462 static const struct key_entry keymap_s64x0[] = { 463 { KE_KEY, KEY1_CODE, { KEY_SCREENLOCK } }, /* "Lock" */ 464 { KE_KEY, KEY2_CODE, { KEY_HELP } }, /* "Mobility Center */ 465 { KE_KEY, KEY3_CODE, { KEY_PROG3 } }, 466 { KE_KEY, KEY4_CODE, { KEY_PROG4 } }, 467 { KE_END, 0 } 468 }; 469 470 static const struct key_entry keymap_p8010[] = { 471 { KE_KEY, KEY1_CODE, { KEY_HELP } }, /* "Support" */ 472 { KE_KEY, KEY2_CODE, { KEY_PROG2 } }, 473 { KE_KEY, KEY3_CODE, { KEY_SWITCHVIDEOMODE } }, /* "Presentation" */ 474 { KE_KEY, KEY4_CODE, { KEY_WWW } }, /* "WWW" */ 475 { KE_END, 0 } 476 }; 477 478 static const struct key_entry *keymap = keymap_default; 479 480 static int fujitsu_laptop_dmi_keymap_override(const struct dmi_system_id *id) 481 { 482 pr_info("Identified laptop model '%s'\n", id->ident); 483 keymap = id->driver_data; 484 return 1; 485 } 486 487 static const struct dmi_system_id fujitsu_laptop_dmi_table[] = { 488 { 489 .callback = fujitsu_laptop_dmi_keymap_override, 490 .ident = "Fujitsu Siemens S6410", 491 .matches = { 492 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 493 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK S6410"), 494 }, 495 .driver_data = (void *)keymap_s64x0 496 }, 497 { 498 .callback = fujitsu_laptop_dmi_keymap_override, 499 .ident = "Fujitsu Siemens S6420", 500 .matches = { 501 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 502 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK S6420"), 503 }, 504 .driver_data = (void *)keymap_s64x0 505 }, 506 { 507 .callback = fujitsu_laptop_dmi_keymap_override, 508 .ident = "Fujitsu LifeBook P8010", 509 .matches = { 510 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 511 DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook P8010"), 512 }, 513 .driver_data = (void *)keymap_p8010 514 }, 515 {} 516 }; 517 518 static int acpi_fujitsu_laptop_input_setup(struct acpi_device *device) 519 { 520 struct fujitsu_laptop *priv = acpi_driver_data(device); 521 int ret; 522 523 priv->input = devm_input_allocate_device(&device->dev); 524 if (!priv->input) 525 return -ENOMEM; 526 527 snprintf(priv->phys, sizeof(priv->phys), "%s/input0", 528 acpi_device_hid(device)); 529 530 priv->input->name = acpi_device_name(device); 531 priv->input->phys = priv->phys; 532 priv->input->id.bustype = BUS_HOST; 533 534 dmi_check_system(fujitsu_laptop_dmi_table); 535 ret = sparse_keymap_setup(priv->input, keymap, NULL); 536 if (ret) 537 return ret; 538 539 return input_register_device(priv->input); 540 } 541 542 static int fujitsu_laptop_platform_add(struct acpi_device *device) 543 { 544 struct fujitsu_laptop *priv = acpi_driver_data(device); 545 int ret; 546 547 priv->pf_device = platform_device_alloc("fujitsu-laptop", -1); 548 if (!priv->pf_device) 549 return -ENOMEM; 550 551 platform_set_drvdata(priv->pf_device, priv); 552 553 ret = platform_device_add(priv->pf_device); 554 if (ret) 555 goto err_put_platform_device; 556 557 ret = sysfs_create_group(&priv->pf_device->dev.kobj, 558 &fujitsu_pf_attribute_group); 559 if (ret) 560 goto err_del_platform_device; 561 562 return 0; 563 564 err_del_platform_device: 565 platform_device_del(priv->pf_device); 566 err_put_platform_device: 567 platform_device_put(priv->pf_device); 568 569 return ret; 570 } 571 572 static void fujitsu_laptop_platform_remove(struct acpi_device *device) 573 { 574 struct fujitsu_laptop *priv = acpi_driver_data(device); 575 576 sysfs_remove_group(&priv->pf_device->dev.kobj, 577 &fujitsu_pf_attribute_group); 578 platform_device_unregister(priv->pf_device); 579 } 580 581 static int logolamp_set(struct led_classdev *cdev, 582 enum led_brightness brightness) 583 { 584 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 585 int poweron = FUNC_LED_ON, always = FUNC_LED_ON; 586 int ret; 587 588 if (brightness < LED_HALF) 589 poweron = FUNC_LED_OFF; 590 591 if (brightness < LED_FULL) 592 always = FUNC_LED_OFF; 593 594 ret = call_fext_func(device, FUNC_LEDS, 0x1, LOGOLAMP_POWERON, poweron); 595 if (ret < 0) 596 return ret; 597 598 return call_fext_func(device, FUNC_LEDS, 0x1, LOGOLAMP_ALWAYS, always); 599 } 600 601 static enum led_brightness logolamp_get(struct led_classdev *cdev) 602 { 603 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 604 int ret; 605 606 ret = call_fext_func(device, FUNC_LEDS, 0x2, LOGOLAMP_ALWAYS, 0x0); 607 if (ret == FUNC_LED_ON) 608 return LED_FULL; 609 610 ret = call_fext_func(device, FUNC_LEDS, 0x2, LOGOLAMP_POWERON, 0x0); 611 if (ret == FUNC_LED_ON) 612 return LED_HALF; 613 614 return LED_OFF; 615 } 616 617 static int kblamps_set(struct led_classdev *cdev, 618 enum led_brightness brightness) 619 { 620 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 621 622 if (brightness >= LED_FULL) 623 return call_fext_func(device, FUNC_LEDS, 0x1, KEYBOARD_LAMPS, 624 FUNC_LED_ON); 625 else 626 return call_fext_func(device, FUNC_LEDS, 0x1, KEYBOARD_LAMPS, 627 FUNC_LED_OFF); 628 } 629 630 static enum led_brightness kblamps_get(struct led_classdev *cdev) 631 { 632 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 633 enum led_brightness brightness = LED_OFF; 634 635 if (call_fext_func(device, 636 FUNC_LEDS, 0x2, KEYBOARD_LAMPS, 0x0) == FUNC_LED_ON) 637 brightness = LED_FULL; 638 639 return brightness; 640 } 641 642 static int radio_led_set(struct led_classdev *cdev, 643 enum led_brightness brightness) 644 { 645 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 646 647 if (brightness >= LED_FULL) 648 return call_fext_func(device, FUNC_FLAGS, 0x5, RADIO_LED_ON, 649 RADIO_LED_ON); 650 else 651 return call_fext_func(device, FUNC_FLAGS, 0x5, RADIO_LED_ON, 652 0x0); 653 } 654 655 static enum led_brightness radio_led_get(struct led_classdev *cdev) 656 { 657 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 658 enum led_brightness brightness = LED_OFF; 659 660 if (call_fext_func(device, FUNC_FLAGS, 0x4, 0x0, 0x0) & RADIO_LED_ON) 661 brightness = LED_FULL; 662 663 return brightness; 664 } 665 666 static int eco_led_set(struct led_classdev *cdev, 667 enum led_brightness brightness) 668 { 669 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 670 int curr; 671 672 curr = call_fext_func(device, FUNC_LEDS, 0x2, ECO_LED, 0x0); 673 if (brightness >= LED_FULL) 674 return call_fext_func(device, FUNC_LEDS, 0x1, ECO_LED, 675 curr | ECO_LED_ON); 676 else 677 return call_fext_func(device, FUNC_LEDS, 0x1, ECO_LED, 678 curr & ~ECO_LED_ON); 679 } 680 681 static enum led_brightness eco_led_get(struct led_classdev *cdev) 682 { 683 struct acpi_device *device = to_acpi_device(cdev->dev->parent); 684 enum led_brightness brightness = LED_OFF; 685 686 if (call_fext_func(device, FUNC_LEDS, 0x2, ECO_LED, 0x0) & ECO_LED_ON) 687 brightness = LED_FULL; 688 689 return brightness; 690 } 691 692 static int acpi_fujitsu_laptop_leds_register(struct acpi_device *device) 693 { 694 struct fujitsu_laptop *priv = acpi_driver_data(device); 695 struct led_classdev *led; 696 int result; 697 698 if (call_fext_func(device, 699 FUNC_LEDS, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON) { 700 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 701 if (!led) 702 return -ENOMEM; 703 704 led->name = "fujitsu::logolamp"; 705 led->brightness_set_blocking = logolamp_set; 706 led->brightness_get = logolamp_get; 707 result = devm_led_classdev_register(&device->dev, led); 708 if (result) 709 return result; 710 } 711 712 if ((call_fext_func(device, 713 FUNC_LEDS, 0x0, 0x0, 0x0) & KEYBOARD_LAMPS) && 714 (call_fext_func(device, FUNC_BUTTONS, 0x0, 0x0, 0x0) == 0x0)) { 715 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 716 if (!led) 717 return -ENOMEM; 718 719 led->name = "fujitsu::kblamps"; 720 led->brightness_set_blocking = kblamps_set; 721 led->brightness_get = kblamps_get; 722 result = devm_led_classdev_register(&device->dev, led); 723 if (result) 724 return result; 725 } 726 727 /* 728 * Some Fujitsu laptops have a radio toggle button in place of a slide 729 * switch and all such machines appear to also have an RF LED. Based on 730 * comparing DSDT tables of four Fujitsu Lifebook models (E744, E751, 731 * S7110, S8420; the first one has a radio toggle button, the other 732 * three have slide switches), bit 17 of flags_supported (the value 733 * returned by method S000 of ACPI device FUJ02E3) seems to indicate 734 * whether given model has a radio toggle button. 735 */ 736 if (priv->flags_supported & BIT(17)) { 737 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 738 if (!led) 739 return -ENOMEM; 740 741 led->name = "fujitsu::radio_led"; 742 led->brightness_set_blocking = radio_led_set; 743 led->brightness_get = radio_led_get; 744 led->default_trigger = "rfkill-any"; 745 result = devm_led_classdev_register(&device->dev, led); 746 if (result) 747 return result; 748 } 749 750 /* Support for eco led is not always signaled in bit corresponding 751 * to the bit used to control the led. According to the DSDT table, 752 * bit 14 seems to indicate presence of said led as well. 753 * Confirm by testing the status. 754 */ 755 if ((call_fext_func(device, FUNC_LEDS, 0x0, 0x0, 0x0) & BIT(14)) && 756 (call_fext_func(device, 757 FUNC_LEDS, 0x2, ECO_LED, 0x0) != UNSUPPORTED_CMD)) { 758 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 759 if (!led) 760 return -ENOMEM; 761 762 led->name = "fujitsu::eco_led"; 763 led->brightness_set_blocking = eco_led_set; 764 led->brightness_get = eco_led_get; 765 result = devm_led_classdev_register(&device->dev, led); 766 if (result) 767 return result; 768 } 769 770 return 0; 771 } 772 773 static int acpi_fujitsu_laptop_add(struct acpi_device *device) 774 { 775 struct fujitsu_laptop *priv; 776 int error; 777 int i; 778 779 priv = devm_kzalloc(&device->dev, sizeof(*priv), GFP_KERNEL); 780 if (!priv) 781 return -ENOMEM; 782 783 WARN_ONCE(fext, "More than one FUJ02E3 ACPI device was found. Driver may not work as intended."); 784 fext = device; 785 786 strcpy(acpi_device_name(device), ACPI_FUJITSU_LAPTOP_DEVICE_NAME); 787 strcpy(acpi_device_class(device), ACPI_FUJITSU_CLASS); 788 device->driver_data = priv; 789 790 /* kfifo */ 791 spin_lock_init(&priv->fifo_lock); 792 error = kfifo_alloc(&priv->fifo, RINGBUFFERSIZE * sizeof(int), 793 GFP_KERNEL); 794 if (error) { 795 pr_err("kfifo_alloc failed\n"); 796 goto err_stop; 797 } 798 799 error = acpi_fujitsu_laptop_input_setup(device); 800 if (error) 801 goto err_free_fifo; 802 803 pr_info("ACPI: %s [%s]\n", 804 acpi_device_name(device), acpi_device_bid(device)); 805 806 i = 0; 807 while (call_fext_func(device, FUNC_BUTTONS, 0x1, 0x0, 0x0) != 0 808 && (i++) < MAX_HOTKEY_RINGBUFFER_SIZE) 809 ; /* No action, result is discarded */ 810 acpi_handle_debug(device->handle, "Discarded %i ringbuffer entries\n", 811 i); 812 813 priv->flags_supported = call_fext_func(device, FUNC_FLAGS, 0x0, 0x0, 814 0x0); 815 816 /* Make sure our bitmask of supported functions is cleared if the 817 RFKILL function block is not implemented, like on the S7020. */ 818 if (priv->flags_supported == UNSUPPORTED_CMD) 819 priv->flags_supported = 0; 820 821 if (priv->flags_supported) 822 priv->flags_state = call_fext_func(device, FUNC_FLAGS, 0x4, 0x0, 823 0x0); 824 825 /* Suspect this is a keymap of the application panel, print it */ 826 acpi_handle_info(device->handle, "BTNI: [0x%x]\n", 827 call_fext_func(device, FUNC_BUTTONS, 0x0, 0x0, 0x0)); 828 829 /* Sync backlight power status */ 830 if (fujitsu_bl && fujitsu_bl->bl_device && 831 acpi_video_get_backlight_type() == acpi_backlight_vendor) { 832 if (call_fext_func(fext, FUNC_BACKLIGHT, 0x2, 0x4, 0x0) == 3) 833 fujitsu_bl->bl_device->props.power = FB_BLANK_POWERDOWN; 834 else 835 fujitsu_bl->bl_device->props.power = FB_BLANK_UNBLANK; 836 } 837 838 error = acpi_fujitsu_laptop_leds_register(device); 839 if (error) 840 goto err_free_fifo; 841 842 error = fujitsu_laptop_platform_add(device); 843 if (error) 844 goto err_free_fifo; 845 846 return 0; 847 848 err_free_fifo: 849 kfifo_free(&priv->fifo); 850 err_stop: 851 return error; 852 } 853 854 static int acpi_fujitsu_laptop_remove(struct acpi_device *device) 855 { 856 struct fujitsu_laptop *priv = acpi_driver_data(device); 857 858 fujitsu_laptop_platform_remove(device); 859 860 kfifo_free(&priv->fifo); 861 862 return 0; 863 } 864 865 static void acpi_fujitsu_laptop_press(struct acpi_device *device, int scancode) 866 { 867 struct fujitsu_laptop *priv = acpi_driver_data(device); 868 int status; 869 870 status = kfifo_in_locked(&priv->fifo, (unsigned char *)&scancode, 871 sizeof(scancode), &priv->fifo_lock); 872 if (status != sizeof(scancode)) { 873 dev_info(&priv->input->dev, "Could not push scancode [0x%x]\n", 874 scancode); 875 return; 876 } 877 sparse_keymap_report_event(priv->input, scancode, 1, false); 878 dev_dbg(&priv->input->dev, "Push scancode into ringbuffer [0x%x]\n", 879 scancode); 880 } 881 882 static void acpi_fujitsu_laptop_release(struct acpi_device *device) 883 { 884 struct fujitsu_laptop *priv = acpi_driver_data(device); 885 int scancode, status; 886 887 while (true) { 888 status = kfifo_out_locked(&priv->fifo, 889 (unsigned char *)&scancode, 890 sizeof(scancode), &priv->fifo_lock); 891 if (status != sizeof(scancode)) 892 return; 893 sparse_keymap_report_event(priv->input, scancode, 0, false); 894 dev_dbg(&priv->input->dev, 895 "Pop scancode from ringbuffer [0x%x]\n", scancode); 896 } 897 } 898 899 static void acpi_fujitsu_laptop_notify(struct acpi_device *device, u32 event) 900 { 901 struct fujitsu_laptop *priv = acpi_driver_data(device); 902 int scancode, i = 0; 903 unsigned int irb; 904 905 if (event != ACPI_FUJITSU_NOTIFY_CODE1) { 906 acpi_handle_info(device->handle, "Unsupported event [0x%x]\n", 907 event); 908 sparse_keymap_report_event(priv->input, -1, 1, true); 909 return; 910 } 911 912 if (priv->flags_supported) 913 priv->flags_state = call_fext_func(device, FUNC_FLAGS, 0x4, 0x0, 914 0x0); 915 916 while ((irb = call_fext_func(device, 917 FUNC_BUTTONS, 0x1, 0x0, 0x0)) != 0 && 918 i++ < MAX_HOTKEY_RINGBUFFER_SIZE) { 919 scancode = irb & 0x4ff; 920 if (sparse_keymap_entry_from_scancode(priv->input, scancode)) 921 acpi_fujitsu_laptop_press(device, scancode); 922 else if (scancode == 0) 923 acpi_fujitsu_laptop_release(device); 924 else 925 acpi_handle_info(device->handle, 926 "Unknown GIRB result [%x]\n", irb); 927 } 928 929 /* On some models (first seen on the Skylake-based Lifebook 930 * E736/E746/E756), the touchpad toggle hotkey (Fn+F4) is 931 * handled in software; its state is queried using FUNC_FLAGS 932 */ 933 if ((priv->flags_supported & BIT(26)) && 934 (call_fext_func(device, FUNC_FLAGS, 0x1, 0x0, 0x0) & BIT(26))) 935 sparse_keymap_report_event(priv->input, BIT(26), 1, true); 936 } 937 938 /* Initialization */ 939 940 static const struct acpi_device_id fujitsu_bl_device_ids[] = { 941 {ACPI_FUJITSU_BL_HID, 0}, 942 {"", 0}, 943 }; 944 945 static struct acpi_driver acpi_fujitsu_bl_driver = { 946 .name = ACPI_FUJITSU_BL_DRIVER_NAME, 947 .class = ACPI_FUJITSU_CLASS, 948 .ids = fujitsu_bl_device_ids, 949 .ops = { 950 .add = acpi_fujitsu_bl_add, 951 .notify = acpi_fujitsu_bl_notify, 952 }, 953 }; 954 955 static const struct acpi_device_id fujitsu_laptop_device_ids[] = { 956 {ACPI_FUJITSU_LAPTOP_HID, 0}, 957 {"", 0}, 958 }; 959 960 static struct acpi_driver acpi_fujitsu_laptop_driver = { 961 .name = ACPI_FUJITSU_LAPTOP_DRIVER_NAME, 962 .class = ACPI_FUJITSU_CLASS, 963 .ids = fujitsu_laptop_device_ids, 964 .ops = { 965 .add = acpi_fujitsu_laptop_add, 966 .remove = acpi_fujitsu_laptop_remove, 967 .notify = acpi_fujitsu_laptop_notify, 968 }, 969 }; 970 971 static const struct acpi_device_id fujitsu_ids[] __used = { 972 {ACPI_FUJITSU_BL_HID, 0}, 973 {ACPI_FUJITSU_LAPTOP_HID, 0}, 974 {"", 0} 975 }; 976 MODULE_DEVICE_TABLE(acpi, fujitsu_ids); 977 978 static int __init fujitsu_init(void) 979 { 980 int ret; 981 982 ret = acpi_bus_register_driver(&acpi_fujitsu_bl_driver); 983 if (ret) 984 return ret; 985 986 /* Register platform stuff */ 987 988 ret = platform_driver_register(&fujitsu_pf_driver); 989 if (ret) 990 goto err_unregister_acpi; 991 992 /* Register laptop driver */ 993 994 ret = acpi_bus_register_driver(&acpi_fujitsu_laptop_driver); 995 if (ret) 996 goto err_unregister_platform_driver; 997 998 pr_info("driver " FUJITSU_DRIVER_VERSION " successfully loaded\n"); 999 1000 return 0; 1001 1002 err_unregister_platform_driver: 1003 platform_driver_unregister(&fujitsu_pf_driver); 1004 err_unregister_acpi: 1005 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver); 1006 1007 return ret; 1008 } 1009 1010 static void __exit fujitsu_cleanup(void) 1011 { 1012 acpi_bus_unregister_driver(&acpi_fujitsu_laptop_driver); 1013 1014 platform_driver_unregister(&fujitsu_pf_driver); 1015 1016 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver); 1017 1018 pr_info("driver unloaded\n"); 1019 } 1020 1021 module_init(fujitsu_init); 1022 module_exit(fujitsu_cleanup); 1023 1024 module_param(use_alt_lcd_levels, int, 0644); 1025 MODULE_PARM_DESC(use_alt_lcd_levels, "Interface used for setting LCD brightness level (-1 = auto, 0 = force SBLL, 1 = force SBL2)"); 1026 module_param(disable_brightness_adjust, bool, 0644); 1027 MODULE_PARM_DESC(disable_brightness_adjust, "Disable LCD brightness adjustment"); 1028 1029 MODULE_AUTHOR("Jonathan Woithe, Peter Gruber, Tony Vroon"); 1030 MODULE_DESCRIPTION("Fujitsu laptop extras support"); 1031 MODULE_VERSION(FUJITSU_DRIVER_VERSION); 1032 MODULE_LICENSE("GPL"); 1033