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 exports a few files in /sys/devices/platform/fujitsu-laptop/; 36 * others may be added at a later date. 37 * 38 * lcd_level - Screen brightness: contains a single integer in the 39 * range 0..7. (rw) 40 * 41 * In addition to these platform device attributes the driver 42 * registers itself in the Linux backlight control subsystem and is 43 * available to userspace under /sys/class/backlight/fujitsu-laptop/. 44 * 45 * Hotkeys present on certain Fujitsu laptops (eg: the S6xxx series) are 46 * also supported by this driver. 47 * 48 * This driver has been tested on a Fujitsu Lifebook S6410, S7020 and 49 * P8010. It should work on most P-series and S-series Lifebooks, but 50 * YMMV. 51 * 52 * The module parameter use_alt_lcd_levels switches between different ACPI 53 * brightness controls which are used by different Fujitsu laptops. In most 54 * cases the correct method is automatically detected. "use_alt_lcd_levels=1" 55 * is applicable for a Fujitsu Lifebook S6410 if autodetection fails. 56 * 57 */ 58 59 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 60 61 #include <linux/module.h> 62 #include <linux/kernel.h> 63 #include <linux/init.h> 64 #include <linux/acpi.h> 65 #include <linux/dmi.h> 66 #include <linux/backlight.h> 67 #include <linux/input.h> 68 #include <linux/kfifo.h> 69 #include <linux/platform_device.h> 70 #include <linux/slab.h> 71 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE) 72 #include <linux/leds.h> 73 #endif 74 75 #define FUJITSU_DRIVER_VERSION "0.6.0" 76 77 #define FUJITSU_LCD_N_LEVELS 8 78 79 #define ACPI_FUJITSU_CLASS "fujitsu" 80 #define ACPI_FUJITSU_HID "FUJ02B1" 81 #define ACPI_FUJITSU_DRIVER_NAME "Fujitsu laptop FUJ02B1 ACPI brightness driver" 82 #define ACPI_FUJITSU_DEVICE_NAME "Fujitsu FUJ02B1" 83 #define ACPI_FUJITSU_HOTKEY_HID "FUJ02E3" 84 #define ACPI_FUJITSU_HOTKEY_DRIVER_NAME "Fujitsu laptop FUJ02E3 ACPI hotkeys driver" 85 #define ACPI_FUJITSU_HOTKEY_DEVICE_NAME "Fujitsu FUJ02E3" 86 87 #define ACPI_FUJITSU_NOTIFY_CODE1 0x80 88 89 #define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86 90 #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87 91 92 /* FUNC interface - command values */ 93 #define FUNC_RFKILL 0x1000 94 #define FUNC_LEDS 0x1001 95 #define FUNC_BUTTONS 0x1002 96 #define FUNC_BACKLIGHT 0x1004 97 98 /* FUNC interface - responses */ 99 #define UNSUPPORTED_CMD 0x80000000 100 101 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE) 102 /* FUNC interface - LED control */ 103 #define FUNC_LED_OFF 0x1 104 #define FUNC_LED_ON 0x30001 105 #define KEYBOARD_LAMPS 0x100 106 #define LOGOLAMP_POWERON 0x2000 107 #define LOGOLAMP_ALWAYS 0x4000 108 #endif 109 110 /* Hotkey details */ 111 #define KEY1_CODE 0x410 /* codes for the keys in the GIRB register */ 112 #define KEY2_CODE 0x411 113 #define KEY3_CODE 0x412 114 #define KEY4_CODE 0x413 115 116 #define MAX_HOTKEY_RINGBUFFER_SIZE 100 117 #define RINGBUFFERSIZE 40 118 119 /* Debugging */ 120 #define FUJLAPTOP_LOG ACPI_FUJITSU_HID ": " 121 #define FUJLAPTOP_ERR KERN_ERR FUJLAPTOP_LOG 122 #define FUJLAPTOP_NOTICE KERN_NOTICE FUJLAPTOP_LOG 123 #define FUJLAPTOP_INFO KERN_INFO FUJLAPTOP_LOG 124 #define FUJLAPTOP_DEBUG KERN_DEBUG FUJLAPTOP_LOG 125 126 #define FUJLAPTOP_DBG_ALL 0xffff 127 #define FUJLAPTOP_DBG_ERROR 0x0001 128 #define FUJLAPTOP_DBG_WARN 0x0002 129 #define FUJLAPTOP_DBG_INFO 0x0004 130 #define FUJLAPTOP_DBG_TRACE 0x0008 131 132 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG 133 #define vdbg_printk(a_dbg_level, format, arg...) \ 134 do { if (dbg_level & a_dbg_level) \ 135 printk(FUJLAPTOP_DEBUG "%s: " format, __func__ , ## arg); \ 136 } while (0) 137 #else 138 #define vdbg_printk(a_dbg_level, format, arg...) \ 139 do { } while (0) 140 #endif 141 142 /* Device controlling the backlight and associated keys */ 143 struct fujitsu_t { 144 acpi_handle acpi_handle; 145 struct acpi_device *dev; 146 struct input_dev *input; 147 char phys[32]; 148 struct backlight_device *bl_device; 149 struct platform_device *pf_device; 150 int keycode1, keycode2, keycode3, keycode4; 151 152 unsigned int max_brightness; 153 unsigned int brightness_changed; 154 unsigned int brightness_level; 155 }; 156 157 static struct fujitsu_t *fujitsu; 158 static int use_alt_lcd_levels = -1; 159 static int disable_brightness_adjust = -1; 160 161 /* Device used to access other hotkeys on the laptop */ 162 struct fujitsu_hotkey_t { 163 acpi_handle acpi_handle; 164 struct acpi_device *dev; 165 struct input_dev *input; 166 char phys[32]; 167 struct platform_device *pf_device; 168 struct kfifo fifo; 169 spinlock_t fifo_lock; 170 int rfkill_supported; 171 int rfkill_state; 172 int logolamp_registered; 173 int kblamps_registered; 174 }; 175 176 static struct fujitsu_hotkey_t *fujitsu_hotkey; 177 178 static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event); 179 180 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE) 181 static enum led_brightness logolamp_get(struct led_classdev *cdev); 182 static void logolamp_set(struct led_classdev *cdev, 183 enum led_brightness brightness); 184 185 static struct led_classdev logolamp_led = { 186 .name = "fujitsu::logolamp", 187 .brightness_get = logolamp_get, 188 .brightness_set = logolamp_set 189 }; 190 191 static enum led_brightness kblamps_get(struct led_classdev *cdev); 192 static void kblamps_set(struct led_classdev *cdev, 193 enum led_brightness brightness); 194 195 static struct led_classdev kblamps_led = { 196 .name = "fujitsu::kblamps", 197 .brightness_get = kblamps_get, 198 .brightness_set = kblamps_set 199 }; 200 #endif 201 202 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG 203 static u32 dbg_level = 0x03; 204 #endif 205 206 static void acpi_fujitsu_notify(struct acpi_device *device, u32 event); 207 208 /* Fujitsu ACPI interface function */ 209 210 static int call_fext_func(int cmd, int arg0, int arg1, int arg2) 211 { 212 acpi_status status = AE_OK; 213 union acpi_object params[4] = { 214 { .type = ACPI_TYPE_INTEGER }, 215 { .type = ACPI_TYPE_INTEGER }, 216 { .type = ACPI_TYPE_INTEGER }, 217 { .type = ACPI_TYPE_INTEGER } 218 }; 219 struct acpi_object_list arg_list = { 4, ¶ms[0] }; 220 unsigned long long value; 221 acpi_handle handle = NULL; 222 223 status = acpi_get_handle(fujitsu_hotkey->acpi_handle, "FUNC", &handle); 224 if (ACPI_FAILURE(status)) { 225 vdbg_printk(FUJLAPTOP_DBG_ERROR, 226 "FUNC interface is not present\n"); 227 return -ENODEV; 228 } 229 230 params[0].integer.value = cmd; 231 params[1].integer.value = arg0; 232 params[2].integer.value = arg1; 233 params[3].integer.value = arg2; 234 235 status = acpi_evaluate_integer(handle, NULL, &arg_list, &value); 236 if (ACPI_FAILURE(status)) { 237 vdbg_printk(FUJLAPTOP_DBG_WARN, 238 "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) call failed\n", 239 cmd, arg0, arg1, arg2); 240 return -ENODEV; 241 } 242 243 vdbg_printk(FUJLAPTOP_DBG_TRACE, 244 "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) returned 0x%x\n", 245 cmd, arg0, arg1, arg2, (int)value); 246 return value; 247 } 248 249 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE) 250 /* LED class callbacks */ 251 252 static void logolamp_set(struct led_classdev *cdev, 253 enum led_brightness brightness) 254 { 255 if (brightness >= LED_FULL) { 256 call_fext_func(FUNC_LEDS, 0x1, LOGOLAMP_POWERON, FUNC_LED_ON); 257 call_fext_func(FUNC_LEDS, 0x1, LOGOLAMP_ALWAYS, FUNC_LED_ON); 258 } else if (brightness >= LED_HALF) { 259 call_fext_func(FUNC_LEDS, 0x1, LOGOLAMP_POWERON, FUNC_LED_ON); 260 call_fext_func(FUNC_LEDS, 0x1, LOGOLAMP_ALWAYS, FUNC_LED_OFF); 261 } else { 262 call_fext_func(FUNC_LEDS, 0x1, LOGOLAMP_POWERON, FUNC_LED_OFF); 263 } 264 } 265 266 static void kblamps_set(struct led_classdev *cdev, 267 enum led_brightness brightness) 268 { 269 if (brightness >= LED_FULL) 270 call_fext_func(FUNC_LEDS, 0x1, KEYBOARD_LAMPS, FUNC_LED_ON); 271 else 272 call_fext_func(FUNC_LEDS, 0x1, KEYBOARD_LAMPS, FUNC_LED_OFF); 273 } 274 275 static enum led_brightness logolamp_get(struct led_classdev *cdev) 276 { 277 enum led_brightness brightness = LED_OFF; 278 int poweron, always; 279 280 poweron = call_fext_func(FUNC_LEDS, 0x2, LOGOLAMP_POWERON, 0x0); 281 if (poweron == FUNC_LED_ON) { 282 brightness = LED_HALF; 283 always = call_fext_func(FUNC_LEDS, 0x2, LOGOLAMP_ALWAYS, 0x0); 284 if (always == FUNC_LED_ON) 285 brightness = LED_FULL; 286 } 287 return brightness; 288 } 289 290 static enum led_brightness kblamps_get(struct led_classdev *cdev) 291 { 292 enum led_brightness brightness = LED_OFF; 293 294 if (call_fext_func(FUNC_LEDS, 0x2, KEYBOARD_LAMPS, 0x0) == FUNC_LED_ON) 295 brightness = LED_FULL; 296 297 return brightness; 298 } 299 #endif 300 301 /* Hardware access for LCD brightness control */ 302 303 static int set_lcd_level(int level) 304 { 305 acpi_status status = AE_OK; 306 acpi_handle handle = NULL; 307 308 vdbg_printk(FUJLAPTOP_DBG_TRACE, "set lcd level via SBLL [%d]\n", 309 level); 310 311 if (level < 0 || level >= fujitsu->max_brightness) 312 return -EINVAL; 313 314 status = acpi_get_handle(fujitsu->acpi_handle, "SBLL", &handle); 315 if (ACPI_FAILURE(status)) { 316 vdbg_printk(FUJLAPTOP_DBG_ERROR, "SBLL not present\n"); 317 return -ENODEV; 318 } 319 320 321 status = acpi_execute_simple_method(handle, NULL, level); 322 if (ACPI_FAILURE(status)) 323 return -ENODEV; 324 325 return 0; 326 } 327 328 static int set_lcd_level_alt(int level) 329 { 330 acpi_status status = AE_OK; 331 acpi_handle handle = NULL; 332 333 vdbg_printk(FUJLAPTOP_DBG_TRACE, "set lcd level via SBL2 [%d]\n", 334 level); 335 336 if (level < 0 || level >= fujitsu->max_brightness) 337 return -EINVAL; 338 339 status = acpi_get_handle(fujitsu->acpi_handle, "SBL2", &handle); 340 if (ACPI_FAILURE(status)) { 341 vdbg_printk(FUJLAPTOP_DBG_ERROR, "SBL2 not present\n"); 342 return -ENODEV; 343 } 344 345 status = acpi_execute_simple_method(handle, NULL, level); 346 if (ACPI_FAILURE(status)) 347 return -ENODEV; 348 349 return 0; 350 } 351 352 static int get_lcd_level(void) 353 { 354 unsigned long long state = 0; 355 acpi_status status = AE_OK; 356 357 vdbg_printk(FUJLAPTOP_DBG_TRACE, "get lcd level via GBLL\n"); 358 359 status = 360 acpi_evaluate_integer(fujitsu->acpi_handle, "GBLL", NULL, &state); 361 if (ACPI_FAILURE(status)) 362 return 0; 363 364 fujitsu->brightness_level = state & 0x0fffffff; 365 366 if (state & 0x80000000) 367 fujitsu->brightness_changed = 1; 368 else 369 fujitsu->brightness_changed = 0; 370 371 return fujitsu->brightness_level; 372 } 373 374 static int get_max_brightness(void) 375 { 376 unsigned long long state = 0; 377 acpi_status status = AE_OK; 378 379 vdbg_printk(FUJLAPTOP_DBG_TRACE, "get max lcd level via RBLL\n"); 380 381 status = 382 acpi_evaluate_integer(fujitsu->acpi_handle, "RBLL", NULL, &state); 383 if (ACPI_FAILURE(status)) 384 return -1; 385 386 fujitsu->max_brightness = state; 387 388 return fujitsu->max_brightness; 389 } 390 391 /* Backlight device stuff */ 392 393 static int bl_get_brightness(struct backlight_device *b) 394 { 395 return get_lcd_level(); 396 } 397 398 static int bl_update_status(struct backlight_device *b) 399 { 400 int ret; 401 if (b->props.power == 4) 402 ret = call_fext_func(FUNC_BACKLIGHT, 0x1, 0x4, 0x3); 403 else 404 ret = call_fext_func(FUNC_BACKLIGHT, 0x1, 0x4, 0x0); 405 if (ret != 0) 406 vdbg_printk(FUJLAPTOP_DBG_ERROR, 407 "Unable to adjust backlight power, error code %i\n", 408 ret); 409 410 if (use_alt_lcd_levels) 411 ret = set_lcd_level_alt(b->props.brightness); 412 else 413 ret = set_lcd_level(b->props.brightness); 414 if (ret != 0) 415 vdbg_printk(FUJLAPTOP_DBG_ERROR, 416 "Unable to adjust LCD brightness, error code %i\n", 417 ret); 418 return ret; 419 } 420 421 static const struct backlight_ops fujitsubl_ops = { 422 .get_brightness = bl_get_brightness, 423 .update_status = bl_update_status, 424 }; 425 426 /* Platform LCD brightness device */ 427 428 static ssize_t 429 show_max_brightness(struct device *dev, 430 struct device_attribute *attr, char *buf) 431 { 432 433 int ret; 434 435 ret = get_max_brightness(); 436 if (ret < 0) 437 return ret; 438 439 return sprintf(buf, "%i\n", ret); 440 } 441 442 static ssize_t 443 show_brightness_changed(struct device *dev, 444 struct device_attribute *attr, char *buf) 445 { 446 447 int ret; 448 449 ret = fujitsu->brightness_changed; 450 if (ret < 0) 451 return ret; 452 453 return sprintf(buf, "%i\n", ret); 454 } 455 456 static ssize_t show_lcd_level(struct device *dev, 457 struct device_attribute *attr, char *buf) 458 { 459 460 int ret; 461 462 ret = get_lcd_level(); 463 if (ret < 0) 464 return ret; 465 466 return sprintf(buf, "%i\n", ret); 467 } 468 469 static ssize_t store_lcd_level(struct device *dev, 470 struct device_attribute *attr, const char *buf, 471 size_t count) 472 { 473 474 int level, ret; 475 476 if (sscanf(buf, "%i", &level) != 1 477 || (level < 0 || level >= fujitsu->max_brightness)) 478 return -EINVAL; 479 480 if (use_alt_lcd_levels) 481 ret = set_lcd_level_alt(level); 482 else 483 ret = set_lcd_level(level); 484 if (ret < 0) 485 return ret; 486 487 ret = get_lcd_level(); 488 if (ret < 0) 489 return ret; 490 491 return count; 492 } 493 494 static ssize_t 495 ignore_store(struct device *dev, 496 struct device_attribute *attr, const char *buf, size_t count) 497 { 498 return count; 499 } 500 501 static ssize_t 502 show_lid_state(struct device *dev, 503 struct device_attribute *attr, char *buf) 504 { 505 if (!(fujitsu_hotkey->rfkill_supported & 0x100)) 506 return sprintf(buf, "unknown\n"); 507 if (fujitsu_hotkey->rfkill_state & 0x100) 508 return sprintf(buf, "open\n"); 509 else 510 return sprintf(buf, "closed\n"); 511 } 512 513 static ssize_t 514 show_dock_state(struct device *dev, 515 struct device_attribute *attr, char *buf) 516 { 517 if (!(fujitsu_hotkey->rfkill_supported & 0x200)) 518 return sprintf(buf, "unknown\n"); 519 if (fujitsu_hotkey->rfkill_state & 0x200) 520 return sprintf(buf, "docked\n"); 521 else 522 return sprintf(buf, "undocked\n"); 523 } 524 525 static ssize_t 526 show_radios_state(struct device *dev, 527 struct device_attribute *attr, char *buf) 528 { 529 if (!(fujitsu_hotkey->rfkill_supported & 0x20)) 530 return sprintf(buf, "unknown\n"); 531 if (fujitsu_hotkey->rfkill_state & 0x20) 532 return sprintf(buf, "on\n"); 533 else 534 return sprintf(buf, "killed\n"); 535 } 536 537 static DEVICE_ATTR(max_brightness, 0444, show_max_brightness, ignore_store); 538 static DEVICE_ATTR(brightness_changed, 0444, show_brightness_changed, 539 ignore_store); 540 static DEVICE_ATTR(lcd_level, 0644, show_lcd_level, store_lcd_level); 541 static DEVICE_ATTR(lid, 0444, show_lid_state, ignore_store); 542 static DEVICE_ATTR(dock, 0444, show_dock_state, ignore_store); 543 static DEVICE_ATTR(radios, 0444, show_radios_state, ignore_store); 544 545 static struct attribute *fujitsupf_attributes[] = { 546 &dev_attr_brightness_changed.attr, 547 &dev_attr_max_brightness.attr, 548 &dev_attr_lcd_level.attr, 549 &dev_attr_lid.attr, 550 &dev_attr_dock.attr, 551 &dev_attr_radios.attr, 552 NULL 553 }; 554 555 static struct attribute_group fujitsupf_attribute_group = { 556 .attrs = fujitsupf_attributes 557 }; 558 559 static struct platform_driver fujitsupf_driver = { 560 .driver = { 561 .name = "fujitsu-laptop", 562 } 563 }; 564 565 static void __init dmi_check_cb_common(const struct dmi_system_id *id) 566 { 567 pr_info("Identified laptop model '%s'\n", id->ident); 568 if (use_alt_lcd_levels == -1) { 569 if (acpi_has_method(NULL, 570 "\\_SB.PCI0.LPCB.FJEX.SBL2")) 571 use_alt_lcd_levels = 1; 572 else 573 use_alt_lcd_levels = 0; 574 vdbg_printk(FUJLAPTOP_DBG_TRACE, "auto-detected usealt as " 575 "%i\n", use_alt_lcd_levels); 576 } 577 } 578 579 static int __init dmi_check_cb_s6410(const struct dmi_system_id *id) 580 { 581 dmi_check_cb_common(id); 582 fujitsu->keycode1 = KEY_SCREENLOCK; /* "Lock" */ 583 fujitsu->keycode2 = KEY_HELP; /* "Mobility Center" */ 584 return 1; 585 } 586 587 static int __init dmi_check_cb_s6420(const struct dmi_system_id *id) 588 { 589 dmi_check_cb_common(id); 590 fujitsu->keycode1 = KEY_SCREENLOCK; /* "Lock" */ 591 fujitsu->keycode2 = KEY_HELP; /* "Mobility Center" */ 592 return 1; 593 } 594 595 static int __init dmi_check_cb_p8010(const struct dmi_system_id *id) 596 { 597 dmi_check_cb_common(id); 598 fujitsu->keycode1 = KEY_HELP; /* "Support" */ 599 fujitsu->keycode3 = KEY_SWITCHVIDEOMODE; /* "Presentation" */ 600 fujitsu->keycode4 = KEY_WWW; /* "Internet" */ 601 return 1; 602 } 603 604 static const struct dmi_system_id fujitsu_dmi_table[] __initconst = { 605 { 606 .ident = "Fujitsu Siemens S6410", 607 .matches = { 608 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 609 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK S6410"), 610 }, 611 .callback = dmi_check_cb_s6410}, 612 { 613 .ident = "Fujitsu Siemens S6420", 614 .matches = { 615 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 616 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK S6420"), 617 }, 618 .callback = dmi_check_cb_s6420}, 619 { 620 .ident = "Fujitsu LifeBook P8010", 621 .matches = { 622 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 623 DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook P8010"), 624 }, 625 .callback = dmi_check_cb_p8010}, 626 {} 627 }; 628 629 /* ACPI device for LCD brightness control */ 630 631 static int acpi_fujitsu_add(struct acpi_device *device) 632 { 633 int state = 0; 634 struct input_dev *input; 635 int error; 636 637 if (!device) 638 return -EINVAL; 639 640 fujitsu->acpi_handle = device->handle; 641 sprintf(acpi_device_name(device), "%s", ACPI_FUJITSU_DEVICE_NAME); 642 sprintf(acpi_device_class(device), "%s", ACPI_FUJITSU_CLASS); 643 device->driver_data = fujitsu; 644 645 fujitsu->input = input = input_allocate_device(); 646 if (!input) { 647 error = -ENOMEM; 648 goto err_stop; 649 } 650 651 snprintf(fujitsu->phys, sizeof(fujitsu->phys), 652 "%s/video/input0", acpi_device_hid(device)); 653 654 input->name = acpi_device_name(device); 655 input->phys = fujitsu->phys; 656 input->id.bustype = BUS_HOST; 657 input->id.product = 0x06; 658 input->dev.parent = &device->dev; 659 input->evbit[0] = BIT(EV_KEY); 660 set_bit(KEY_BRIGHTNESSUP, input->keybit); 661 set_bit(KEY_BRIGHTNESSDOWN, input->keybit); 662 set_bit(KEY_UNKNOWN, input->keybit); 663 664 error = input_register_device(input); 665 if (error) 666 goto err_free_input_dev; 667 668 error = acpi_bus_update_power(fujitsu->acpi_handle, &state); 669 if (error) { 670 pr_err("Error reading power state\n"); 671 goto err_unregister_input_dev; 672 } 673 674 pr_info("ACPI: %s [%s] (%s)\n", 675 acpi_device_name(device), acpi_device_bid(device), 676 !device->power.state ? "on" : "off"); 677 678 fujitsu->dev = device; 679 680 if (acpi_has_method(device->handle, METHOD_NAME__INI)) { 681 vdbg_printk(FUJLAPTOP_DBG_INFO, "Invoking _INI\n"); 682 if (ACPI_FAILURE 683 (acpi_evaluate_object 684 (device->handle, METHOD_NAME__INI, NULL, NULL))) 685 pr_err("_INI Method failed\n"); 686 } 687 688 /* do config (detect defaults) */ 689 use_alt_lcd_levels = use_alt_lcd_levels == 1 ? 1 : 0; 690 disable_brightness_adjust = disable_brightness_adjust == 1 ? 1 : 0; 691 vdbg_printk(FUJLAPTOP_DBG_INFO, 692 "config: [alt interface: %d], [adjust disable: %d]\n", 693 use_alt_lcd_levels, disable_brightness_adjust); 694 695 if (get_max_brightness() <= 0) 696 fujitsu->max_brightness = FUJITSU_LCD_N_LEVELS; 697 get_lcd_level(); 698 699 return 0; 700 701 err_unregister_input_dev: 702 input_unregister_device(input); 703 input = NULL; 704 err_free_input_dev: 705 input_free_device(input); 706 err_stop: 707 return error; 708 } 709 710 static int acpi_fujitsu_remove(struct acpi_device *device) 711 { 712 struct fujitsu_t *fujitsu = acpi_driver_data(device); 713 struct input_dev *input = fujitsu->input; 714 715 input_unregister_device(input); 716 717 fujitsu->acpi_handle = NULL; 718 719 return 0; 720 } 721 722 /* Brightness notify */ 723 724 static void acpi_fujitsu_notify(struct acpi_device *device, u32 event) 725 { 726 struct input_dev *input; 727 int keycode; 728 int oldb, newb; 729 730 input = fujitsu->input; 731 732 switch (event) { 733 case ACPI_FUJITSU_NOTIFY_CODE1: 734 keycode = 0; 735 oldb = fujitsu->brightness_level; 736 get_lcd_level(); 737 newb = fujitsu->brightness_level; 738 739 vdbg_printk(FUJLAPTOP_DBG_TRACE, 740 "brightness button event [%i -> %i (%i)]\n", 741 oldb, newb, fujitsu->brightness_changed); 742 743 if (oldb < newb) { 744 if (disable_brightness_adjust != 1) { 745 if (use_alt_lcd_levels) 746 set_lcd_level_alt(newb); 747 else 748 set_lcd_level(newb); 749 } 750 keycode = KEY_BRIGHTNESSUP; 751 } else if (oldb > newb) { 752 if (disable_brightness_adjust != 1) { 753 if (use_alt_lcd_levels) 754 set_lcd_level_alt(newb); 755 else 756 set_lcd_level(newb); 757 } 758 keycode = KEY_BRIGHTNESSDOWN; 759 } 760 break; 761 default: 762 keycode = KEY_UNKNOWN; 763 vdbg_printk(FUJLAPTOP_DBG_WARN, 764 "unsupported event [0x%x]\n", event); 765 break; 766 } 767 768 if (keycode != 0) { 769 input_report_key(input, keycode, 1); 770 input_sync(input); 771 input_report_key(input, keycode, 0); 772 input_sync(input); 773 } 774 } 775 776 /* ACPI device for hotkey handling */ 777 778 static int acpi_fujitsu_hotkey_add(struct acpi_device *device) 779 { 780 int result = 0; 781 int state = 0; 782 struct input_dev *input; 783 int error; 784 int i; 785 786 if (!device) 787 return -EINVAL; 788 789 fujitsu_hotkey->acpi_handle = device->handle; 790 sprintf(acpi_device_name(device), "%s", 791 ACPI_FUJITSU_HOTKEY_DEVICE_NAME); 792 sprintf(acpi_device_class(device), "%s", ACPI_FUJITSU_CLASS); 793 device->driver_data = fujitsu_hotkey; 794 795 /* kfifo */ 796 spin_lock_init(&fujitsu_hotkey->fifo_lock); 797 error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int), 798 GFP_KERNEL); 799 if (error) { 800 pr_err("kfifo_alloc failed\n"); 801 goto err_stop; 802 } 803 804 fujitsu_hotkey->input = input = input_allocate_device(); 805 if (!input) { 806 error = -ENOMEM; 807 goto err_free_fifo; 808 } 809 810 snprintf(fujitsu_hotkey->phys, sizeof(fujitsu_hotkey->phys), 811 "%s/video/input0", acpi_device_hid(device)); 812 813 input->name = acpi_device_name(device); 814 input->phys = fujitsu_hotkey->phys; 815 input->id.bustype = BUS_HOST; 816 input->id.product = 0x06; 817 input->dev.parent = &device->dev; 818 819 set_bit(EV_KEY, input->evbit); 820 set_bit(fujitsu->keycode1, input->keybit); 821 set_bit(fujitsu->keycode2, input->keybit); 822 set_bit(fujitsu->keycode3, input->keybit); 823 set_bit(fujitsu->keycode4, input->keybit); 824 set_bit(KEY_UNKNOWN, input->keybit); 825 826 error = input_register_device(input); 827 if (error) 828 goto err_free_input_dev; 829 830 error = acpi_bus_update_power(fujitsu_hotkey->acpi_handle, &state); 831 if (error) { 832 pr_err("Error reading power state\n"); 833 goto err_unregister_input_dev; 834 } 835 836 pr_info("ACPI: %s [%s] (%s)\n", 837 acpi_device_name(device), acpi_device_bid(device), 838 !device->power.state ? "on" : "off"); 839 840 fujitsu_hotkey->dev = device; 841 842 if (acpi_has_method(device->handle, METHOD_NAME__INI)) { 843 vdbg_printk(FUJLAPTOP_DBG_INFO, "Invoking _INI\n"); 844 if (ACPI_FAILURE 845 (acpi_evaluate_object 846 (device->handle, METHOD_NAME__INI, NULL, NULL))) 847 pr_err("_INI Method failed\n"); 848 } 849 850 i = 0; 851 while (call_fext_func(FUNC_BUTTONS, 0x1, 0x0, 0x0) != 0 852 && (i++) < MAX_HOTKEY_RINGBUFFER_SIZE) 853 ; /* No action, result is discarded */ 854 vdbg_printk(FUJLAPTOP_DBG_INFO, "Discarded %i ringbuffer entries\n", i); 855 856 fujitsu_hotkey->rfkill_supported = 857 call_fext_func(FUNC_RFKILL, 0x0, 0x0, 0x0); 858 859 /* Make sure our bitmask of supported functions is cleared if the 860 RFKILL function block is not implemented, like on the S7020. */ 861 if (fujitsu_hotkey->rfkill_supported == UNSUPPORTED_CMD) 862 fujitsu_hotkey->rfkill_supported = 0; 863 864 if (fujitsu_hotkey->rfkill_supported) 865 fujitsu_hotkey->rfkill_state = 866 call_fext_func(FUNC_RFKILL, 0x4, 0x0, 0x0); 867 868 /* Suspect this is a keymap of the application panel, print it */ 869 pr_info("BTNI: [0x%x]\n", call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0)); 870 871 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE) 872 if (call_fext_func(FUNC_LEDS, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON) { 873 result = led_classdev_register(&fujitsu->pf_device->dev, 874 &logolamp_led); 875 if (result == 0) { 876 fujitsu_hotkey->logolamp_registered = 1; 877 } else { 878 pr_err("Could not register LED handler for logo lamp, error %i\n", 879 result); 880 } 881 } 882 883 if ((call_fext_func(FUNC_LEDS, 0x0, 0x0, 0x0) & KEYBOARD_LAMPS) && 884 (call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0) == 0x0)) { 885 result = led_classdev_register(&fujitsu->pf_device->dev, 886 &kblamps_led); 887 if (result == 0) { 888 fujitsu_hotkey->kblamps_registered = 1; 889 } else { 890 pr_err("Could not register LED handler for keyboard lamps, error %i\n", 891 result); 892 } 893 } 894 #endif 895 896 return result; 897 898 err_unregister_input_dev: 899 input_unregister_device(input); 900 input = NULL; 901 err_free_input_dev: 902 input_free_device(input); 903 err_free_fifo: 904 kfifo_free(&fujitsu_hotkey->fifo); 905 err_stop: 906 return error; 907 } 908 909 static int acpi_fujitsu_hotkey_remove(struct acpi_device *device) 910 { 911 struct fujitsu_hotkey_t *fujitsu_hotkey = acpi_driver_data(device); 912 struct input_dev *input = fujitsu_hotkey->input; 913 914 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE) 915 if (fujitsu_hotkey->logolamp_registered) 916 led_classdev_unregister(&logolamp_led); 917 918 if (fujitsu_hotkey->kblamps_registered) 919 led_classdev_unregister(&kblamps_led); 920 #endif 921 922 input_unregister_device(input); 923 924 kfifo_free(&fujitsu_hotkey->fifo); 925 926 fujitsu_hotkey->acpi_handle = NULL; 927 928 return 0; 929 } 930 931 static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event) 932 { 933 struct input_dev *input; 934 int keycode, keycode_r; 935 unsigned int irb = 1; 936 int i, status; 937 938 input = fujitsu_hotkey->input; 939 940 if (fujitsu_hotkey->rfkill_supported) 941 fujitsu_hotkey->rfkill_state = 942 call_fext_func(FUNC_RFKILL, 0x4, 0x0, 0x0); 943 944 switch (event) { 945 case ACPI_FUJITSU_NOTIFY_CODE1: 946 i = 0; 947 while ((irb = 948 call_fext_func(FUNC_BUTTONS, 0x1, 0x0, 0x0)) != 0 949 && (i++) < MAX_HOTKEY_RINGBUFFER_SIZE) { 950 switch (irb & 0x4ff) { 951 case KEY1_CODE: 952 keycode = fujitsu->keycode1; 953 break; 954 case KEY2_CODE: 955 keycode = fujitsu->keycode2; 956 break; 957 case KEY3_CODE: 958 keycode = fujitsu->keycode3; 959 break; 960 case KEY4_CODE: 961 keycode = fujitsu->keycode4; 962 break; 963 case 0: 964 keycode = 0; 965 break; 966 default: 967 vdbg_printk(FUJLAPTOP_DBG_WARN, 968 "Unknown GIRB result [%x]\n", irb); 969 keycode = -1; 970 break; 971 } 972 if (keycode > 0) { 973 vdbg_printk(FUJLAPTOP_DBG_TRACE, 974 "Push keycode into ringbuffer [%d]\n", 975 keycode); 976 status = kfifo_in_locked(&fujitsu_hotkey->fifo, 977 (unsigned char *)&keycode, 978 sizeof(keycode), 979 &fujitsu_hotkey->fifo_lock); 980 if (status != sizeof(keycode)) { 981 vdbg_printk(FUJLAPTOP_DBG_WARN, 982 "Could not push keycode [0x%x]\n", 983 keycode); 984 } else { 985 input_report_key(input, keycode, 1); 986 input_sync(input); 987 } 988 } else if (keycode == 0) { 989 while ((status = 990 kfifo_out_locked( 991 &fujitsu_hotkey->fifo, 992 (unsigned char *) &keycode_r, 993 sizeof(keycode_r), 994 &fujitsu_hotkey->fifo_lock)) 995 == sizeof(keycode_r)) { 996 input_report_key(input, keycode_r, 0); 997 input_sync(input); 998 vdbg_printk(FUJLAPTOP_DBG_TRACE, 999 "Pop keycode from ringbuffer [%d]\n", 1000 keycode_r); 1001 } 1002 } 1003 } 1004 1005 break; 1006 default: 1007 keycode = KEY_UNKNOWN; 1008 vdbg_printk(FUJLAPTOP_DBG_WARN, 1009 "Unsupported event [0x%x]\n", event); 1010 input_report_key(input, keycode, 1); 1011 input_sync(input); 1012 input_report_key(input, keycode, 0); 1013 input_sync(input); 1014 break; 1015 } 1016 } 1017 1018 /* Initialization */ 1019 1020 static const struct acpi_device_id fujitsu_device_ids[] = { 1021 {ACPI_FUJITSU_HID, 0}, 1022 {"", 0}, 1023 }; 1024 1025 static struct acpi_driver acpi_fujitsu_driver = { 1026 .name = ACPI_FUJITSU_DRIVER_NAME, 1027 .class = ACPI_FUJITSU_CLASS, 1028 .ids = fujitsu_device_ids, 1029 .ops = { 1030 .add = acpi_fujitsu_add, 1031 .remove = acpi_fujitsu_remove, 1032 .notify = acpi_fujitsu_notify, 1033 }, 1034 }; 1035 1036 static const struct acpi_device_id fujitsu_hotkey_device_ids[] = { 1037 {ACPI_FUJITSU_HOTKEY_HID, 0}, 1038 {"", 0}, 1039 }; 1040 1041 static struct acpi_driver acpi_fujitsu_hotkey_driver = { 1042 .name = ACPI_FUJITSU_HOTKEY_DRIVER_NAME, 1043 .class = ACPI_FUJITSU_CLASS, 1044 .ids = fujitsu_hotkey_device_ids, 1045 .ops = { 1046 .add = acpi_fujitsu_hotkey_add, 1047 .remove = acpi_fujitsu_hotkey_remove, 1048 .notify = acpi_fujitsu_hotkey_notify, 1049 }, 1050 }; 1051 1052 static const struct acpi_device_id fujitsu_ids[] __used = { 1053 {ACPI_FUJITSU_HID, 0}, 1054 {ACPI_FUJITSU_HOTKEY_HID, 0}, 1055 {"", 0} 1056 }; 1057 MODULE_DEVICE_TABLE(acpi, fujitsu_ids); 1058 1059 static int __init fujitsu_init(void) 1060 { 1061 int ret, result, max_brightness; 1062 1063 if (acpi_disabled) 1064 return -ENODEV; 1065 1066 fujitsu = kzalloc(sizeof(struct fujitsu_t), GFP_KERNEL); 1067 if (!fujitsu) 1068 return -ENOMEM; 1069 fujitsu->keycode1 = KEY_PROG1; 1070 fujitsu->keycode2 = KEY_PROG2; 1071 fujitsu->keycode3 = KEY_PROG3; 1072 fujitsu->keycode4 = KEY_PROG4; 1073 dmi_check_system(fujitsu_dmi_table); 1074 1075 result = acpi_bus_register_driver(&acpi_fujitsu_driver); 1076 if (result < 0) { 1077 ret = -ENODEV; 1078 goto fail_acpi; 1079 } 1080 1081 /* Register platform stuff */ 1082 1083 fujitsu->pf_device = platform_device_alloc("fujitsu-laptop", -1); 1084 if (!fujitsu->pf_device) { 1085 ret = -ENOMEM; 1086 goto fail_platform_driver; 1087 } 1088 1089 ret = platform_device_add(fujitsu->pf_device); 1090 if (ret) 1091 goto fail_platform_device1; 1092 1093 ret = 1094 sysfs_create_group(&fujitsu->pf_device->dev.kobj, 1095 &fujitsupf_attribute_group); 1096 if (ret) 1097 goto fail_platform_device2; 1098 1099 /* Register backlight stuff */ 1100 1101 if (!acpi_video_backlight_support()) { 1102 struct backlight_properties props; 1103 1104 memset(&props, 0, sizeof(struct backlight_properties)); 1105 max_brightness = fujitsu->max_brightness; 1106 props.type = BACKLIGHT_PLATFORM; 1107 props.max_brightness = max_brightness - 1; 1108 fujitsu->bl_device = backlight_device_register("fujitsu-laptop", 1109 NULL, NULL, 1110 &fujitsubl_ops, 1111 &props); 1112 if (IS_ERR(fujitsu->bl_device)) { 1113 ret = PTR_ERR(fujitsu->bl_device); 1114 fujitsu->bl_device = NULL; 1115 goto fail_sysfs_group; 1116 } 1117 fujitsu->bl_device->props.brightness = fujitsu->brightness_level; 1118 } 1119 1120 ret = platform_driver_register(&fujitsupf_driver); 1121 if (ret) 1122 goto fail_backlight; 1123 1124 /* Register hotkey driver */ 1125 1126 fujitsu_hotkey = kzalloc(sizeof(struct fujitsu_hotkey_t), GFP_KERNEL); 1127 if (!fujitsu_hotkey) { 1128 ret = -ENOMEM; 1129 goto fail_hotkey; 1130 } 1131 1132 result = acpi_bus_register_driver(&acpi_fujitsu_hotkey_driver); 1133 if (result < 0) { 1134 ret = -ENODEV; 1135 goto fail_hotkey1; 1136 } 1137 1138 /* Sync backlight power status (needs FUJ02E3 device, hence deferred) */ 1139 1140 if (!acpi_video_backlight_support()) { 1141 if (call_fext_func(FUNC_BACKLIGHT, 0x2, 0x4, 0x0) == 3) 1142 fujitsu->bl_device->props.power = 4; 1143 else 1144 fujitsu->bl_device->props.power = 0; 1145 } 1146 1147 pr_info("driver " FUJITSU_DRIVER_VERSION " successfully loaded\n"); 1148 1149 return 0; 1150 1151 fail_hotkey1: 1152 kfree(fujitsu_hotkey); 1153 fail_hotkey: 1154 platform_driver_unregister(&fujitsupf_driver); 1155 fail_backlight: 1156 backlight_device_unregister(fujitsu->bl_device); 1157 fail_sysfs_group: 1158 sysfs_remove_group(&fujitsu->pf_device->dev.kobj, 1159 &fujitsupf_attribute_group); 1160 fail_platform_device2: 1161 platform_device_del(fujitsu->pf_device); 1162 fail_platform_device1: 1163 platform_device_put(fujitsu->pf_device); 1164 fail_platform_driver: 1165 acpi_bus_unregister_driver(&acpi_fujitsu_driver); 1166 fail_acpi: 1167 kfree(fujitsu); 1168 1169 return ret; 1170 } 1171 1172 static void __exit fujitsu_cleanup(void) 1173 { 1174 acpi_bus_unregister_driver(&acpi_fujitsu_hotkey_driver); 1175 1176 kfree(fujitsu_hotkey); 1177 1178 platform_driver_unregister(&fujitsupf_driver); 1179 1180 backlight_device_unregister(fujitsu->bl_device); 1181 1182 sysfs_remove_group(&fujitsu->pf_device->dev.kobj, 1183 &fujitsupf_attribute_group); 1184 1185 platform_device_unregister(fujitsu->pf_device); 1186 1187 acpi_bus_unregister_driver(&acpi_fujitsu_driver); 1188 1189 kfree(fujitsu); 1190 1191 pr_info("driver unloaded\n"); 1192 } 1193 1194 module_init(fujitsu_init); 1195 module_exit(fujitsu_cleanup); 1196 1197 module_param(use_alt_lcd_levels, uint, 0644); 1198 MODULE_PARM_DESC(use_alt_lcd_levels, 1199 "Use alternative interface for lcd_levels (needed for Lifebook s6410)."); 1200 module_param(disable_brightness_adjust, uint, 0644); 1201 MODULE_PARM_DESC(disable_brightness_adjust, "Disable brightness adjustment ."); 1202 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG 1203 module_param_named(debug, dbg_level, uint, 0644); 1204 MODULE_PARM_DESC(debug, "Sets debug level bit-mask"); 1205 #endif 1206 1207 MODULE_AUTHOR("Jonathan Woithe, Peter Gruber, Tony Vroon"); 1208 MODULE_DESCRIPTION("Fujitsu laptop extras support"); 1209 MODULE_VERSION(FUJITSU_DRIVER_VERSION); 1210 MODULE_LICENSE("GPL"); 1211 1212 MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1D3:*:cvrS6410:*"); 1213 MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1E6:*:cvrS6420:*"); 1214 MODULE_ALIAS("dmi:*:svnFUJITSU:*:pvr:rvnFUJITSU:rnFJNB19C:*:cvrS7020:*"); 1215