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>
8 Copyright (C) 2003 Shane Spencer <shane@bogomip.com>
9 Adrian Yee <brewt-fujitsu@brewt.org>
11 Templated from msi-laptop.c and thinkpad_acpi.c which is copyright
12 by its respective authors.
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.
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.
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
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.
35 * This driver implements a vendor-specific backlight control interface for
36 * Fujitsu laptops and provides support for hotkeys present on certain Fujitsu
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
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.
50 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
59 #include <linux/input.h>
60 #include <linux/input/sparse-keymap.h>
61 #include <linux/kfifo.h>
62 #include <linux/platform_device.h>
63 #include <linux/slab.h>
64 #if IS_ENABLED(CONFIG_LEDS_CLASS)
65 #include <linux/leds.h>
67 #include <acpi/video.h>
69 #define FUJITSU_DRIVER_VERSION "0.6.0"
71 #define FUJITSU_LCD_N_LEVELS 8
73 #define ACPI_FUJITSU_CLASS "fujitsu"
74 #define ACPI_FUJITSU_BL_HID "FUJ02B1"
75 #define ACPI_FUJITSU_BL_DRIVER_NAME "Fujitsu laptop FUJ02B1 ACPI brightness driver"
76 #define ACPI_FUJITSU_BL_DEVICE_NAME "Fujitsu FUJ02B1"
77 #define ACPI_FUJITSU_LAPTOP_HID "FUJ02E3"
78 #define ACPI_FUJITSU_LAPTOP_DRIVER_NAME "Fujitsu laptop FUJ02E3 ACPI hotkeys driver"
79 #define ACPI_FUJITSU_LAPTOP_DEVICE_NAME "Fujitsu FUJ02E3"
81 #define ACPI_FUJITSU_NOTIFY_CODE1 0x80
83 /* FUNC interface - command values */
84 #define FUNC_FLAGS 0x1000
85 #define FUNC_LEDS 0x1001
86 #define FUNC_BUTTONS 0x1002
87 #define FUNC_BACKLIGHT 0x1004
89 /* FUNC interface - responses */
90 #define UNSUPPORTED_CMD 0x80000000
92 /* FUNC interface - status flags */
93 #define FLAG_RFKILL 0x020
94 #define FLAG_LID 0x100
95 #define FLAG_DOCK 0x200
97 #if IS_ENABLED(CONFIG_LEDS_CLASS)
98 /* FUNC interface - LED control */
99 #define FUNC_LED_OFF 0x1
100 #define FUNC_LED_ON 0x30001
101 #define KEYBOARD_LAMPS 0x100
102 #define LOGOLAMP_POWERON 0x2000
103 #define LOGOLAMP_ALWAYS 0x4000
104 #define RADIO_LED_ON 0x20
105 #define ECO_LED 0x10000
106 #define ECO_LED_ON 0x80000
110 #define KEY1_CODE 0x410 /* codes for the keys in the GIRB register */
111 #define KEY2_CODE 0x411
112 #define KEY3_CODE 0x412
113 #define KEY4_CODE 0x413
114 #define KEY5_CODE 0x420
116 #define MAX_HOTKEY_RINGBUFFER_SIZE 100
117 #define RINGBUFFERSIZE 40
120 #define FUJLAPTOP_DBG_ERROR 0x0001
121 #define FUJLAPTOP_DBG_WARN 0x0002
122 #define FUJLAPTOP_DBG_INFO 0x0004
123 #define FUJLAPTOP_DBG_TRACE 0x0008
125 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
126 #define vdbg_printk(a_dbg_level, format, arg...) \
127 do { if (dbg_level & a_dbg_level) \
128 printk(KERN_DEBUG pr_fmt("%s: " format), __func__, ## arg); \
131 #define vdbg_printk(a_dbg_level, format, arg...) \
135 /* Device controlling the backlight and associated keys */
137 acpi_handle acpi_handle
;
138 struct acpi_device
*dev
;
139 struct input_dev
*input
;
141 struct backlight_device
*bl_device
;
143 unsigned int max_brightness
;
144 unsigned int brightness_changed
;
145 unsigned int brightness_level
;
148 static struct fujitsu_bl
*fujitsu_bl
;
149 static int use_alt_lcd_levels
= -1;
150 static bool disable_brightness_adjust
;
152 /* Device used to access hotkeys and other features on the laptop */
153 struct fujitsu_laptop
{
154 acpi_handle acpi_handle
;
155 struct acpi_device
*dev
;
156 struct input_dev
*input
;
158 struct platform_device
*pf_device
;
160 spinlock_t fifo_lock
;
163 int logolamp_registered
;
164 int kblamps_registered
;
165 int radio_led_registered
;
166 int eco_led_registered
;
169 static struct fujitsu_laptop
*fujitsu_laptop
;
171 #if IS_ENABLED(CONFIG_LEDS_CLASS)
172 static enum led_brightness
logolamp_get(struct led_classdev
*cdev
);
173 static int logolamp_set(struct led_classdev
*cdev
,
174 enum led_brightness brightness
);
176 static struct led_classdev logolamp_led
= {
177 .name
= "fujitsu::logolamp",
178 .brightness_get
= logolamp_get
,
179 .brightness_set_blocking
= logolamp_set
182 static enum led_brightness
kblamps_get(struct led_classdev
*cdev
);
183 static int kblamps_set(struct led_classdev
*cdev
,
184 enum led_brightness brightness
);
186 static struct led_classdev kblamps_led
= {
187 .name
= "fujitsu::kblamps",
188 .brightness_get
= kblamps_get
,
189 .brightness_set_blocking
= kblamps_set
192 static enum led_brightness
radio_led_get(struct led_classdev
*cdev
);
193 static int radio_led_set(struct led_classdev
*cdev
,
194 enum led_brightness brightness
);
196 static struct led_classdev radio_led
= {
197 .name
= "fujitsu::radio_led",
198 .default_trigger
= "rfkill-any",
199 .brightness_get
= radio_led_get
,
200 .brightness_set_blocking
= radio_led_set
203 static enum led_brightness
eco_led_get(struct led_classdev
*cdev
);
204 static int eco_led_set(struct led_classdev
*cdev
,
205 enum led_brightness brightness
);
207 static struct led_classdev eco_led
= {
208 .name
= "fujitsu::eco_led",
209 .brightness_get
= eco_led_get
,
210 .brightness_set_blocking
= eco_led_set
214 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
215 static u32 dbg_level
= 0x03;
218 /* Fujitsu ACPI interface function */
220 static int call_fext_func(int func
, int op
, int feature
, int state
)
222 union acpi_object params
[4] = {
223 { .integer
.type
= ACPI_TYPE_INTEGER
, .integer
.value
= func
},
224 { .integer
.type
= ACPI_TYPE_INTEGER
, .integer
.value
= op
},
225 { .integer
.type
= ACPI_TYPE_INTEGER
, .integer
.value
= feature
},
226 { .integer
.type
= ACPI_TYPE_INTEGER
, .integer
.value
= state
}
228 struct acpi_object_list arg_list
= { 4, params
};
229 unsigned long long value
;
232 status
= acpi_evaluate_integer(fujitsu_laptop
->acpi_handle
, "FUNC",
234 if (ACPI_FAILURE(status
)) {
235 vdbg_printk(FUJLAPTOP_DBG_ERROR
, "Failed to evaluate FUNC\n");
239 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) returned 0x%x\n",
240 func
, op
, feature
, state
, (int)value
);
244 #if IS_ENABLED(CONFIG_LEDS_CLASS)
245 /* LED class callbacks */
247 static int logolamp_set(struct led_classdev
*cdev
,
248 enum led_brightness brightness
)
250 int poweron
= FUNC_LED_ON
, always
= FUNC_LED_ON
;
253 if (brightness
< LED_HALF
)
254 poweron
= FUNC_LED_OFF
;
256 if (brightness
< LED_FULL
)
257 always
= FUNC_LED_OFF
;
259 ret
= call_fext_func(FUNC_LEDS
, 0x1, LOGOLAMP_POWERON
, poweron
);
263 return call_fext_func(FUNC_LEDS
, 0x1, LOGOLAMP_ALWAYS
, always
);
266 static int kblamps_set(struct led_classdev
*cdev
,
267 enum led_brightness brightness
)
269 if (brightness
>= LED_FULL
)
270 return call_fext_func(FUNC_LEDS
, 0x1, KEYBOARD_LAMPS
, FUNC_LED_ON
);
272 return call_fext_func(FUNC_LEDS
, 0x1, KEYBOARD_LAMPS
, FUNC_LED_OFF
);
275 static int radio_led_set(struct led_classdev
*cdev
,
276 enum led_brightness brightness
)
278 if (brightness
>= LED_FULL
)
279 return call_fext_func(FUNC_FLAGS
, 0x5, RADIO_LED_ON
, RADIO_LED_ON
);
281 return call_fext_func(FUNC_FLAGS
, 0x5, RADIO_LED_ON
, 0x0);
284 static int eco_led_set(struct led_classdev
*cdev
,
285 enum led_brightness brightness
)
289 curr
= call_fext_func(FUNC_LEDS
, 0x2, ECO_LED
, 0x0);
290 if (brightness
>= LED_FULL
)
291 return call_fext_func(FUNC_LEDS
, 0x1, ECO_LED
, curr
| ECO_LED_ON
);
293 return call_fext_func(FUNC_LEDS
, 0x1, ECO_LED
, curr
& ~ECO_LED_ON
);
296 static enum led_brightness
logolamp_get(struct led_classdev
*cdev
)
300 ret
= call_fext_func(FUNC_LEDS
, 0x2, LOGOLAMP_ALWAYS
, 0x0);
301 if (ret
== FUNC_LED_ON
)
304 ret
= call_fext_func(FUNC_LEDS
, 0x2, LOGOLAMP_POWERON
, 0x0);
305 if (ret
== FUNC_LED_ON
)
311 static enum led_brightness
kblamps_get(struct led_classdev
*cdev
)
313 enum led_brightness brightness
= LED_OFF
;
315 if (call_fext_func(FUNC_LEDS
, 0x2, KEYBOARD_LAMPS
, 0x0) == FUNC_LED_ON
)
316 brightness
= LED_FULL
;
321 static enum led_brightness
radio_led_get(struct led_classdev
*cdev
)
323 enum led_brightness brightness
= LED_OFF
;
325 if (call_fext_func(FUNC_FLAGS
, 0x4, 0x0, 0x0) & RADIO_LED_ON
)
326 brightness
= LED_FULL
;
331 static enum led_brightness
eco_led_get(struct led_classdev
*cdev
)
333 enum led_brightness brightness
= LED_OFF
;
335 if (call_fext_func(FUNC_LEDS
, 0x2, ECO_LED
, 0x0) & ECO_LED_ON
)
336 brightness
= LED_FULL
;
342 /* Hardware access for LCD brightness control */
344 static int set_lcd_level(int level
)
349 switch (use_alt_lcd_levels
) {
351 if (acpi_has_method(fujitsu_bl
->acpi_handle
, "SBL2"))
364 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "set lcd level via %s [%d]\n",
367 if (level
< 0 || level
>= fujitsu_bl
->max_brightness
)
370 status
= acpi_execute_simple_method(fujitsu_bl
->acpi_handle
, method
,
372 if (ACPI_FAILURE(status
)) {
373 vdbg_printk(FUJLAPTOP_DBG_ERROR
, "Failed to evaluate %s\n",
378 fujitsu_bl
->brightness_level
= level
;
383 static int get_lcd_level(void)
385 unsigned long long state
= 0;
386 acpi_status status
= AE_OK
;
388 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "get lcd level via GBLL\n");
390 status
= acpi_evaluate_integer(fujitsu_bl
->acpi_handle
, "GBLL", NULL
,
392 if (ACPI_FAILURE(status
))
395 fujitsu_bl
->brightness_level
= state
& 0x0fffffff;
397 if (state
& 0x80000000)
398 fujitsu_bl
->brightness_changed
= 1;
400 fujitsu_bl
->brightness_changed
= 0;
402 return fujitsu_bl
->brightness_level
;
405 static int get_max_brightness(void)
407 unsigned long long state
= 0;
408 acpi_status status
= AE_OK
;
410 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "get max lcd level via RBLL\n");
412 status
= acpi_evaluate_integer(fujitsu_bl
->acpi_handle
, "RBLL", NULL
,
414 if (ACPI_FAILURE(status
))
417 fujitsu_bl
->max_brightness
= state
;
419 return fujitsu_bl
->max_brightness
;
422 /* Backlight device stuff */
424 static int bl_get_brightness(struct backlight_device
*b
)
426 return get_lcd_level();
429 static int bl_update_status(struct backlight_device
*b
)
431 if (b
->props
.power
== FB_BLANK_POWERDOWN
)
432 call_fext_func(FUNC_BACKLIGHT
, 0x1, 0x4, 0x3);
434 call_fext_func(FUNC_BACKLIGHT
, 0x1, 0x4, 0x0);
436 return set_lcd_level(b
->props
.brightness
);
439 static const struct backlight_ops fujitsu_bl_ops
= {
440 .get_brightness
= bl_get_brightness
,
441 .update_status
= bl_update_status
,
444 static ssize_t
lid_show(struct device
*dev
, struct device_attribute
*attr
,
447 if (!(fujitsu_laptop
->flags_supported
& FLAG_LID
))
448 return sprintf(buf
, "unknown\n");
449 if (fujitsu_laptop
->flags_state
& FLAG_LID
)
450 return sprintf(buf
, "open\n");
452 return sprintf(buf
, "closed\n");
455 static ssize_t
dock_show(struct device
*dev
, struct device_attribute
*attr
,
458 if (!(fujitsu_laptop
->flags_supported
& FLAG_DOCK
))
459 return sprintf(buf
, "unknown\n");
460 if (fujitsu_laptop
->flags_state
& FLAG_DOCK
)
461 return sprintf(buf
, "docked\n");
463 return sprintf(buf
, "undocked\n");
466 static ssize_t
radios_show(struct device
*dev
, struct device_attribute
*attr
,
469 if (!(fujitsu_laptop
->flags_supported
& FLAG_RFKILL
))
470 return sprintf(buf
, "unknown\n");
471 if (fujitsu_laptop
->flags_state
& FLAG_RFKILL
)
472 return sprintf(buf
, "on\n");
474 return sprintf(buf
, "killed\n");
477 static DEVICE_ATTR_RO(lid
);
478 static DEVICE_ATTR_RO(dock
);
479 static DEVICE_ATTR_RO(radios
);
481 static struct attribute
*fujitsu_pf_attributes
[] = {
484 &dev_attr_radios
.attr
,
488 static struct attribute_group fujitsu_pf_attribute_group
= {
489 .attrs
= fujitsu_pf_attributes
492 static struct platform_driver fujitsu_pf_driver
= {
494 .name
= "fujitsu-laptop",
498 /* ACPI device for LCD brightness control */
500 static const struct key_entry keymap_backlight
[] = {
501 { KE_KEY
, true, { KEY_BRIGHTNESSUP
} },
502 { KE_KEY
, false, { KEY_BRIGHTNESSDOWN
} },
506 static int acpi_fujitsu_bl_input_setup(struct acpi_device
*device
)
508 struct fujitsu_bl
*fujitsu_bl
= acpi_driver_data(device
);
511 fujitsu_bl
->input
= devm_input_allocate_device(&device
->dev
);
512 if (!fujitsu_bl
->input
)
515 snprintf(fujitsu_bl
->phys
, sizeof(fujitsu_bl
->phys
),
516 "%s/video/input0", acpi_device_hid(device
));
518 fujitsu_bl
->input
->name
= acpi_device_name(device
);
519 fujitsu_bl
->input
->phys
= fujitsu_bl
->phys
;
520 fujitsu_bl
->input
->id
.bustype
= BUS_HOST
;
521 fujitsu_bl
->input
->id
.product
= 0x06;
523 ret
= sparse_keymap_setup(fujitsu_bl
->input
, keymap_backlight
, NULL
);
527 return input_register_device(fujitsu_bl
->input
);
530 static int fujitsu_backlight_register(struct acpi_device
*device
)
532 const struct backlight_properties props
= {
533 .brightness
= fujitsu_bl
->brightness_level
,
534 .max_brightness
= fujitsu_bl
->max_brightness
- 1,
535 .type
= BACKLIGHT_PLATFORM
537 struct backlight_device
*bd
;
539 bd
= devm_backlight_device_register(&device
->dev
, "fujitsu-laptop",
541 &fujitsu_bl_ops
, &props
);
545 fujitsu_bl
->bl_device
= bd
;
550 static int acpi_fujitsu_bl_add(struct acpi_device
*device
)
555 if (acpi_video_get_backlight_type() != acpi_backlight_vendor
)
561 fujitsu_bl
->acpi_handle
= device
->handle
;
562 sprintf(acpi_device_name(device
), "%s", ACPI_FUJITSU_BL_DEVICE_NAME
);
563 sprintf(acpi_device_class(device
), "%s", ACPI_FUJITSU_CLASS
);
564 device
->driver_data
= fujitsu_bl
;
566 error
= acpi_fujitsu_bl_input_setup(device
);
570 error
= acpi_bus_update_power(fujitsu_bl
->acpi_handle
, &state
);
572 pr_err("Error reading power state\n");
576 pr_info("ACPI: %s [%s] (%s)\n",
577 acpi_device_name(device
), acpi_device_bid(device
),
578 !device
->power
.state
? "on" : "off");
580 fujitsu_bl
->dev
= device
;
582 if (acpi_has_method(device
->handle
, METHOD_NAME__INI
)) {
583 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Invoking _INI\n");
585 (acpi_evaluate_object
586 (device
->handle
, METHOD_NAME__INI
, NULL
, NULL
)))
587 pr_err("_INI Method failed\n");
590 if (get_max_brightness() <= 0)
591 fujitsu_bl
->max_brightness
= FUJITSU_LCD_N_LEVELS
;
594 error
= fujitsu_backlight_register(device
);
601 /* Brightness notify */
603 static void acpi_fujitsu_bl_notify(struct acpi_device
*device
, u32 event
)
605 struct input_dev
*input
;
608 input
= fujitsu_bl
->input
;
610 if (event
!= ACPI_FUJITSU_NOTIFY_CODE1
) {
611 vdbg_printk(FUJLAPTOP_DBG_WARN
,
612 "unsupported event [0x%x]\n", event
);
613 sparse_keymap_report_event(input
, -1, 1, true);
617 oldb
= fujitsu_bl
->brightness_level
;
619 newb
= fujitsu_bl
->brightness_level
;
621 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
622 "brightness button event [%i -> %i (%i)]\n",
623 oldb
, newb
, fujitsu_bl
->brightness_changed
);
628 if (!disable_brightness_adjust
)
631 sparse_keymap_report_event(input
, oldb
< newb
, 1, true);
634 /* ACPI device for hotkey handling */
636 static const struct key_entry keymap_default
[] = {
637 { KE_KEY
, KEY1_CODE
, { KEY_PROG1
} },
638 { KE_KEY
, KEY2_CODE
, { KEY_PROG2
} },
639 { KE_KEY
, KEY3_CODE
, { KEY_PROG3
} },
640 { KE_KEY
, KEY4_CODE
, { KEY_PROG4
} },
641 { KE_KEY
, KEY5_CODE
, { KEY_RFKILL
} },
642 { KE_KEY
, BIT(26), { KEY_TOUCHPAD_TOGGLE
} },
646 static const struct key_entry keymap_s64x0
[] = {
647 { KE_KEY
, KEY1_CODE
, { KEY_SCREENLOCK
} }, /* "Lock" */
648 { KE_KEY
, KEY2_CODE
, { KEY_HELP
} }, /* "Mobility Center */
649 { KE_KEY
, KEY3_CODE
, { KEY_PROG3
} },
650 { KE_KEY
, KEY4_CODE
, { KEY_PROG4
} },
654 static const struct key_entry keymap_p8010
[] = {
655 { KE_KEY
, KEY1_CODE
, { KEY_HELP
} }, /* "Support" */
656 { KE_KEY
, KEY2_CODE
, { KEY_PROG2
} },
657 { KE_KEY
, KEY3_CODE
, { KEY_SWITCHVIDEOMODE
} }, /* "Presentation" */
658 { KE_KEY
, KEY4_CODE
, { KEY_WWW
} }, /* "WWW" */
662 static const struct key_entry
*keymap
= keymap_default
;
664 static int fujitsu_laptop_dmi_keymap_override(const struct dmi_system_id
*id
)
666 pr_info("Identified laptop model '%s'\n", id
->ident
);
667 keymap
= id
->driver_data
;
671 static const struct dmi_system_id fujitsu_laptop_dmi_table
[] = {
673 .callback
= fujitsu_laptop_dmi_keymap_override
,
674 .ident
= "Fujitsu Siemens S6410",
676 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU SIEMENS"),
677 DMI_MATCH(DMI_PRODUCT_NAME
, "LIFEBOOK S6410"),
679 .driver_data
= (void *)keymap_s64x0
682 .callback
= fujitsu_laptop_dmi_keymap_override
,
683 .ident
= "Fujitsu Siemens S6420",
685 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU SIEMENS"),
686 DMI_MATCH(DMI_PRODUCT_NAME
, "LIFEBOOK S6420"),
688 .driver_data
= (void *)keymap_s64x0
691 .callback
= fujitsu_laptop_dmi_keymap_override
,
692 .ident
= "Fujitsu LifeBook P8010",
694 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU"),
695 DMI_MATCH(DMI_PRODUCT_NAME
, "LifeBook P8010"),
697 .driver_data
= (void *)keymap_p8010
702 static int acpi_fujitsu_laptop_input_setup(struct acpi_device
*device
)
704 struct fujitsu_laptop
*fujitsu_laptop
= acpi_driver_data(device
);
707 fujitsu_laptop
->input
= devm_input_allocate_device(&device
->dev
);
708 if (!fujitsu_laptop
->input
)
711 snprintf(fujitsu_laptop
->phys
, sizeof(fujitsu_laptop
->phys
),
712 "%s/video/input0", acpi_device_hid(device
));
714 fujitsu_laptop
->input
->name
= acpi_device_name(device
);
715 fujitsu_laptop
->input
->phys
= fujitsu_laptop
->phys
;
716 fujitsu_laptop
->input
->id
.bustype
= BUS_HOST
;
717 fujitsu_laptop
->input
->id
.product
= 0x06;
719 dmi_check_system(fujitsu_laptop_dmi_table
);
720 ret
= sparse_keymap_setup(fujitsu_laptop
->input
, keymap
, NULL
);
724 return input_register_device(fujitsu_laptop
->input
);
727 static int fujitsu_laptop_platform_add(void)
731 fujitsu_laptop
->pf_device
= platform_device_alloc("fujitsu-laptop", -1);
732 if (!fujitsu_laptop
->pf_device
)
735 ret
= platform_device_add(fujitsu_laptop
->pf_device
);
737 goto err_put_platform_device
;
739 ret
= sysfs_create_group(&fujitsu_laptop
->pf_device
->dev
.kobj
,
740 &fujitsu_pf_attribute_group
);
742 goto err_del_platform_device
;
746 err_del_platform_device
:
747 platform_device_del(fujitsu_laptop
->pf_device
);
748 err_put_platform_device
:
749 platform_device_put(fujitsu_laptop
->pf_device
);
754 static void fujitsu_laptop_platform_remove(void)
756 sysfs_remove_group(&fujitsu_laptop
->pf_device
->dev
.kobj
,
757 &fujitsu_pf_attribute_group
);
758 platform_device_unregister(fujitsu_laptop
->pf_device
);
761 static int acpi_fujitsu_laptop_add(struct acpi_device
*device
)
771 fujitsu_laptop
->acpi_handle
= device
->handle
;
772 sprintf(acpi_device_name(device
), "%s",
773 ACPI_FUJITSU_LAPTOP_DEVICE_NAME
);
774 sprintf(acpi_device_class(device
), "%s", ACPI_FUJITSU_CLASS
);
775 device
->driver_data
= fujitsu_laptop
;
778 spin_lock_init(&fujitsu_laptop
->fifo_lock
);
779 error
= kfifo_alloc(&fujitsu_laptop
->fifo
, RINGBUFFERSIZE
* sizeof(int),
782 pr_err("kfifo_alloc failed\n");
786 error
= acpi_fujitsu_laptop_input_setup(device
);
790 error
= acpi_bus_update_power(fujitsu_laptop
->acpi_handle
, &state
);
792 pr_err("Error reading power state\n");
796 pr_info("ACPI: %s [%s] (%s)\n",
797 acpi_device_name(device
), acpi_device_bid(device
),
798 !device
->power
.state
? "on" : "off");
800 fujitsu_laptop
->dev
= device
;
802 if (acpi_has_method(device
->handle
, METHOD_NAME__INI
)) {
803 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Invoking _INI\n");
805 (acpi_evaluate_object
806 (device
->handle
, METHOD_NAME__INI
, NULL
, NULL
)))
807 pr_err("_INI Method failed\n");
811 while (call_fext_func(FUNC_BUTTONS
, 0x1, 0x0, 0x0) != 0
812 && (i
++) < MAX_HOTKEY_RINGBUFFER_SIZE
)
813 ; /* No action, result is discarded */
814 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Discarded %i ringbuffer entries\n", i
);
816 fujitsu_laptop
->flags_supported
=
817 call_fext_func(FUNC_FLAGS
, 0x0, 0x0, 0x0);
819 /* Make sure our bitmask of supported functions is cleared if the
820 RFKILL function block is not implemented, like on the S7020. */
821 if (fujitsu_laptop
->flags_supported
== UNSUPPORTED_CMD
)
822 fujitsu_laptop
->flags_supported
= 0;
824 if (fujitsu_laptop
->flags_supported
)
825 fujitsu_laptop
->flags_state
=
826 call_fext_func(FUNC_FLAGS
, 0x4, 0x0, 0x0);
828 /* Suspect this is a keymap of the application panel, print it */
829 pr_info("BTNI: [0x%x]\n", call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0));
831 /* Sync backlight power status */
832 if (fujitsu_bl
->bl_device
&&
833 acpi_video_get_backlight_type() == acpi_backlight_vendor
) {
834 if (call_fext_func(FUNC_BACKLIGHT
, 0x2, 0x4, 0x0) == 3)
835 fujitsu_bl
->bl_device
->props
.power
= FB_BLANK_POWERDOWN
;
837 fujitsu_bl
->bl_device
->props
.power
= FB_BLANK_UNBLANK
;
840 error
= fujitsu_laptop_platform_add();
844 #if IS_ENABLED(CONFIG_LEDS_CLASS)
845 if (call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON
) {
846 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
849 fujitsu_laptop
->logolamp_registered
= 1;
851 pr_err("Could not register LED handler for logo lamp, error %i\n",
856 if ((call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & KEYBOARD_LAMPS
) &&
857 (call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0) == 0x0)) {
858 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
861 fujitsu_laptop
->kblamps_registered
= 1;
863 pr_err("Could not register LED handler for keyboard lamps, error %i\n",
869 * BTNI bit 24 seems to indicate the presence of a radio toggle
870 * button in place of a slide switch, and all such machines appear
871 * to also have an RF LED. Therefore use bit 24 as an indicator
872 * that an RF LED is present.
874 if (call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0) & BIT(24)) {
875 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
878 fujitsu_laptop
->radio_led_registered
= 1;
880 pr_err("Could not register LED handler for radio LED, error %i\n",
885 /* Support for eco led is not always signaled in bit corresponding
886 * to the bit used to control the led. According to the DSDT table,
887 * bit 14 seems to indicate presence of said led as well.
888 * Confirm by testing the status.
890 if ((call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & BIT(14)) &&
891 (call_fext_func(FUNC_LEDS
, 0x2, ECO_LED
, 0x0) != UNSUPPORTED_CMD
)) {
892 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
895 fujitsu_laptop
->eco_led_registered
= 1;
897 pr_err("Could not register LED handler for eco LED, error %i\n",
906 kfifo_free(&fujitsu_laptop
->fifo
);
911 static int acpi_fujitsu_laptop_remove(struct acpi_device
*device
)
913 struct fujitsu_laptop
*fujitsu_laptop
= acpi_driver_data(device
);
915 #if IS_ENABLED(CONFIG_LEDS_CLASS)
916 if (fujitsu_laptop
->logolamp_registered
)
917 led_classdev_unregister(&logolamp_led
);
919 if (fujitsu_laptop
->kblamps_registered
)
920 led_classdev_unregister(&kblamps_led
);
922 if (fujitsu_laptop
->radio_led_registered
)
923 led_classdev_unregister(&radio_led
);
925 if (fujitsu_laptop
->eco_led_registered
)
926 led_classdev_unregister(&eco_led
);
929 fujitsu_laptop_platform_remove();
931 kfifo_free(&fujitsu_laptop
->fifo
);
933 fujitsu_laptop
->acpi_handle
= NULL
;
938 static void acpi_fujitsu_laptop_press(int scancode
)
940 struct input_dev
*input
= fujitsu_laptop
->input
;
943 status
= kfifo_in_locked(&fujitsu_laptop
->fifo
,
944 (unsigned char *)&scancode
, sizeof(scancode
),
945 &fujitsu_laptop
->fifo_lock
);
946 if (status
!= sizeof(scancode
)) {
947 vdbg_printk(FUJLAPTOP_DBG_WARN
,
948 "Could not push scancode [0x%x]\n", scancode
);
951 sparse_keymap_report_event(input
, scancode
, 1, false);
952 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
953 "Push scancode into ringbuffer [0x%x]\n", scancode
);
956 static void acpi_fujitsu_laptop_release(void)
958 struct input_dev
*input
= fujitsu_laptop
->input
;
959 int scancode
, status
;
962 status
= kfifo_out_locked(&fujitsu_laptop
->fifo
,
963 (unsigned char *)&scancode
,
965 &fujitsu_laptop
->fifo_lock
);
966 if (status
!= sizeof(scancode
))
968 sparse_keymap_report_event(input
, scancode
, 0, false);
969 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
970 "Pop scancode from ringbuffer [0x%x]\n", scancode
);
974 static void acpi_fujitsu_laptop_notify(struct acpi_device
*device
, u32 event
)
976 struct input_dev
*input
;
980 input
= fujitsu_laptop
->input
;
982 if (event
!= ACPI_FUJITSU_NOTIFY_CODE1
) {
983 vdbg_printk(FUJLAPTOP_DBG_WARN
,
984 "Unsupported event [0x%x]\n", event
);
985 sparse_keymap_report_event(input
, -1, 1, true);
989 if (fujitsu_laptop
->flags_supported
)
990 fujitsu_laptop
->flags_state
=
991 call_fext_func(FUNC_FLAGS
, 0x4, 0x0, 0x0);
993 while ((irb
= call_fext_func(FUNC_BUTTONS
, 0x1, 0x0, 0x0)) != 0 &&
994 i
++ < MAX_HOTKEY_RINGBUFFER_SIZE
) {
995 scancode
= irb
& 0x4ff;
996 if (sparse_keymap_entry_from_scancode(input
, scancode
))
997 acpi_fujitsu_laptop_press(scancode
);
998 else if (scancode
== 0)
999 acpi_fujitsu_laptop_release();
1001 vdbg_printk(FUJLAPTOP_DBG_WARN
,
1002 "Unknown GIRB result [%x]\n", irb
);
1005 /* On some models (first seen on the Skylake-based Lifebook
1006 * E736/E746/E756), the touchpad toggle hotkey (Fn+F4) is
1007 * handled in software; its state is queried using FUNC_FLAGS
1009 if ((fujitsu_laptop
->flags_supported
& BIT(26)) &&
1010 (call_fext_func(FUNC_FLAGS
, 0x1, 0x0, 0x0) & BIT(26)))
1011 sparse_keymap_report_event(input
, BIT(26), 1, true);
1014 /* Initialization */
1016 static const struct acpi_device_id fujitsu_bl_device_ids
[] = {
1017 {ACPI_FUJITSU_BL_HID
, 0},
1021 static struct acpi_driver acpi_fujitsu_bl_driver
= {
1022 .name
= ACPI_FUJITSU_BL_DRIVER_NAME
,
1023 .class = ACPI_FUJITSU_CLASS
,
1024 .ids
= fujitsu_bl_device_ids
,
1026 .add
= acpi_fujitsu_bl_add
,
1027 .notify
= acpi_fujitsu_bl_notify
,
1031 static const struct acpi_device_id fujitsu_laptop_device_ids
[] = {
1032 {ACPI_FUJITSU_LAPTOP_HID
, 0},
1036 static struct acpi_driver acpi_fujitsu_laptop_driver
= {
1037 .name
= ACPI_FUJITSU_LAPTOP_DRIVER_NAME
,
1038 .class = ACPI_FUJITSU_CLASS
,
1039 .ids
= fujitsu_laptop_device_ids
,
1041 .add
= acpi_fujitsu_laptop_add
,
1042 .remove
= acpi_fujitsu_laptop_remove
,
1043 .notify
= acpi_fujitsu_laptop_notify
,
1047 static const struct acpi_device_id fujitsu_ids
[] __used
= {
1048 {ACPI_FUJITSU_BL_HID
, 0},
1049 {ACPI_FUJITSU_LAPTOP_HID
, 0},
1052 MODULE_DEVICE_TABLE(acpi
, fujitsu_ids
);
1054 static int __init
fujitsu_init(void)
1061 fujitsu_bl
= kzalloc(sizeof(struct fujitsu_bl
), GFP_KERNEL
);
1065 ret
= acpi_bus_register_driver(&acpi_fujitsu_bl_driver
);
1067 goto err_free_fujitsu_bl
;
1069 /* Register platform stuff */
1071 ret
= platform_driver_register(&fujitsu_pf_driver
);
1073 goto err_unregister_acpi
;
1075 /* Register laptop driver */
1077 fujitsu_laptop
= kzalloc(sizeof(struct fujitsu_laptop
), GFP_KERNEL
);
1078 if (!fujitsu_laptop
) {
1080 goto err_unregister_platform_driver
;
1083 ret
= acpi_bus_register_driver(&acpi_fujitsu_laptop_driver
);
1085 goto err_free_fujitsu_laptop
;
1087 pr_info("driver " FUJITSU_DRIVER_VERSION
" successfully loaded\n");
1091 err_free_fujitsu_laptop
:
1092 kfree(fujitsu_laptop
);
1093 err_unregister_platform_driver
:
1094 platform_driver_unregister(&fujitsu_pf_driver
);
1095 err_unregister_acpi
:
1096 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver
);
1097 err_free_fujitsu_bl
:
1103 static void __exit
fujitsu_cleanup(void)
1105 acpi_bus_unregister_driver(&acpi_fujitsu_laptop_driver
);
1107 kfree(fujitsu_laptop
);
1109 platform_driver_unregister(&fujitsu_pf_driver
);
1111 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver
);
1115 pr_info("driver unloaded\n");
1118 module_init(fujitsu_init
);
1119 module_exit(fujitsu_cleanup
);
1121 module_param(use_alt_lcd_levels
, int, 0644);
1122 MODULE_PARM_DESC(use_alt_lcd_levels
, "Interface used for setting LCD brightness level (-1 = auto, 0 = force SBLL, 1 = force SBL2)");
1123 module_param(disable_brightness_adjust
, bool, 0644);
1124 MODULE_PARM_DESC(disable_brightness_adjust
, "Disable LCD brightness adjustment");
1125 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
1126 module_param_named(debug
, dbg_level
, uint
, 0644);
1127 MODULE_PARM_DESC(debug
, "Sets debug level bit-mask");
1130 MODULE_AUTHOR("Jonathan Woithe, Peter Gruber, Tony Vroon");
1131 MODULE_DESCRIPTION("Fujitsu laptop extras support");
1132 MODULE_VERSION(FUJITSU_DRIVER_VERSION
);
1133 MODULE_LICENSE("GPL");