4 Copyright (C) 2007,2008 Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
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 exports a few files in /sys/devices/platform/fujitsu-laptop/;
36 * others may be added at a later date.
38 * lcd_level - Screen brightness: contains a single integer in the
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/.
45 * Hotkeys present on certain Fujitsu laptops (eg: the S6xxx series) are
46 * also supported by this driver.
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
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.
59 #include <linux/module.h>
60 #include <linux/kernel.h>
61 #include <linux/init.h>
62 #include <linux/acpi.h>
63 #include <linux/dmi.h>
64 #include <linux/backlight.h>
65 #include <linux/input.h>
66 #include <linux/kfifo.h>
67 #include <linux/video_output.h>
68 #include <linux/platform_device.h>
69 #ifdef CONFIG_LEDS_CLASS
70 #include <linux/leds.h>
73 #define FUJITSU_DRIVER_VERSION "0.5.0"
75 #define FUJITSU_LCD_N_LEVELS 8
77 #define ACPI_FUJITSU_CLASS "fujitsu"
78 #define ACPI_FUJITSU_HID "FUJ02B1"
79 #define ACPI_FUJITSU_DRIVER_NAME "Fujitsu laptop FUJ02B1 ACPI brightness driver"
80 #define ACPI_FUJITSU_DEVICE_NAME "Fujitsu FUJ02B1"
81 #define ACPI_FUJITSU_HOTKEY_HID "FUJ02E3"
82 #define ACPI_FUJITSU_HOTKEY_DRIVER_NAME "Fujitsu laptop FUJ02E3 ACPI hotkeys driver"
83 #define ACPI_FUJITSU_HOTKEY_DEVICE_NAME "Fujitsu FUJ02E3"
85 #define ACPI_FUJITSU_NOTIFY_CODE1 0x80
87 #define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
88 #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
90 /* FUNC interface - command values */
91 #define FUNC_RFKILL 0x1000
92 #define FUNC_LEDS 0x1001
93 #define FUNC_BUTTONS 0x1002
94 #define FUNC_BACKLIGHT 0x1004
96 /* FUNC interface - responses */
97 #define UNSUPPORTED_CMD 0x80000000
99 #ifdef CONFIG_LEDS_CLASS
100 /* FUNC interface - LED control */
101 #define FUNC_LED_OFF 0x1
102 #define FUNC_LED_ON 0x30001
103 #define KEYBOARD_LAMPS 0x100
104 #define LOGOLAMP_POWERON 0x2000
105 #define LOGOLAMP_ALWAYS 0x4000
109 #define KEY1_CODE 0x410 /* codes for the keys in the GIRB register */
110 #define KEY2_CODE 0x411
111 #define KEY3_CODE 0x412
112 #define KEY4_CODE 0x413
114 #define MAX_HOTKEY_RINGBUFFER_SIZE 100
115 #define RINGBUFFERSIZE 40
118 #define FUJLAPTOP_LOG ACPI_FUJITSU_HID ": "
119 #define FUJLAPTOP_ERR KERN_ERR FUJLAPTOP_LOG
120 #define FUJLAPTOP_NOTICE KERN_NOTICE FUJLAPTOP_LOG
121 #define FUJLAPTOP_INFO KERN_INFO FUJLAPTOP_LOG
122 #define FUJLAPTOP_DEBUG KERN_DEBUG FUJLAPTOP_LOG
124 #define FUJLAPTOP_DBG_ALL 0xffff
125 #define FUJLAPTOP_DBG_ERROR 0x0001
126 #define FUJLAPTOP_DBG_WARN 0x0002
127 #define FUJLAPTOP_DBG_INFO 0x0004
128 #define FUJLAPTOP_DBG_TRACE 0x0008
130 #define dbg_printk(a_dbg_level, format, arg...) \
131 do { if (dbg_level & a_dbg_level) \
132 printk(FUJLAPTOP_DEBUG "%s: " format, __func__ , ## arg); \
134 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
135 #define vdbg_printk(a_dbg_level, format, arg...) \
136 dbg_printk(a_dbg_level, format, ## arg)
138 #define vdbg_printk(a_dbg_level, format, arg...)
141 /* Device controlling the backlight and associated keys */
143 acpi_handle acpi_handle
;
144 struct acpi_device
*dev
;
145 struct input_dev
*input
;
147 struct backlight_device
*bl_device
;
148 struct platform_device
*pf_device
;
149 int keycode1
, keycode2
, keycode3
, keycode4
;
151 unsigned int max_brightness
;
152 unsigned int brightness_changed
;
153 unsigned int brightness_level
;
156 static struct fujitsu_t
*fujitsu
;
157 static int use_alt_lcd_levels
= -1;
158 static int disable_brightness_adjust
= -1;
160 /* Device used to access other hotkeys on the laptop */
161 struct fujitsu_hotkey_t
{
162 acpi_handle acpi_handle
;
163 struct acpi_device
*dev
;
164 struct input_dev
*input
;
166 struct platform_device
*pf_device
;
168 spinlock_t fifo_lock
;
169 int rfkill_supported
;
171 int logolamp_registered
;
172 int kblamps_registered
;
175 static struct fujitsu_hotkey_t
*fujitsu_hotkey
;
177 static void acpi_fujitsu_hotkey_notify(acpi_handle handle
, u32 event
,
180 #ifdef CONFIG_LEDS_CLASS
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
);
185 struct led_classdev logolamp_led
= {
186 .name
= "fujitsu::logolamp",
187 .brightness_get
= logolamp_get
,
188 .brightness_set
= logolamp_set
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
);
195 struct led_classdev kblamps_led
= {
196 .name
= "fujitsu::kblamps",
197 .brightness_get
= kblamps_get
,
198 .brightness_set
= kblamps_set
202 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
203 static u32 dbg_level
= 0x03;
206 static void acpi_fujitsu_notify(acpi_handle handle
, u32 event
, void *data
);
208 /* Fujitsu ACPI interface function */
210 static int call_fext_func(int cmd
, int arg0
, int arg1
, int arg2
)
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
}
219 struct acpi_object_list arg_list
= { 4, ¶ms
[0] };
220 struct acpi_buffer output
;
221 union acpi_object out_obj
;
222 acpi_handle handle
= NULL
;
224 status
= acpi_get_handle(fujitsu_hotkey
->acpi_handle
, "FUNC", &handle
);
225 if (ACPI_FAILURE(status
)) {
226 vdbg_printk(FUJLAPTOP_DBG_ERROR
,
227 "FUNC interface is not present\n");
231 params
[0].integer
.value
= cmd
;
232 params
[1].integer
.value
= arg0
;
233 params
[2].integer
.value
= arg1
;
234 params
[3].integer
.value
= arg2
;
236 output
.length
= sizeof(out_obj
);
237 output
.pointer
= &out_obj
;
239 status
= acpi_evaluate_object(handle
, NULL
, &arg_list
, &output
);
240 if (ACPI_FAILURE(status
)) {
241 vdbg_printk(FUJLAPTOP_DBG_WARN
,
242 "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) call failed\n",
243 cmd
, arg0
, arg1
, arg2
);
247 if (out_obj
.type
!= ACPI_TYPE_INTEGER
) {
248 vdbg_printk(FUJLAPTOP_DBG_WARN
,
249 "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) did not "
250 "return an integer\n",
251 cmd
, arg0
, arg1
, arg2
);
255 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
256 "FUNC 0x%x (args 0x%x, 0x%x, 0x%x) returned 0x%x\n",
257 cmd
, arg0
, arg1
, arg2
, (int)out_obj
.integer
.value
);
258 return out_obj
.integer
.value
;
261 #ifdef CONFIG_LEDS_CLASS
262 /* LED class callbacks */
264 static void logolamp_set(struct led_classdev
*cdev
,
265 enum led_brightness brightness
)
267 if (brightness
>= LED_FULL
) {
268 call_fext_func(FUNC_LEDS
, 0x1, LOGOLAMP_POWERON
, FUNC_LED_ON
);
269 call_fext_func(FUNC_LEDS
, 0x1, LOGOLAMP_ALWAYS
, FUNC_LED_ON
);
270 } else if (brightness
>= LED_HALF
) {
271 call_fext_func(FUNC_LEDS
, 0x1, LOGOLAMP_POWERON
, FUNC_LED_ON
);
272 call_fext_func(FUNC_LEDS
, 0x1, LOGOLAMP_ALWAYS
, FUNC_LED_OFF
);
274 call_fext_func(FUNC_LEDS
, 0x1, LOGOLAMP_POWERON
, FUNC_LED_OFF
);
278 static void kblamps_set(struct led_classdev
*cdev
,
279 enum led_brightness brightness
)
281 if (brightness
>= LED_FULL
)
282 call_fext_func(FUNC_LEDS
, 0x1, KEYBOARD_LAMPS
, FUNC_LED_ON
);
284 call_fext_func(FUNC_LEDS
, 0x1, KEYBOARD_LAMPS
, FUNC_LED_OFF
);
287 static enum led_brightness
logolamp_get(struct led_classdev
*cdev
)
289 enum led_brightness brightness
= LED_OFF
;
292 poweron
= call_fext_func(FUNC_LEDS
, 0x2, LOGOLAMP_POWERON
, 0x0);
293 if (poweron
== FUNC_LED_ON
) {
294 brightness
= LED_HALF
;
295 always
= call_fext_func(FUNC_LEDS
, 0x2, LOGOLAMP_ALWAYS
, 0x0);
296 if (always
== FUNC_LED_ON
)
297 brightness
= LED_FULL
;
302 static enum led_brightness
kblamps_get(struct led_classdev
*cdev
)
304 enum led_brightness brightness
= LED_OFF
;
306 if (call_fext_func(FUNC_LEDS
, 0x2, KEYBOARD_LAMPS
, 0x0) == FUNC_LED_ON
)
307 brightness
= LED_FULL
;
313 /* Hardware access for LCD brightness control */
315 static int set_lcd_level(int level
)
317 acpi_status status
= AE_OK
;
318 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
319 struct acpi_object_list arg_list
= { 1, &arg0
};
320 acpi_handle handle
= NULL
;
322 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "set lcd level via SBLL [%d]\n",
325 if (level
< 0 || level
>= fujitsu
->max_brightness
)
331 status
= acpi_get_handle(fujitsu
->acpi_handle
, "SBLL", &handle
);
332 if (ACPI_FAILURE(status
)) {
333 vdbg_printk(FUJLAPTOP_DBG_ERROR
, "SBLL not present\n");
337 arg0
.integer
.value
= level
;
339 status
= acpi_evaluate_object(handle
, NULL
, &arg_list
, NULL
);
340 if (ACPI_FAILURE(status
))
346 static int set_lcd_level_alt(int level
)
348 acpi_status status
= AE_OK
;
349 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
350 struct acpi_object_list arg_list
= { 1, &arg0
};
351 acpi_handle handle
= NULL
;
353 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "set lcd level via SBL2 [%d]\n",
356 if (level
< 0 || level
>= fujitsu
->max_brightness
)
362 status
= acpi_get_handle(fujitsu
->acpi_handle
, "SBL2", &handle
);
363 if (ACPI_FAILURE(status
)) {
364 vdbg_printk(FUJLAPTOP_DBG_ERROR
, "SBL2 not present\n");
368 arg0
.integer
.value
= level
;
370 status
= acpi_evaluate_object(handle
, NULL
, &arg_list
, NULL
);
371 if (ACPI_FAILURE(status
))
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");
385 acpi_evaluate_integer(fujitsu
->acpi_handle
, "GBLL", NULL
, &state
);
389 fujitsu
->brightness_level
= state
& 0x0fffffff;
391 if (state
& 0x80000000)
392 fujitsu
->brightness_changed
= 1;
394 fujitsu
->brightness_changed
= 0;
396 return fujitsu
->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");
407 acpi_evaluate_integer(fujitsu
->acpi_handle
, "RBLL", NULL
, &state
);
411 fujitsu
->max_brightness
= state
;
413 return fujitsu
->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
== 4)
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 if (use_alt_lcd_levels
)
436 ret
= set_lcd_level_alt(b
->props
.brightness
);
438 ret
= set_lcd_level(b
->props
.brightness
);
440 vdbg_printk(FUJLAPTOP_DBG_ERROR
,
441 "Unable to adjust LCD brightness, error code %i\n",
446 static struct backlight_ops fujitsubl_ops
= {
447 .get_brightness
= bl_get_brightness
,
448 .update_status
= bl_update_status
,
451 /* Platform LCD brightness device */
454 show_max_brightness(struct device
*dev
,
455 struct device_attribute
*attr
, char *buf
)
460 ret
= get_max_brightness();
464 return sprintf(buf
, "%i\n", ret
);
468 show_brightness_changed(struct device
*dev
,
469 struct device_attribute
*attr
, char *buf
)
474 ret
= fujitsu
->brightness_changed
;
478 return sprintf(buf
, "%i\n", ret
);
481 static ssize_t
show_lcd_level(struct device
*dev
,
482 struct device_attribute
*attr
, char *buf
)
487 ret
= get_lcd_level();
491 return sprintf(buf
, "%i\n", ret
);
494 static ssize_t
store_lcd_level(struct device
*dev
,
495 struct device_attribute
*attr
, const char *buf
,
501 if (sscanf(buf
, "%i", &level
) != 1
502 || (level
< 0 || level
>= fujitsu
->max_brightness
))
505 if (use_alt_lcd_levels
)
506 ret
= set_lcd_level_alt(level
);
508 ret
= set_lcd_level(level
);
512 ret
= get_lcd_level();
520 ignore_store(struct device
*dev
,
521 struct device_attribute
*attr
, const char *buf
, size_t count
)
527 show_lid_state(struct device
*dev
,
528 struct device_attribute
*attr
, char *buf
)
530 if (!(fujitsu_hotkey
->rfkill_supported
& 0x100))
531 return sprintf(buf
, "unknown\n");
532 if (fujitsu_hotkey
->rfkill_state
& 0x100)
533 return sprintf(buf
, "open\n");
535 return sprintf(buf
, "closed\n");
539 show_dock_state(struct device
*dev
,
540 struct device_attribute
*attr
, char *buf
)
542 if (!(fujitsu_hotkey
->rfkill_supported
& 0x200))
543 return sprintf(buf
, "unknown\n");
544 if (fujitsu_hotkey
->rfkill_state
& 0x200)
545 return sprintf(buf
, "docked\n");
547 return sprintf(buf
, "undocked\n");
551 show_radios_state(struct device
*dev
,
552 struct device_attribute
*attr
, char *buf
)
554 if (!(fujitsu_hotkey
->rfkill_supported
& 0x20))
555 return sprintf(buf
, "unknown\n");
556 if (fujitsu_hotkey
->rfkill_state
& 0x20)
557 return sprintf(buf
, "on\n");
559 return sprintf(buf
, "killed\n");
562 static DEVICE_ATTR(max_brightness
, 0444, show_max_brightness
, ignore_store
);
563 static DEVICE_ATTR(brightness_changed
, 0444, show_brightness_changed
,
565 static DEVICE_ATTR(lcd_level
, 0644, show_lcd_level
, store_lcd_level
);
566 static DEVICE_ATTR(lid
, 0444, show_lid_state
, ignore_store
);
567 static DEVICE_ATTR(dock
, 0444, show_dock_state
, ignore_store
);
568 static DEVICE_ATTR(radios
, 0444, show_radios_state
, ignore_store
);
570 static struct attribute
*fujitsupf_attributes
[] = {
571 &dev_attr_brightness_changed
.attr
,
572 &dev_attr_max_brightness
.attr
,
573 &dev_attr_lcd_level
.attr
,
576 &dev_attr_radios
.attr
,
580 static struct attribute_group fujitsupf_attribute_group
= {
581 .attrs
= fujitsupf_attributes
584 static struct platform_driver fujitsupf_driver
= {
586 .name
= "fujitsu-laptop",
587 .owner
= THIS_MODULE
,
591 static void dmi_check_cb_common(const struct dmi_system_id
*id
)
594 printk(KERN_INFO
"fujitsu-laptop: Identified laptop model '%s'.\n",
596 if (use_alt_lcd_levels
== -1) {
597 if (ACPI_SUCCESS(acpi_get_handle(NULL
,
598 "\\_SB.PCI0.LPCB.FJEX.SBL2", &handle
)))
599 use_alt_lcd_levels
= 1;
601 use_alt_lcd_levels
= 0;
602 vdbg_printk(FUJLAPTOP_DBG_TRACE
, "auto-detected usealt as "
603 "%i\n", use_alt_lcd_levels
);
607 static int dmi_check_cb_s6410(const struct dmi_system_id
*id
)
609 dmi_check_cb_common(id
);
610 fujitsu
->keycode1
= KEY_SCREENLOCK
; /* "Lock" */
611 fujitsu
->keycode2
= KEY_HELP
; /* "Mobility Center" */
615 static int dmi_check_cb_s6420(const struct dmi_system_id
*id
)
617 dmi_check_cb_common(id
);
618 fujitsu
->keycode1
= KEY_SCREENLOCK
; /* "Lock" */
619 fujitsu
->keycode2
= KEY_HELP
; /* "Mobility Center" */
623 static int dmi_check_cb_p8010(const struct dmi_system_id
*id
)
625 dmi_check_cb_common(id
);
626 fujitsu
->keycode1
= KEY_HELP
; /* "Support" */
627 fujitsu
->keycode3
= KEY_SWITCHVIDEOMODE
; /* "Presentation" */
628 fujitsu
->keycode4
= KEY_WWW
; /* "Internet" */
632 static struct dmi_system_id fujitsu_dmi_table
[] = {
634 .ident
= "Fujitsu Siemens S6410",
636 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU SIEMENS"),
637 DMI_MATCH(DMI_PRODUCT_NAME
, "LIFEBOOK S6410"),
639 .callback
= dmi_check_cb_s6410
},
641 .ident
= "Fujitsu Siemens S6420",
643 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU SIEMENS"),
644 DMI_MATCH(DMI_PRODUCT_NAME
, "LIFEBOOK S6420"),
646 .callback
= dmi_check_cb_s6420
},
648 .ident
= "Fujitsu LifeBook P8010",
650 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU"),
651 DMI_MATCH(DMI_PRODUCT_NAME
, "LifeBook P8010"),
653 .callback
= dmi_check_cb_p8010
},
657 /* ACPI device for LCD brightness control */
659 static int acpi_fujitsu_add(struct acpi_device
*device
)
665 struct input_dev
*input
;
671 fujitsu
->acpi_handle
= device
->handle
;
672 sprintf(acpi_device_name(device
), "%s", ACPI_FUJITSU_DEVICE_NAME
);
673 sprintf(acpi_device_class(device
), "%s", ACPI_FUJITSU_CLASS
);
674 device
->driver_data
= fujitsu
;
676 status
= acpi_install_notify_handler(device
->handle
,
678 acpi_fujitsu_notify
, fujitsu
);
680 if (ACPI_FAILURE(status
)) {
681 printk(KERN_ERR
"Error installing notify handler\n");
686 fujitsu
->input
= input
= input_allocate_device();
689 goto err_uninstall_notify
;
692 snprintf(fujitsu
->phys
, sizeof(fujitsu
->phys
),
693 "%s/video/input0", acpi_device_hid(device
));
695 input
->name
= acpi_device_name(device
);
696 input
->phys
= fujitsu
->phys
;
697 input
->id
.bustype
= BUS_HOST
;
698 input
->id
.product
= 0x06;
699 input
->dev
.parent
= &device
->dev
;
700 input
->evbit
[0] = BIT(EV_KEY
);
701 set_bit(KEY_BRIGHTNESSUP
, input
->keybit
);
702 set_bit(KEY_BRIGHTNESSDOWN
, input
->keybit
);
703 set_bit(KEY_UNKNOWN
, input
->keybit
);
705 error
= input_register_device(input
);
707 goto err_free_input_dev
;
709 result
= acpi_bus_get_power(fujitsu
->acpi_handle
, &state
);
711 printk(KERN_ERR
"Error reading power state\n");
715 printk(KERN_INFO PREFIX
"%s [%s] (%s)\n",
716 acpi_device_name(device
), acpi_device_bid(device
),
717 !device
->power
.state
? "on" : "off");
719 fujitsu
->dev
= device
;
722 (acpi_get_handle(device
->handle
, METHOD_NAME__INI
, &handle
))) {
723 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Invoking _INI\n");
725 (acpi_evaluate_object
726 (device
->handle
, METHOD_NAME__INI
, NULL
, NULL
)))
727 printk(KERN_ERR
"_INI Method failed\n");
730 /* do config (detect defaults) */
731 use_alt_lcd_levels
= use_alt_lcd_levels
== 1 ? 1 : 0;
732 disable_brightness_adjust
= disable_brightness_adjust
== 1 ? 1 : 0;
733 vdbg_printk(FUJLAPTOP_DBG_INFO
,
734 "config: [alt interface: %d], [adjust disable: %d]\n",
735 use_alt_lcd_levels
, disable_brightness_adjust
);
737 if (get_max_brightness() <= 0)
738 fujitsu
->max_brightness
= FUJITSU_LCD_N_LEVELS
;
745 input_free_device(input
);
746 err_uninstall_notify
:
747 acpi_remove_notify_handler(device
->handle
, ACPI_DEVICE_NOTIFY
,
748 acpi_fujitsu_notify
);
754 static int acpi_fujitsu_remove(struct acpi_device
*device
, int type
)
757 struct fujitsu_t
*fujitsu
= NULL
;
759 if (!device
|| !acpi_driver_data(device
))
762 fujitsu
= acpi_driver_data(device
);
764 status
= acpi_remove_notify_handler(fujitsu
->acpi_handle
,
766 acpi_fujitsu_notify
);
768 if (!device
|| !acpi_driver_data(device
))
771 fujitsu
->acpi_handle
= NULL
;
776 /* Brightness notify */
778 static void acpi_fujitsu_notify(acpi_handle handle
, u32 event
, void *data
)
780 struct input_dev
*input
;
784 input
= fujitsu
->input
;
787 case ACPI_FUJITSU_NOTIFY_CODE1
:
789 oldb
= fujitsu
->brightness_level
;
791 newb
= fujitsu
->brightness_level
;
793 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
794 "brightness button event [%i -> %i (%i)]\n",
795 oldb
, newb
, fujitsu
->brightness_changed
);
798 if (disable_brightness_adjust
!= 1) {
799 if (use_alt_lcd_levels
)
800 set_lcd_level_alt(newb
);
804 acpi_bus_generate_proc_event(fujitsu
->dev
,
805 ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS
, 0);
806 keycode
= KEY_BRIGHTNESSUP
;
807 } else if (oldb
> newb
) {
808 if (disable_brightness_adjust
!= 1) {
809 if (use_alt_lcd_levels
)
810 set_lcd_level_alt(newb
);
814 acpi_bus_generate_proc_event(fujitsu
->dev
,
815 ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS
, 0);
816 keycode
= KEY_BRIGHTNESSDOWN
;
820 keycode
= KEY_UNKNOWN
;
821 vdbg_printk(FUJLAPTOP_DBG_WARN
,
822 "unsupported event [0x%x]\n", event
);
827 input_report_key(input
, keycode
, 1);
829 input_report_key(input
, keycode
, 0);
836 /* ACPI device for hotkey handling */
838 static int acpi_fujitsu_hotkey_add(struct acpi_device
*device
)
844 struct input_dev
*input
;
851 fujitsu_hotkey
->acpi_handle
= device
->handle
;
852 sprintf(acpi_device_name(device
), "%s",
853 ACPI_FUJITSU_HOTKEY_DEVICE_NAME
);
854 sprintf(acpi_device_class(device
), "%s", ACPI_FUJITSU_CLASS
);
855 device
->driver_data
= fujitsu_hotkey
;
857 status
= acpi_install_notify_handler(device
->handle
,
859 acpi_fujitsu_hotkey_notify
,
862 if (ACPI_FAILURE(status
)) {
863 printk(KERN_ERR
"Error installing notify handler\n");
869 spin_lock_init(&fujitsu_hotkey
->fifo_lock
);
870 fujitsu_hotkey
->fifo
=
871 kfifo_alloc(RINGBUFFERSIZE
* sizeof(int), GFP_KERNEL
,
872 &fujitsu_hotkey
->fifo_lock
);
873 if (IS_ERR(fujitsu_hotkey
->fifo
)) {
874 printk(KERN_ERR
"kfifo_alloc failed\n");
875 error
= PTR_ERR(fujitsu_hotkey
->fifo
);
879 fujitsu_hotkey
->input
= input
= input_allocate_device();
882 goto err_uninstall_notify
;
885 snprintf(fujitsu_hotkey
->phys
, sizeof(fujitsu_hotkey
->phys
),
886 "%s/video/input0", acpi_device_hid(device
));
888 input
->name
= acpi_device_name(device
);
889 input
->phys
= fujitsu_hotkey
->phys
;
890 input
->id
.bustype
= BUS_HOST
;
891 input
->id
.product
= 0x06;
892 input
->dev
.parent
= &device
->dev
;
894 set_bit(EV_KEY
, input
->evbit
);
895 set_bit(fujitsu
->keycode1
, input
->keybit
);
896 set_bit(fujitsu
->keycode2
, input
->keybit
);
897 set_bit(fujitsu
->keycode3
, input
->keybit
);
898 set_bit(fujitsu
->keycode4
, input
->keybit
);
899 set_bit(KEY_UNKNOWN
, input
->keybit
);
901 error
= input_register_device(input
);
903 goto err_free_input_dev
;
905 result
= acpi_bus_get_power(fujitsu_hotkey
->acpi_handle
, &state
);
907 printk(KERN_ERR
"Error reading power state\n");
911 printk(KERN_INFO PREFIX
"%s [%s] (%s)\n",
912 acpi_device_name(device
), acpi_device_bid(device
),
913 !device
->power
.state
? "on" : "off");
915 fujitsu_hotkey
->dev
= device
;
918 (acpi_get_handle(device
->handle
, METHOD_NAME__INI
, &handle
))) {
919 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Invoking _INI\n");
921 (acpi_evaluate_object
922 (device
->handle
, METHOD_NAME__INI
, NULL
, NULL
)))
923 printk(KERN_ERR
"_INI Method failed\n");
927 while (call_fext_func(FUNC_BUTTONS
, 0x1, 0x0, 0x0) != 0
928 && (i
++) < MAX_HOTKEY_RINGBUFFER_SIZE
)
929 ; /* No action, result is discarded */
930 vdbg_printk(FUJLAPTOP_DBG_INFO
, "Discarded %i ringbuffer entries\n", i
);
932 fujitsu_hotkey
->rfkill_supported
=
933 call_fext_func(FUNC_RFKILL
, 0x0, 0x0, 0x0);
935 /* Make sure our bitmask of supported functions is cleared if the
936 RFKILL function block is not implemented, like on the S7020. */
937 if (fujitsu_hotkey
->rfkill_supported
== UNSUPPORTED_CMD
)
938 fujitsu_hotkey
->rfkill_supported
= 0;
940 if (fujitsu_hotkey
->rfkill_supported
)
941 fujitsu_hotkey
->rfkill_state
=
942 call_fext_func(FUNC_RFKILL
, 0x4, 0x0, 0x0);
944 /* Suspect this is a keymap of the application panel, print it */
945 printk(KERN_INFO
"fujitsu-laptop: BTNI: [0x%x]\n",
946 call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0));
948 #ifdef CONFIG_LEDS_CLASS
949 if (call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON
) {
950 result
= led_classdev_register(&fujitsu
->pf_device
->dev
,
953 fujitsu_hotkey
->logolamp_registered
= 1;
955 printk(KERN_ERR
"fujitsu-laptop: Could not register "
956 "LED handler for logo lamp, error %i\n", result
);
960 if ((call_fext_func(FUNC_LEDS
, 0x0, 0x0, 0x0) & KEYBOARD_LAMPS
) &&
961 (call_fext_func(FUNC_BUTTONS
, 0x0, 0x0, 0x0) == 0x0)) {
962 result
= led_classdev_register(&fujitsu
->pf_device
->dev
,
965 fujitsu_hotkey
->kblamps_registered
= 1;
967 printk(KERN_ERR
"fujitsu-laptop: Could not register "
968 "LED handler for keyboard lamps, error %i\n", result
);
977 input_free_device(input
);
978 err_uninstall_notify
:
979 acpi_remove_notify_handler(device
->handle
, ACPI_DEVICE_NOTIFY
,
980 acpi_fujitsu_hotkey_notify
);
981 kfifo_free(fujitsu_hotkey
->fifo
);
987 static int acpi_fujitsu_hotkey_remove(struct acpi_device
*device
, int type
)
990 struct fujitsu_hotkey_t
*fujitsu_hotkey
= NULL
;
992 if (!device
|| !acpi_driver_data(device
))
995 fujitsu_hotkey
= acpi_driver_data(device
);
997 status
= acpi_remove_notify_handler(fujitsu_hotkey
->acpi_handle
,
999 acpi_fujitsu_hotkey_notify
);
1001 fujitsu_hotkey
->acpi_handle
= NULL
;
1003 kfifo_free(fujitsu_hotkey
->fifo
);
1008 static void acpi_fujitsu_hotkey_notify(acpi_handle handle
, u32 event
,
1011 struct input_dev
*input
;
1012 int keycode
, keycode_r
;
1013 unsigned int irb
= 1;
1016 input
= fujitsu_hotkey
->input
;
1018 if (fujitsu_hotkey
->rfkill_supported
)
1019 fujitsu_hotkey
->rfkill_state
=
1020 call_fext_func(FUNC_RFKILL
, 0x4, 0x0, 0x0);
1023 case ACPI_FUJITSU_NOTIFY_CODE1
:
1026 call_fext_func(FUNC_BUTTONS
, 0x1, 0x0, 0x0)) != 0
1027 && (i
++) < MAX_HOTKEY_RINGBUFFER_SIZE
) {
1028 switch (irb
& 0x4ff) {
1030 keycode
= fujitsu
->keycode1
;
1033 keycode
= fujitsu
->keycode2
;
1036 keycode
= fujitsu
->keycode3
;
1039 keycode
= fujitsu
->keycode4
;
1045 vdbg_printk(FUJLAPTOP_DBG_WARN
,
1046 "Unknown GIRB result [%x]\n", irb
);
1051 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
1052 "Push keycode into ringbuffer [%d]\n",
1054 status
= kfifo_put(fujitsu_hotkey
->fifo
,
1055 (unsigned char *)&keycode
,
1057 if (status
!= sizeof(keycode
)) {
1058 vdbg_printk(FUJLAPTOP_DBG_WARN
,
1059 "Could not push keycode [0x%x]\n",
1062 input_report_key(input
, keycode
, 1);
1065 } else if (keycode
== 0) {
1068 (fujitsu_hotkey
->fifo
, (unsigned char *)
1071 (keycode_r
))) == sizeof(keycode_r
)) {
1072 input_report_key(input
, keycode_r
, 0);
1074 vdbg_printk(FUJLAPTOP_DBG_TRACE
,
1075 "Pop keycode from ringbuffer [%d]\n",
1083 keycode
= KEY_UNKNOWN
;
1084 vdbg_printk(FUJLAPTOP_DBG_WARN
,
1085 "Unsupported event [0x%x]\n", event
);
1086 input_report_key(input
, keycode
, 1);
1088 input_report_key(input
, keycode
, 0);
1096 /* Initialization */
1098 static const struct acpi_device_id fujitsu_device_ids
[] = {
1099 {ACPI_FUJITSU_HID
, 0},
1103 static struct acpi_driver acpi_fujitsu_driver
= {
1104 .name
= ACPI_FUJITSU_DRIVER_NAME
,
1105 .class = ACPI_FUJITSU_CLASS
,
1106 .ids
= fujitsu_device_ids
,
1108 .add
= acpi_fujitsu_add
,
1109 .remove
= acpi_fujitsu_remove
,
1113 static const struct acpi_device_id fujitsu_hotkey_device_ids
[] = {
1114 {ACPI_FUJITSU_HOTKEY_HID
, 0},
1118 static struct acpi_driver acpi_fujitsu_hotkey_driver
= {
1119 .name
= ACPI_FUJITSU_HOTKEY_DRIVER_NAME
,
1120 .class = ACPI_FUJITSU_CLASS
,
1121 .ids
= fujitsu_hotkey_device_ids
,
1123 .add
= acpi_fujitsu_hotkey_add
,
1124 .remove
= acpi_fujitsu_hotkey_remove
,
1128 static int __init
fujitsu_init(void)
1130 int ret
, result
, max_brightness
;
1135 fujitsu
= kmalloc(sizeof(struct fujitsu_t
), GFP_KERNEL
);
1138 memset(fujitsu
, 0, sizeof(struct fujitsu_t
));
1139 fujitsu
->keycode1
= KEY_PROG1
;
1140 fujitsu
->keycode2
= KEY_PROG2
;
1141 fujitsu
->keycode3
= KEY_PROG3
;
1142 fujitsu
->keycode4
= KEY_PROG4
;
1143 dmi_check_system(fujitsu_dmi_table
);
1145 result
= acpi_bus_register_driver(&acpi_fujitsu_driver
);
1151 /* Register platform stuff */
1153 fujitsu
->pf_device
= platform_device_alloc("fujitsu-laptop", -1);
1154 if (!fujitsu
->pf_device
) {
1156 goto fail_platform_driver
;
1159 ret
= platform_device_add(fujitsu
->pf_device
);
1161 goto fail_platform_device1
;
1164 sysfs_create_group(&fujitsu
->pf_device
->dev
.kobj
,
1165 &fujitsupf_attribute_group
);
1167 goto fail_platform_device2
;
1169 /* Register backlight stuff */
1171 if (!acpi_video_backlight_support()) {
1172 fujitsu
->bl_device
=
1173 backlight_device_register("fujitsu-laptop", NULL
, NULL
,
1175 if (IS_ERR(fujitsu
->bl_device
))
1176 return PTR_ERR(fujitsu
->bl_device
);
1177 max_brightness
= fujitsu
->max_brightness
;
1178 fujitsu
->bl_device
->props
.max_brightness
= max_brightness
- 1;
1179 fujitsu
->bl_device
->props
.brightness
= fujitsu
->brightness_level
;
1182 ret
= platform_driver_register(&fujitsupf_driver
);
1184 goto fail_backlight
;
1186 /* Register hotkey driver */
1188 fujitsu_hotkey
= kmalloc(sizeof(struct fujitsu_hotkey_t
), GFP_KERNEL
);
1189 if (!fujitsu_hotkey
) {
1193 memset(fujitsu_hotkey
, 0, sizeof(struct fujitsu_hotkey_t
));
1195 result
= acpi_bus_register_driver(&acpi_fujitsu_hotkey_driver
);
1201 /* Sync backlight power status (needs FUJ02E3 device, hence deferred) */
1203 if (!acpi_video_backlight_support()) {
1204 if (call_fext_func(FUNC_BACKLIGHT
, 0x2, 0x4, 0x0) == 3)
1205 fujitsu
->bl_device
->props
.power
= 4;
1207 fujitsu
->bl_device
->props
.power
= 0;
1210 printk(KERN_INFO
"fujitsu-laptop: driver " FUJITSU_DRIVER_VERSION
1211 " successfully loaded.\n");
1217 kfree(fujitsu_hotkey
);
1221 platform_driver_unregister(&fujitsupf_driver
);
1225 if (fujitsu
->bl_device
)
1226 backlight_device_unregister(fujitsu
->bl_device
);
1228 fail_platform_device2
:
1230 platform_device_del(fujitsu
->pf_device
);
1232 fail_platform_device1
:
1234 platform_device_put(fujitsu
->pf_device
);
1236 fail_platform_driver
:
1238 acpi_bus_unregister_driver(&acpi_fujitsu_driver
);
1247 static void __exit
fujitsu_cleanup(void)
1249 #ifdef CONFIG_LEDS_CLASS
1250 if (fujitsu_hotkey
->logolamp_registered
!= 0)
1251 led_classdev_unregister(&logolamp_led
);
1253 if (fujitsu_hotkey
->kblamps_registered
!= 0)
1254 led_classdev_unregister(&kblamps_led
);
1257 sysfs_remove_group(&fujitsu
->pf_device
->dev
.kobj
,
1258 &fujitsupf_attribute_group
);
1259 platform_device_unregister(fujitsu
->pf_device
);
1260 platform_driver_unregister(&fujitsupf_driver
);
1261 if (fujitsu
->bl_device
)
1262 backlight_device_unregister(fujitsu
->bl_device
);
1264 acpi_bus_unregister_driver(&acpi_fujitsu_driver
);
1268 acpi_bus_unregister_driver(&acpi_fujitsu_hotkey_driver
);
1270 kfree(fujitsu_hotkey
);
1272 printk(KERN_INFO
"fujitsu-laptop: driver unloaded.\n");
1275 module_init(fujitsu_init
);
1276 module_exit(fujitsu_cleanup
);
1278 module_param(use_alt_lcd_levels
, uint
, 0644);
1279 MODULE_PARM_DESC(use_alt_lcd_levels
,
1280 "Use alternative interface for lcd_levels (needed for Lifebook s6410).");
1281 module_param(disable_brightness_adjust
, uint
, 0644);
1282 MODULE_PARM_DESC(disable_brightness_adjust
, "Disable brightness adjustment .");
1283 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
1284 module_param_named(debug
, dbg_level
, uint
, 0644);
1285 MODULE_PARM_DESC(debug
, "Sets debug level bit-mask");
1288 MODULE_AUTHOR("Jonathan Woithe, Peter Gruber, Tony Vroon");
1289 MODULE_DESCRIPTION("Fujitsu laptop extras support");
1290 MODULE_VERSION(FUJITSU_DRIVER_VERSION
);
1291 MODULE_LICENSE("GPL");
1293 MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1D3:*:cvrS6410:*");
1294 MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1E6:*:cvrS6420:*");
1295 MODULE_ALIAS("dmi:*:svnFUJITSU:*:pvr:rvnFUJITSU:rnFJNB19C:*:cvrS7020:*");
1297 static struct pnp_device_id pnp_ids
[] = {
1304 MODULE_DEVICE_TABLE(pnp
, pnp_ids
);