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 int disable_brightness_adjust
= -1;
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
) {
358 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "set lcd level via %s [%d]\n",
361 if (level
< 0 || level
>= fujitsu_bl
->max_brightness
)
364 status
= acpi_execute_simple_method(fujitsu_bl
->acpi_handle
, method
,
366 if (ACPI_FAILURE(status
)) {
367 vdbg_printk(FUJLAPTOP_DBG_ERROR
, "Failed to evaluate %s\n",
372 fujitsu_bl
->brightness_level
= level
;
377 static int get_lcd_level(void)
379 unsigned long long state
= 0;
380 acpi_status status
= AE_OK
;
382 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "get lcd level via GBLL\n");
384 status
= acpi_evaluate_integer(fujitsu_bl
->acpi_handle
, "GBLL", NULL
,
386 if (ACPI_FAILURE(status
))
389 fujitsu_bl
->brightness_level
= state
& 0x0fffffff;
391 if (state
& 0x80000000)
392 fujitsu_bl
->brightness_changed
= 1;
394 fujitsu_bl
->brightness_changed
= 0;
396 return fujitsu_bl
->brightness_level
;
399 static int get_max_brightness(void)
401 unsigned long long state
= 0;
402 acpi_status status
= AE_OK
;
404 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "get max lcd level via RBLL\n");
406 status
= acpi_evaluate_integer(fujitsu_bl
->acpi_handle
, "RBLL", NULL
,
408 if (ACPI_FAILURE(status
))
411 fujitsu_bl
->max_brightness
= state
;
413 return fujitsu_bl
->max_brightness
;
416 /* Backlight device stuff */
418 static int bl_get_brightness(struct backlight_device
*b
)
420 return get_lcd_level();
423 static int bl_update_status(struct backlight_device
*b
)
426 if (b
->props
.power
== FB_BLANK_POWERDOWN
)
427 ret
= call_fext_func(FUNC_BACKLIGHT
, 0x1, 0x4, 0x3);
429 ret
= call_fext_func(FUNC_BACKLIGHT
, 0x1, 0x4, 0x0);
431 vdbg_printk(FUJLAPTOP_DBG_ERROR
,
432 "Unable to adjust backlight power, error code %i\n",
435 ret
= set_lcd_level(b
->props
.brightness
);
437 vdbg_printk(FUJLAPTOP_DBG_ERROR
,
438 "Unable to adjust LCD brightness, error code %i\n",
443 static const struct backlight_ops fujitsu_bl_ops
= {
444 .get_brightness
= bl_get_brightness
,
445 .update_status
= bl_update_status
,
448 static ssize_t
lid_show(struct device
*dev
, struct device_attribute
*attr
,
451 if (!(fujitsu_laptop
->flags_supported
& FLAG_LID
))
452 return sprintf(buf
, "unknown\n");
453 if (fujitsu_laptop
->flags_state
& FLAG_LID
)
454 return sprintf(buf
, "open\n");
456 return sprintf(buf
, "closed\n");
459 static ssize_t
dock_show(struct device
*dev
, struct device_attribute
*attr
,
462 if (!(fujitsu_laptop
->flags_supported
& FLAG_DOCK
))
463 return sprintf(buf
, "unknown\n");
464 if (fujitsu_laptop
->flags_state
& FLAG_DOCK
)
465 return sprintf(buf
, "docked\n");
467 return sprintf(buf
, "undocked\n");
470 static ssize_t
radios_show(struct device
*dev
, struct device_attribute
*attr
,
473 if (!(fujitsu_laptop
->flags_supported
& FLAG_RFKILL
))
474 return sprintf(buf
, "unknown\n");
475 if (fujitsu_laptop
->flags_state
& FLAG_RFKILL
)
476 return sprintf(buf
, "on\n");
478 return sprintf(buf
, "killed\n");
481 static DEVICE_ATTR_RO(lid
);
482 static DEVICE_ATTR_RO(dock
);
483 static DEVICE_ATTR_RO(radios
);
485 static struct attribute
*fujitsu_pf_attributes
[] = {
488 &dev_attr_radios
.attr
,
492 static struct attribute_group fujitsu_pf_attribute_group
= {
493 .attrs
= fujitsu_pf_attributes
496 static struct platform_driver fujitsu_pf_driver
= {
498 .name
= "fujitsu-laptop",
502 /* ACPI device for LCD brightness control */
504 static const struct key_entry keymap_backlight
[] = {
505 { KE_KEY
, true, { KEY_BRIGHTNESSUP
} },
506 { KE_KEY
, false, { KEY_BRIGHTNESSDOWN
} },
510 static int acpi_fujitsu_bl_input_setup(struct acpi_device
*device
)
512 struct fujitsu_bl
*fujitsu_bl
= acpi_driver_data(device
);
515 fujitsu_bl
->input
= devm_input_allocate_device(&device
->dev
);
516 if (!fujitsu_bl
->input
)
519 snprintf(fujitsu_bl
->phys
, sizeof(fujitsu_bl
->phys
),
520 "%s/video/input0", acpi_device_hid(device
));
522 fujitsu_bl
->input
->name
= acpi_device_name(device
);
523 fujitsu_bl
->input
->phys
= fujitsu_bl
->phys
;
524 fujitsu_bl
->input
->id
.bustype
= BUS_HOST
;
525 fujitsu_bl
->input
->id
.product
= 0x06;
527 ret
= sparse_keymap_setup(fujitsu_bl
->input
, keymap_backlight
, NULL
);
531 return input_register_device(fujitsu_bl
->input
);
534 static int fujitsu_backlight_register(struct acpi_device
*device
)
536 const struct backlight_properties props
= {
537 .brightness
= fujitsu_bl
->brightness_level
,
538 .max_brightness
= fujitsu_bl
->max_brightness
- 1,
539 .type
= BACKLIGHT_PLATFORM
541 struct backlight_device
*bd
;
543 bd
= devm_backlight_device_register(&device
->dev
, "fujitsu-laptop",
545 &fujitsu_bl_ops
, &props
);
549 fujitsu_bl
->bl_device
= bd
;
554 static int acpi_fujitsu_bl_add(struct acpi_device
*device
)
559 if (acpi_video_get_backlight_type() != acpi_backlight_vendor
)
565 fujitsu_bl
->acpi_handle
= device
->handle
;
566 sprintf(acpi_device_name(device
), "%s", ACPI_FUJITSU_BL_DEVICE_NAME
);
567 sprintf(acpi_device_class(device
), "%s", ACPI_FUJITSU_CLASS
);
568 device
->driver_data
= fujitsu_bl
;
570 error
= acpi_fujitsu_bl_input_setup(device
);
574 error
= acpi_bus_update_power(fujitsu_bl
->acpi_handle
, &state
);
576 pr_err("Error reading power state\n");
580 pr_info("ACPI: %s [%s] (%s)\n",
581 acpi_device_name(device
), acpi_device_bid(device
),
582 !device
->power
.state
? "on" : "off");
584 fujitsu_bl
->dev
= device
;
586 if (acpi_has_method(device
->handle
, METHOD_NAME__INI
)) {
587 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Invoking _INI\n");
589 (acpi_evaluate_object
590 (device
->handle
, METHOD_NAME__INI
, NULL
, NULL
)))
591 pr_err("_INI Method failed\n");
594 if (use_alt_lcd_levels
== -1) {
595 if (acpi_has_method(NULL
, "\\_SB.PCI0.LPCB.FJEX.SBL2"))
596 use_alt_lcd_levels
= 1;
598 use_alt_lcd_levels
= 0;
599 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "auto-detected usealt as %i\n",
603 /* do config (detect defaults) */
604 use_alt_lcd_levels
= use_alt_lcd_levels
== 1 ? 1 : 0;
605 disable_brightness_adjust
= disable_brightness_adjust
== 1 ? 1 : 0;
606 vdbg_printk(FUJLAPTOP_DBG_INFO
,
607 "config: [alt interface: %d], [adjust disable: %d]\n",
608 use_alt_lcd_levels
, disable_brightness_adjust
);
610 if (get_max_brightness() <= 0)
611 fujitsu_bl
->max_brightness
= FUJITSU_LCD_N_LEVELS
;
614 error
= fujitsu_backlight_register(device
);
621 /* Brightness notify */
623 static void acpi_fujitsu_bl_notify(struct acpi_device
*device
, u32 event
)
625 struct input_dev
*input
;
628 input
= fujitsu_bl
->input
;
630 if (event
!= ACPI_FUJITSU_NOTIFY_CODE1
) {
631 vdbg_printk(FUJLAPTOP_DBG_WARN
,
632 "unsupported event [0x%x]\n", event
);
633 sparse_keymap_report_event(input
, -1, 1, true);
637 oldb
= fujitsu_bl
->brightness_level
;
639 newb
= fujitsu_bl
->brightness_level
;
641 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
642 "brightness button event [%i -> %i (%i)]\n",
643 oldb
, newb
, fujitsu_bl
->brightness_changed
);
648 if (disable_brightness_adjust
!= 1)
651 sparse_keymap_report_event(input
, oldb
< newb
, 1, true);
654 /* ACPI device for hotkey handling */
656 static const struct key_entry keymap_default
[] = {
657 { KE_KEY
, KEY1_CODE
, { KEY_PROG1
} },
658 { KE_KEY
, KEY2_CODE
, { KEY_PROG2
} },
659 { KE_KEY
, KEY3_CODE
, { KEY_PROG3
} },
660 { KE_KEY
, KEY4_CODE
, { KEY_PROG4
} },
661 { KE_KEY
, KEY5_CODE
, { KEY_RFKILL
} },
662 { KE_KEY
, BIT(26), { KEY_TOUCHPAD_TOGGLE
} },
666 static const struct key_entry keymap_s64x0
[] = {
667 { KE_KEY
, KEY1_CODE
, { KEY_SCREENLOCK
} }, /* "Lock" */
668 { KE_KEY
, KEY2_CODE
, { KEY_HELP
} }, /* "Mobility Center */
669 { KE_KEY
, KEY3_CODE
, { KEY_PROG3
} },
670 { KE_KEY
, KEY4_CODE
, { KEY_PROG4
} },
674 static const struct key_entry keymap_p8010
[] = {
675 { KE_KEY
, KEY1_CODE
, { KEY_HELP
} }, /* "Support" */
676 { KE_KEY
, KEY2_CODE
, { KEY_PROG2
} },
677 { KE_KEY
, KEY3_CODE
, { KEY_SWITCHVIDEOMODE
} }, /* "Presentation" */
678 { KE_KEY
, KEY4_CODE
, { KEY_WWW
} }, /* "WWW" */
682 static const struct key_entry
*keymap
= keymap_default
;
684 static int fujitsu_laptop_dmi_keymap_override(const struct dmi_system_id
*id
)
686 pr_info("Identified laptop model '%s'\n", id
->ident
);
687 keymap
= id
->driver_data
;
691 static const struct dmi_system_id fujitsu_laptop_dmi_table
[] = {
693 .callback
= fujitsu_laptop_dmi_keymap_override
,
694 .ident
= "Fujitsu Siemens S6410",
696 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU SIEMENS"),
697 DMI_MATCH(DMI_PRODUCT_NAME
, "LIFEBOOK S6410"),
699 .driver_data
= (void *)keymap_s64x0
702 .callback
= fujitsu_laptop_dmi_keymap_override
,
703 .ident
= "Fujitsu Siemens S6420",
705 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU SIEMENS"),
706 DMI_MATCH(DMI_PRODUCT_NAME
, "LIFEBOOK S6420"),
708 .driver_data
= (void *)keymap_s64x0
711 .callback
= fujitsu_laptop_dmi_keymap_override
,
712 .ident
= "Fujitsu LifeBook P8010",
714 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU"),
715 DMI_MATCH(DMI_PRODUCT_NAME
, "LifeBook P8010"),
717 .driver_data
= (void *)keymap_p8010
722 static int acpi_fujitsu_laptop_input_setup(struct acpi_device
*device
)
724 struct fujitsu_laptop
*fujitsu_laptop
= acpi_driver_data(device
);
727 fujitsu_laptop
->input
= devm_input_allocate_device(&device
->dev
);
728 if (!fujitsu_laptop
->input
)
731 snprintf(fujitsu_laptop
->phys
, sizeof(fujitsu_laptop
->phys
),
732 "%s/video/input0", acpi_device_hid(device
));
734 fujitsu_laptop
->input
->name
= acpi_device_name(device
);
735 fujitsu_laptop
->input
->phys
= fujitsu_laptop
->phys
;
736 fujitsu_laptop
->input
->id
.bustype
= BUS_HOST
;
737 fujitsu_laptop
->input
->id
.product
= 0x06;
739 dmi_check_system(fujitsu_laptop_dmi_table
);
740 ret
= sparse_keymap_setup(fujitsu_laptop
->input
, keymap
, NULL
);
744 return input_register_device(fujitsu_laptop
->input
);
747 static int fujitsu_laptop_platform_add(void)
751 fujitsu_laptop
->pf_device
= platform_device_alloc("fujitsu-laptop", -1);
752 if (!fujitsu_laptop
->pf_device
)
755 ret
= platform_device_add(fujitsu_laptop
->pf_device
);
757 goto err_put_platform_device
;
759 ret
= sysfs_create_group(&fujitsu_laptop
->pf_device
->dev
.kobj
,
760 &fujitsu_pf_attribute_group
);
762 goto err_del_platform_device
;
766 err_del_platform_device
:
767 platform_device_del(fujitsu_laptop
->pf_device
);
768 err_put_platform_device
:
769 platform_device_put(fujitsu_laptop
->pf_device
);
774 static void fujitsu_laptop_platform_remove(void)
776 sysfs_remove_group(&fujitsu_laptop
->pf_device
->dev
.kobj
,
777 &fujitsu_pf_attribute_group
);
778 platform_device_unregister(fujitsu_laptop
->pf_device
);
781 static int acpi_fujitsu_laptop_add(struct acpi_device
*device
)
791 fujitsu_laptop
->acpi_handle
= device
->handle
;
792 sprintf(acpi_device_name(device
), "%s",
793 ACPI_FUJITSU_LAPTOP_DEVICE_NAME
);
794 sprintf(acpi_device_class(device
), "%s", ACPI_FUJITSU_CLASS
);
795 device
->driver_data
= fujitsu_laptop
;
798 spin_lock_init(&fujitsu_laptop
->fifo_lock
);
799 error
= kfifo_alloc(&fujitsu_laptop
->fifo
, RINGBUFFERSIZE
* sizeof(int),
802 pr_err("kfifo_alloc failed\n");
806 error
= acpi_fujitsu_laptop_input_setup(device
);
810 error
= acpi_bus_update_power(fujitsu_laptop
->acpi_handle
, &state
);
812 pr_err("Error reading power state\n");
816 pr_info("ACPI: %s [%s] (%s)\n",
817 acpi_device_name(device
), acpi_device_bid(device
),
818 !device
->power
.state
? "on" : "off");
820 fujitsu_laptop
->dev
= device
;
822 if (acpi_has_method(device
->handle
, METHOD_NAME__INI
)) {
823 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Invoking _INI\n");
825 (acpi_evaluate_object
826 (device
->handle
, METHOD_NAME__INI
, NULL
, NULL
)))
827 pr_err("_INI Method failed\n");
831 while (call_fext_func(FUNC_BUTTONS
, 0x1, 0x0, 0x0) != 0
832 && (i
++) < MAX_HOTKEY_RINGBUFFER_SIZE
)
833 ; /* No action, result is discarded */
834 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Discarded %i ringbuffer entries\n", i
);
836 fujitsu_laptop
->flags_supported
=
837 call_fext_func(FUNC_FLAGS
, 0x0, 0x0, 0x0);
839 /* Make sure our bitmask of supported functions is cleared if the
840 RFKILL function block is not implemented, like on the S7020. */
841 if (fujitsu_laptop
->flags_supported
== UNSUPPORTED_CMD
)
842 fujitsu_laptop
->flags_supported
= 0;
844 if (fujitsu_laptop
->flags_supported
)
845 fujitsu_laptop
->flags_state
=
846 call_fext_func(FUNC_FLAGS
, 0x4, 0x0, 0x0);
848 /* Suspect this is a keymap of the application panel, print it */
849 pr_info("BTNI: [0x%x]\n", call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0));
851 /* Sync backlight power status */
852 if (fujitsu_bl
->bl_device
&&
853 acpi_video_get_backlight_type() == acpi_backlight_vendor
) {
854 if (call_fext_func(FUNC_BACKLIGHT
, 0x2, 0x4, 0x0) == 3)
855 fujitsu_bl
->bl_device
->props
.power
= FB_BLANK_POWERDOWN
;
857 fujitsu_bl
->bl_device
->props
.power
= FB_BLANK_UNBLANK
;
860 error
= fujitsu_laptop_platform_add();
864 #if IS_ENABLED(CONFIG_LEDS_CLASS)
865 if (call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON
) {
866 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
869 fujitsu_laptop
->logolamp_registered
= 1;
871 pr_err("Could not register LED handler for logo lamp, error %i\n",
876 if ((call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & KEYBOARD_LAMPS
) &&
877 (call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0) == 0x0)) {
878 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
881 fujitsu_laptop
->kblamps_registered
= 1;
883 pr_err("Could not register LED handler for keyboard lamps, error %i\n",
889 * BTNI bit 24 seems to indicate the presence of a radio toggle
890 * button in place of a slide switch, and all such machines appear
891 * to also have an RF LED. Therefore use bit 24 as an indicator
892 * that an RF LED is present.
894 if (call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0) & BIT(24)) {
895 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
898 fujitsu_laptop
->radio_led_registered
= 1;
900 pr_err("Could not register LED handler for radio LED, error %i\n",
905 /* Support for eco led is not always signaled in bit corresponding
906 * to the bit used to control the led. According to the DSDT table,
907 * bit 14 seems to indicate presence of said led as well.
908 * Confirm by testing the status.
910 if ((call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & BIT(14)) &&
911 (call_fext_func(FUNC_LEDS
, 0x2, ECO_LED
, 0x0) != UNSUPPORTED_CMD
)) {
912 result
= led_classdev_register(&fujitsu_laptop
->pf_device
->dev
,
915 fujitsu_laptop
->eco_led_registered
= 1;
917 pr_err("Could not register LED handler for eco LED, error %i\n",
926 kfifo_free(&fujitsu_laptop
->fifo
);
931 static int acpi_fujitsu_laptop_remove(struct acpi_device
*device
)
933 struct fujitsu_laptop
*fujitsu_laptop
= acpi_driver_data(device
);
935 #if IS_ENABLED(CONFIG_LEDS_CLASS)
936 if (fujitsu_laptop
->logolamp_registered
)
937 led_classdev_unregister(&logolamp_led
);
939 if (fujitsu_laptop
->kblamps_registered
)
940 led_classdev_unregister(&kblamps_led
);
942 if (fujitsu_laptop
->radio_led_registered
)
943 led_classdev_unregister(&radio_led
);
945 if (fujitsu_laptop
->eco_led_registered
)
946 led_classdev_unregister(&eco_led
);
949 fujitsu_laptop_platform_remove();
951 kfifo_free(&fujitsu_laptop
->fifo
);
953 fujitsu_laptop
->acpi_handle
= NULL
;
958 static void acpi_fujitsu_laptop_press(int scancode
)
960 struct input_dev
*input
= fujitsu_laptop
->input
;
963 status
= kfifo_in_locked(&fujitsu_laptop
->fifo
,
964 (unsigned char *)&scancode
, sizeof(scancode
),
965 &fujitsu_laptop
->fifo_lock
);
966 if (status
!= sizeof(scancode
)) {
967 vdbg_printk(FUJLAPTOP_DBG_WARN
,
968 "Could not push scancode [0x%x]\n", scancode
);
971 sparse_keymap_report_event(input
, scancode
, 1, false);
972 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
973 "Push scancode into ringbuffer [0x%x]\n", scancode
);
976 static void acpi_fujitsu_laptop_release(void)
978 struct input_dev
*input
= fujitsu_laptop
->input
;
979 int scancode
, status
;
982 status
= kfifo_out_locked(&fujitsu_laptop
->fifo
,
983 (unsigned char *)&scancode
,
985 &fujitsu_laptop
->fifo_lock
);
986 if (status
!= sizeof(scancode
))
988 sparse_keymap_report_event(input
, scancode
, 0, false);
989 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
990 "Pop scancode from ringbuffer [0x%x]\n", scancode
);
994 static void acpi_fujitsu_laptop_notify(struct acpi_device
*device
, u32 event
)
996 struct input_dev
*input
;
1000 input
= fujitsu_laptop
->input
;
1002 if (event
!= ACPI_FUJITSU_NOTIFY_CODE1
) {
1003 vdbg_printk(FUJLAPTOP_DBG_WARN
,
1004 "Unsupported event [0x%x]\n", event
);
1005 sparse_keymap_report_event(input
, -1, 1, true);
1009 if (fujitsu_laptop
->flags_supported
)
1010 fujitsu_laptop
->flags_state
=
1011 call_fext_func(FUNC_FLAGS
, 0x4, 0x0, 0x0);
1013 while ((irb
= call_fext_func(FUNC_BUTTONS
, 0x1, 0x0, 0x0)) != 0 &&
1014 i
++ < MAX_HOTKEY_RINGBUFFER_SIZE
) {
1015 scancode
= irb
& 0x4ff;
1016 if (sparse_keymap_entry_from_scancode(input
, scancode
))
1017 acpi_fujitsu_laptop_press(scancode
);
1018 else if (scancode
== 0)
1019 acpi_fujitsu_laptop_release();
1021 vdbg_printk(FUJLAPTOP_DBG_WARN
,
1022 "Unknown GIRB result [%x]\n", irb
);
1025 /* On some models (first seen on the Skylake-based Lifebook
1026 * E736/E746/E756), the touchpad toggle hotkey (Fn+F4) is
1027 * handled in software; its state is queried using FUNC_FLAGS
1029 if ((fujitsu_laptop
->flags_supported
& BIT(26)) &&
1030 (call_fext_func(FUNC_FLAGS
, 0x1, 0x0, 0x0) & BIT(26)))
1031 sparse_keymap_report_event(input
, BIT(26), 1, true);
1034 /* Initialization */
1036 static const struct acpi_device_id fujitsu_bl_device_ids
[] = {
1037 {ACPI_FUJITSU_BL_HID
, 0},
1041 static struct acpi_driver acpi_fujitsu_bl_driver
= {
1042 .name
= ACPI_FUJITSU_BL_DRIVER_NAME
,
1043 .class = ACPI_FUJITSU_CLASS
,
1044 .ids
= fujitsu_bl_device_ids
,
1046 .add
= acpi_fujitsu_bl_add
,
1047 .notify
= acpi_fujitsu_bl_notify
,
1051 static const struct acpi_device_id fujitsu_laptop_device_ids
[] = {
1052 {ACPI_FUJITSU_LAPTOP_HID
, 0},
1056 static struct acpi_driver acpi_fujitsu_laptop_driver
= {
1057 .name
= ACPI_FUJITSU_LAPTOP_DRIVER_NAME
,
1058 .class = ACPI_FUJITSU_CLASS
,
1059 .ids
= fujitsu_laptop_device_ids
,
1061 .add
= acpi_fujitsu_laptop_add
,
1062 .remove
= acpi_fujitsu_laptop_remove
,
1063 .notify
= acpi_fujitsu_laptop_notify
,
1067 static const struct acpi_device_id fujitsu_ids
[] __used
= {
1068 {ACPI_FUJITSU_BL_HID
, 0},
1069 {ACPI_FUJITSU_LAPTOP_HID
, 0},
1072 MODULE_DEVICE_TABLE(acpi
, fujitsu_ids
);
1074 static int __init
fujitsu_init(void)
1081 fujitsu_bl
= kzalloc(sizeof(struct fujitsu_bl
), GFP_KERNEL
);
1085 ret
= acpi_bus_register_driver(&acpi_fujitsu_bl_driver
);
1087 goto err_free_fujitsu_bl
;
1089 /* Register platform stuff */
1091 ret
= platform_driver_register(&fujitsu_pf_driver
);
1093 goto err_unregister_acpi
;
1095 /* Register laptop driver */
1097 fujitsu_laptop
= kzalloc(sizeof(struct fujitsu_laptop
), GFP_KERNEL
);
1098 if (!fujitsu_laptop
) {
1100 goto err_unregister_platform_driver
;
1103 ret
= acpi_bus_register_driver(&acpi_fujitsu_laptop_driver
);
1105 goto err_free_fujitsu_laptop
;
1107 pr_info("driver " FUJITSU_DRIVER_VERSION
" successfully loaded\n");
1111 err_free_fujitsu_laptop
:
1112 kfree(fujitsu_laptop
);
1113 err_unregister_platform_driver
:
1114 platform_driver_unregister(&fujitsu_pf_driver
);
1115 err_unregister_acpi
:
1116 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver
);
1117 err_free_fujitsu_bl
:
1123 static void __exit
fujitsu_cleanup(void)
1125 acpi_bus_unregister_driver(&acpi_fujitsu_laptop_driver
);
1127 kfree(fujitsu_laptop
);
1129 platform_driver_unregister(&fujitsu_pf_driver
);
1131 acpi_bus_unregister_driver(&acpi_fujitsu_bl_driver
);
1135 pr_info("driver unloaded\n");
1138 module_init(fujitsu_init
);
1139 module_exit(fujitsu_cleanup
);
1141 module_param(use_alt_lcd_levels
, uint
, 0644);
1142 MODULE_PARM_DESC(use_alt_lcd_levels
,
1143 "Use alternative interface for lcd_levels (needed for Lifebook s6410).");
1144 module_param(disable_brightness_adjust
, uint
, 0644);
1145 MODULE_PARM_DESC(disable_brightness_adjust
, "Disable brightness adjustment .");
1146 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
1147 module_param_named(debug
, dbg_level
, uint
, 0644);
1148 MODULE_PARM_DESC(debug
, "Sets debug level bit-mask");
1151 MODULE_AUTHOR("Jonathan Woithe, Peter Gruber, Tony Vroon");
1152 MODULE_DESCRIPTION("Fujitsu laptop extras support");
1153 MODULE_VERSION(FUJITSU_DRIVER_VERSION
);
1154 MODULE_LICENSE("GPL");