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 led_classdev *led; 695 int result; 696 697 if (call_fext_func(device, 698 FUNC_LEDS, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON) { 699 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 700 if (!led) 701 return -ENOMEM; 702 703 led->name = "fujitsu::logolamp"; 704 led->brightness_set_blocking = logolamp_set; 705 led->brightness_get = logolamp_get; 706 result = devm_led_classdev_register(&device->dev, led); 707 if (result) 708 return result; 709 } 710 711 if ((call_fext_func(device, 712 FUNC_LEDS, 0x0, 0x0, 0x0) & KEYBOARD_LAMPS) && 713 (call_fext_func(device, FUNC_BUTTONS, 0x0, 0x0, 0x0) == 0x0)) { 714 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 715 if (!led) 716 return -ENOMEM; 717 718 led->name = "fujitsu::kblamps"; 719 led->brightness_set_blocking = kblamps_set; 720 led->brightness_get = kblamps_get; 721 result = devm_led_classdev_register(&device->dev, led); 722 if (result) 723 return result; 724 } 725 726 /* 727 * BTNI bit 24 seems to indicate the presence of a radio toggle 728 * button in place of a slide switch, and all such machines appear 729 * to also have an RF LED. Therefore use bit 24 as an indicator 730 * that an RF LED is present. 731 */ 732 if (call_fext_func(device, FUNC_BUTTONS, 0x0, 0x0, 0x0) & BIT(24)) { 733 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 734 if (!led) 735 return -ENOMEM; 736 737 led->name = "fujitsu::radio_led"; 738 led->brightness_set_blocking = radio_led_set; 739 led->brightness_get = radio_led_get; 740 led->default_trigger = "rfkill-any"; 741 result = devm_led_classdev_register(&device->dev, led); 742 if (result) 743 return result; 744 } 745 746 /* Support for eco led is not always signaled in bit corresponding 747 * to the bit used to control the led. According to the DSDT table, 748 * bit 14 seems to indicate presence of said led as well. 749 * Confirm by testing the status. 750 */ 751 if ((call_fext_func(device, FUNC_LEDS, 0x0, 0x0, 0x0) & BIT(14)) && 752 (call_fext_func(device, 753 FUNC_LEDS, 0x2, ECO_LED, 0x0) != UNSUPPORTED_CMD)) { 754 led = devm_kzalloc(&device->dev, sizeof(*led), GFP_KERNEL); 755 if (!led) 756 return -ENOMEM; 757 758 led->name = "fujitsu::eco_led"; 759 led->brightness_set_blocking = eco_led_set; 760 led->brightness_get = eco_led_get; 761 result = devm_led_classdev_register(&device->dev, led); 762 if (result) 763 return result; 764 } 765 766 return 0; 767 } 768 769 static int acpi_fujitsu_laptop_add(struct acpi_device *device) 770 { 771 struct fujitsu_laptop *priv; 772 int error; 773 int i; 774 775 priv = devm_kzalloc(&device->dev, sizeof(*priv), GFP_KERNEL); 776 if (!priv) 777 return -ENOMEM; 778 779 WARN_ONCE(fext, "More than one FUJ02E3 ACPI device was found. Driver may not work as intended."); 780 fext = device; 781 782 strcpy(acpi_device_name(device), ACPI_FUJITSU_LAPTOP_DEVICE_NAME); 783 strcpy(acpi_device_class(device), ACPI_FUJITSU_CLASS); 784 device->driver_data = priv; 785 786 /* kfifo */ 787 spin_lock_init(&priv->fifo_lock); 788 error = kfifo_alloc(&priv->fifo, RINGBUFFERSIZE * sizeof(int), 789 GFP_KERNEL); 790 if (error) { 791 pr_err("kfifo_alloc failed\n"); 792 goto err_stop; 793 } 794 795 error = acpi_fujitsu_laptop_input_setup(device); 796 if (error) 797 goto err_free_fifo; 798 799 pr_info("ACPI: %s [%s]\n", 800 acpi_device_name(device), acpi_device_bid(device)); 801 802 i = 0; 803 while (call_fext_func(device, FUNC_BUTTONS, 0x1, 0x0, 0x0) != 0 804 && (i++) < MAX_HOTKEY_RINGBUFFER_SIZE) 805 ; /* No action, result is discarded */ 806 acpi_handle_debug(device->handle, "Discarded %i ringbuffer entries\n", 807 i); 808 809 priv->flags_supported = call_fext_func(device, FUNC_FLAGS, 0x0, 0x0, 810 0x0); 811 812 /* Make sure our bitmask of supported functions is cleared if the 813 RFKILL function block is not implemented, like on the S7020. */ 814 if (priv->flags_supported == UNSUPPORTED_CMD) 815 priv->flags_supported = 0; 816 817 if (priv->flags_supported) 818 priv->flags_state = call_fext_func(device, FUNC_FLAGS, 0x4, 0x0, 819 0x0); 820 821 /* Suspect this is a keymap of the application panel, print it */ 822 acpi_handle_info(device->handle, "BTNI: [0x%x]\n", 823 call_fext_func(device, FUNC_BUTTONS, 0x0, 0x0, 0x0)); 824 825 /* Sync backlight power status */ 826 if (fujitsu_bl && fujitsu_bl->bl_device && 827 acpi_video_get_backlight_type() == acpi_backlight_vendor) { 828 if (call_fext_func(fext, FUNC_BACKLIGHT, 0x2, 0x4, 0x0) == 3) 829 fujitsu_bl->bl_device->props.power = FB_BLANK_POWERDOWN; 830 else 831 fujitsu_bl->bl_device->props.power = FB_BLANK_UNBLANK; 832 } 833 834 error = acpi_fujitsu_laptop_leds_register(device); 835 if (error) 836 goto err_free_fifo; 837 838 error = fujitsu_laptop_platform_add(device); 839 if (error) 840 goto err_free_fifo; 841 842 return 0; 843 844 err_free_fifo: 845 kfifo_free(&priv->fifo); 846 err_stop: 847 return error; 848 } 849 850 static int acpi_fujitsu_laptop_remove(struct acpi_device *device) 851 { 852 struct fujitsu_laptop *priv = acpi_driver_data(device); 853 854 fujitsu_laptop_platform_remove(device); 855 856 kfifo_free(&priv->fifo); 857 858 return 0; 859 } 860 861 static void acpi_fujitsu_laptop_press(struct acpi_device *device, int scancode) 862 { 863 struct fujitsu_laptop *priv = acpi_driver_data(device); 864 int status; 865 866 status = kfifo_in_locked(&priv->fifo, (unsigned char *)&scancode, 867 sizeof(scancode), &priv->fifo_lock); 868 if (status != sizeof(scancode)) { 869 dev_info(&priv->input->dev, "Could not push scancode [0x%x]\n", 870 scancode); 871 return; 872 } 873 sparse_keymap_report_event(priv->input, scancode, 1, false); 874 dev_dbg(&priv->input->dev, "Push scancode into ringbuffer [0x%x]\n", 875 scancode); 876 } 877 878 static void acpi_fujitsu_laptop_release(struct acpi_device *device) 879 { 880 struct fujitsu_laptop *priv = acpi_driver_data(device); 881 int scancode, status; 882 883 while (true) { 884 status = kfifo_out_locked(&priv->fifo, 885 (unsigned char *)&scancode, 886 sizeof(scancode), &priv->fifo_lock); 887 if (status != sizeof(scancode)) 888 return; 889 sparse_keymap_report_event(priv->input, scancode, 0, false); 890 dev_dbg(&priv->input->dev, 891 "Pop scancode from ringbuffer [0x%x]\n", scancode); 892 } 893 } 894 895 static void acpi_fujitsu_laptop_notify(struct acpi_device *device, u32 event) 896 { 897 struct fujitsu_laptop *priv = acpi_driver_data(device); 898 int scancode, i = 0; 899 unsigned int irb; 900 901 if (event != ACPI_FUJITSU_NOTIFY_CODE1) { 902 acpi_handle_info(device->handle, "Unsupported event [0x%x]\n", 903 event); 904 sparse_keymap_report_event(priv->input, -1, 1, true); 905 return; 906 } 907 908 if (priv->flags_supported) 909 priv->flags_state = call_fext_func(device, FUNC_FLAGS, 0x4, 0x0, 910 0x0); 911 912 while ((irb = call_fext_func(device, 913 FUNC_BUTTONS, 0x1, 0x0, 0x0)) != 0 && 914 i++ < MAX_HOTKEY_RINGBUFFER_SIZE) { 915 scancode = irb & 0x4ff; 916 if (sparse_keymap_entry_from_scancode(priv->input, scancode)) 917 acpi_fujitsu_laptop_press(device, scancode); 918 else if (scancode == 0) 919 acpi_fujitsu_laptop_release(device); 920 else 921 acpi_handle_info(device->handle, 922 "Unknown GIRB result [%x]\n", irb); 923 } 924 925 /* On some models (first seen on the Skylake-based Lifebook 926 * E736/E746/E756), the touchpad toggle hotkey (Fn+F4) is 927 * handled in software; its state is queried using FUNC_FLAGS 928 */ 929 if ((priv->flags_supported & BIT(26)) && 930 (call_fext_func(device, FUNC_FLAGS, 0x1, 0x0, 0x0) & BIT(26))) 931 sparse_keymap_report_event(priv->input, BIT(26), 1, true); 932 } 933 934 /* Initialization */ 935 936 static const struct acpi_device_id fujitsu_bl_device_ids[] = { 937 {ACPI_FUJITSU_BL_HID, 0}, 938 {"", 0}, 939 }; 940 941 static struct acpi_driver acpi_fujitsu_bl_driver = { 942 .name = ACPI_FUJITSU_BL_DRIVER_NAME, 943 .class = ACPI_FUJITSU_CLASS, 944 .ids = fujitsu_bl_device_ids, 945 .ops = { 946 .add = acpi_fujitsu_bl_add, 947 .notify = acpi_fujitsu_bl_notify, 948 }, 949 }; 950 951 static const struct acpi_device_id fujitsu_laptop_device_ids[] = { 952 {ACPI_FUJITSU_LAPTOP_HID, 0}, 953 {"", 0}, 954 }; 955 956 static struct acpi_driver acpi_fujitsu_laptop_driver = { 957 .name = ACPI_FUJITSU_LAPTOP_DRIVER_NAME, 958 .class = ACPI_FUJITSU_CLASS, 959 .ids = fujitsu_laptop_device_ids, 960 .ops = { 961 .add = acpi_fujitsu_laptop_add, 962 .remove = acpi_fujitsu_laptop_remove, 963 .notify = acpi_fujitsu_laptop_notify, 964 }, 965 }; 966 967 static const struct acpi_device_id fujitsu_ids[] __used = { 968 {ACPI_FUJITSU_BL_HID, 0}, 969 {ACPI_FUJITSU_LAPTOP_HID, 0}, 970 {"", 0} 971 }; 972 MODULE_DEVICE_TABLE(acpi, fujitsu_ids); 973 974 static int __init fujitsu_init(void) 975 { 976 int ret; 977 978 ret = acpi_bus_register_driver(&acpi_fujitsu_bl_driver); 979 if (ret) 980 return ret; 981 982 /* Register platform stuff */ 983 984 ret = platform_driver_register(&fujitsu_pf_driver); 985 if (ret) 986 goto err_unregister_acpi; 987 988 /* Register laptop driver */ 989 990 ret = acpi_bus_register_driver(&acpi_fujitsu_laptop_driver); 991 if (ret) 992 goto err_unregister_platform_driver; 993 994 pr_info("driver " FUJITSU_DRIVER_VERSION " successfully loaded\n"); 995 996 return 0; 997 998 err_unregister_platform_driver: 999 platform_driver_unregister(&fujitsu_pf_driver); 1000 err_unregister_acpi: 1001 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver); 1002 1003 return ret; 1004 } 1005 1006 static void __exit fujitsu_cleanup(void) 1007 { 1008 acpi_bus_unregister_driver(&acpi_fujitsu_laptop_driver); 1009 1010 platform_driver_unregister(&fujitsu_pf_driver); 1011 1012 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver); 1013 1014 pr_info("driver unloaded\n"); 1015 } 1016 1017 module_init(fujitsu_init); 1018 module_exit(fujitsu_cleanup); 1019 1020 module_param(use_alt_lcd_levels, int, 0644); 1021 MODULE_PARM_DESC(use_alt_lcd_levels, "Interface used for setting LCD brightness level (-1 = auto, 0 = force SBLL, 1 = force SBL2)"); 1022 module_param(disable_brightness_adjust, bool, 0644); 1023 MODULE_PARM_DESC(disable_brightness_adjust, "Disable LCD brightness adjustment"); 1024 1025 MODULE_AUTHOR("Jonathan Woithe, Peter Gruber, Tony Vroon"); 1026 MODULE_DESCRIPTION("Fujitsu laptop extras support"); 1027 MODULE_VERSION(FUJITSU_DRIVER_VERSION); 1028 MODULE_LICENSE("GPL"); 1029