Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/platform/x86/fujitsu-laptop.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us