create drivers/platform/x86/ from drivers/misc/
[linux-2.6] / drivers / platform / x86 / fujitsu-laptop.c
1 /*-*-linux-c-*-*/
2
3 /*
4   Copyright (C) 2007,2008 Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
5   Copyright (C) 2008 Peter Gruber <nokos@gmx.net>
6   Based on earlier work:
7     Copyright (C) 2003 Shane Spencer <shane@bogomip.com>
8     Adrian Yee <brewt-fujitsu@brewt.org>
9
10   Templated from msi-laptop.c and thinkpad_acpi.c which is copyright
11   by its respective authors.
12
13   This program is free software; you can redistribute it and/or modify
14   it under the terms of the GNU General Public License as published by
15   the Free Software Foundation; either version 2 of the License, or
16   (at your option) any later version.
17
18   This program is distributed in the hope that it will be useful, but
19   WITHOUT ANY WARRANTY; without even the implied warranty of
20   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21   General Public License for more details.
22
23   You should have received a copy of the GNU General Public License
24   along with this program; if not, write to the Free Software
25   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
26   02110-1301, USA.
27  */
28
29 /*
30  * fujitsu-laptop.c - Fujitsu laptop support, providing access to additional
31  * features made available on a range of Fujitsu laptops including the
32  * P2xxx/P5xxx/S6xxx/S7xxx series.
33  *
34  * This driver exports a few files in /sys/devices/platform/fujitsu-laptop/;
35  * others may be added at a later date.
36  *
37  *   lcd_level - Screen brightness: contains a single integer in the
38  *   range 0..7. (rw)
39  *
40  * In addition to these platform device attributes the driver
41  * registers itself in the Linux backlight control subsystem and is
42  * available to userspace under /sys/class/backlight/fujitsu-laptop/.
43  *
44  * Hotkeys present on certain Fujitsu laptops (eg: the S6xxx series) are
45  * also supported by this driver.
46  *
47  * This driver has been tested on a Fujitsu Lifebook S6410, S7020 and
48  * P8010.  It should work on most P-series and S-series Lifebooks, but
49  * YMMV.
50  *
51  * The module parameter use_alt_lcd_levels switches between different ACPI
52  * brightness controls which are used by different Fujitsu laptops.  In most
53  * cases the correct method is automatically detected. "use_alt_lcd_levels=1"
54  * is applicable for a Fujitsu Lifebook S6410 if autodetection fails.
55  *
56  */
57
58 #include <linux/module.h>
59 #include <linux/kernel.h>
60 #include <linux/init.h>
61 #include <linux/acpi.h>
62 #include <linux/dmi.h>
63 #include <linux/backlight.h>
64 #include <linux/input.h>
65 #include <linux/kfifo.h>
66 #include <linux/video_output.h>
67 #include <linux/platform_device.h>
68
69 #define FUJITSU_DRIVER_VERSION "0.4.3"
70
71 #define FUJITSU_LCD_N_LEVELS 8
72
73 #define ACPI_FUJITSU_CLASS              "fujitsu"
74 #define ACPI_FUJITSU_HID                "FUJ02B1"
75 #define ACPI_FUJITSU_DRIVER_NAME        "Fujitsu laptop FUJ02B1 ACPI brightness driver"
76 #define ACPI_FUJITSU_DEVICE_NAME        "Fujitsu FUJ02B1"
77 #define ACPI_FUJITSU_HOTKEY_HID         "FUJ02E3"
78 #define ACPI_FUJITSU_HOTKEY_DRIVER_NAME "Fujitsu laptop FUJ02E3 ACPI hotkeys driver"
79 #define ACPI_FUJITSU_HOTKEY_DEVICE_NAME "Fujitsu FUJ02E3"
80
81 #define ACPI_FUJITSU_NOTIFY_CODE1     0x80
82
83 #define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS     0x86
84 #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS     0x87
85
86 /* Hotkey details */
87 #define KEY1_CODE       0x410   /* codes for the keys in the GIRB register */
88 #define KEY2_CODE       0x411
89 #define KEY3_CODE       0x412
90 #define KEY4_CODE       0x413
91
92 #define MAX_HOTKEY_RINGBUFFER_SIZE 100
93 #define RINGBUFFERSIZE 40
94
95 /* Debugging */
96 #define FUJLAPTOP_LOG      ACPI_FUJITSU_HID ": "
97 #define FUJLAPTOP_ERR      KERN_ERR FUJLAPTOP_LOG
98 #define FUJLAPTOP_NOTICE   KERN_NOTICE FUJLAPTOP_LOG
99 #define FUJLAPTOP_INFO     KERN_INFO FUJLAPTOP_LOG
100 #define FUJLAPTOP_DEBUG    KERN_DEBUG FUJLAPTOP_LOG
101
102 #define FUJLAPTOP_DBG_ALL         0xffff
103 #define FUJLAPTOP_DBG_ERROR       0x0001
104 #define FUJLAPTOP_DBG_WARN        0x0002
105 #define FUJLAPTOP_DBG_INFO        0x0004
106 #define FUJLAPTOP_DBG_TRACE       0x0008
107
108 #define dbg_printk(a_dbg_level, format, arg...) \
109         do { if (dbg_level & a_dbg_level) \
110                 printk(FUJLAPTOP_DEBUG "%s: " format, __func__ , ## arg); \
111         } while (0)
112 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
113 #define vdbg_printk(a_dbg_level, format, arg...) \
114         dbg_printk(a_dbg_level, format, ## arg)
115 #else
116 #define vdbg_printk(a_dbg_level, format, arg...)
117 #endif
118
119 /* Device controlling the backlight and associated keys */
120 struct fujitsu_t {
121         acpi_handle acpi_handle;
122         struct acpi_device *dev;
123         struct input_dev *input;
124         char phys[32];
125         struct backlight_device *bl_device;
126         struct platform_device *pf_device;
127         int keycode1, keycode2, keycode3, keycode4;
128
129         unsigned int max_brightness;
130         unsigned int brightness_changed;
131         unsigned int brightness_level;
132 };
133
134 static struct fujitsu_t *fujitsu;
135 static int use_alt_lcd_levels = -1;
136 static int disable_brightness_keys = -1;
137 static int disable_brightness_adjust = -1;
138
139 /* Device used to access other hotkeys on the laptop */
140 struct fujitsu_hotkey_t {
141         acpi_handle acpi_handle;
142         struct acpi_device *dev;
143         struct input_dev *input;
144         char phys[32];
145         struct platform_device *pf_device;
146         struct kfifo *fifo;
147         spinlock_t fifo_lock;
148
149         unsigned int irb;       /* info about the pressed buttons */
150 };
151
152 static struct fujitsu_hotkey_t *fujitsu_hotkey;
153
154 static void acpi_fujitsu_hotkey_notify(acpi_handle handle, u32 event,
155                                        void *data);
156
157 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
158 static u32 dbg_level = 0x03;
159 #endif
160
161 static void acpi_fujitsu_notify(acpi_handle handle, u32 event, void *data);
162
163 /* Hardware access for LCD brightness control */
164
165 static int set_lcd_level(int level)
166 {
167         acpi_status status = AE_OK;
168         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
169         struct acpi_object_list arg_list = { 1, &arg0 };
170         acpi_handle handle = NULL;
171
172         vdbg_printk(FUJLAPTOP_DBG_TRACE, "set lcd level via SBLL [%d]\n",
173                     level);
174
175         if (level < 0 || level >= fujitsu->max_brightness)
176                 return -EINVAL;
177
178         if (!fujitsu)
179                 return -EINVAL;
180
181         status = acpi_get_handle(fujitsu->acpi_handle, "SBLL", &handle);
182         if (ACPI_FAILURE(status)) {
183                 vdbg_printk(FUJLAPTOP_DBG_ERROR, "SBLL not present\n");
184                 return -ENODEV;
185         }
186
187         arg0.integer.value = level;
188
189         status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
190         if (ACPI_FAILURE(status))
191                 return -ENODEV;
192
193         return 0;
194 }
195
196 static int set_lcd_level_alt(int level)
197 {
198         acpi_status status = AE_OK;
199         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
200         struct acpi_object_list arg_list = { 1, &arg0 };
201         acpi_handle handle = NULL;
202
203         vdbg_printk(FUJLAPTOP_DBG_TRACE, "set lcd level via SBL2 [%d]\n",
204                     level);
205
206         if (level < 0 || level >= fujitsu->max_brightness)
207                 return -EINVAL;
208
209         if (!fujitsu)
210                 return -EINVAL;
211
212         status = acpi_get_handle(fujitsu->acpi_handle, "SBL2", &handle);
213         if (ACPI_FAILURE(status)) {
214                 vdbg_printk(FUJLAPTOP_DBG_ERROR, "SBL2 not present\n");
215                 return -ENODEV;
216         }
217
218         arg0.integer.value = level;
219
220         status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
221         if (ACPI_FAILURE(status))
222                 return -ENODEV;
223
224         return 0;
225 }
226
227 static int get_lcd_level(void)
228 {
229         unsigned long long state = 0;
230         acpi_status status = AE_OK;
231
232         vdbg_printk(FUJLAPTOP_DBG_TRACE, "get lcd level via GBLL\n");
233
234         status =
235             acpi_evaluate_integer(fujitsu->acpi_handle, "GBLL", NULL, &state);
236         if (status < 0)
237                 return status;
238
239         fujitsu->brightness_level = state & 0x0fffffff;
240
241         if (state & 0x80000000)
242                 fujitsu->brightness_changed = 1;
243         else
244                 fujitsu->brightness_changed = 0;
245
246         return fujitsu->brightness_level;
247 }
248
249 static int get_max_brightness(void)
250 {
251         unsigned long long state = 0;
252         acpi_status status = AE_OK;
253
254         vdbg_printk(FUJLAPTOP_DBG_TRACE, "get max lcd level via RBLL\n");
255
256         status =
257             acpi_evaluate_integer(fujitsu->acpi_handle, "RBLL", NULL, &state);
258         if (status < 0)
259                 return status;
260
261         fujitsu->max_brightness = state;
262
263         return fujitsu->max_brightness;
264 }
265
266 static int get_lcd_level_alt(void)
267 {
268         unsigned long long state = 0;
269         acpi_status status = AE_OK;
270
271         vdbg_printk(FUJLAPTOP_DBG_TRACE, "get lcd level via GBLS\n");
272
273         status =
274             acpi_evaluate_integer(fujitsu->acpi_handle, "GBLS", NULL, &state);
275         if (status < 0)
276                 return status;
277
278         fujitsu->brightness_level = state & 0x0fffffff;
279
280         if (state & 0x80000000)
281                 fujitsu->brightness_changed = 1;
282         else
283                 fujitsu->brightness_changed = 0;
284
285         return fujitsu->brightness_level;
286 }
287
288 /* Backlight device stuff */
289
290 static int bl_get_brightness(struct backlight_device *b)
291 {
292         if (use_alt_lcd_levels)
293                 return get_lcd_level_alt();
294         else
295                 return get_lcd_level();
296 }
297
298 static int bl_update_status(struct backlight_device *b)
299 {
300         if (use_alt_lcd_levels)
301                 return set_lcd_level_alt(b->props.brightness);
302         else
303                 return set_lcd_level(b->props.brightness);
304 }
305
306 static struct backlight_ops fujitsubl_ops = {
307         .get_brightness = bl_get_brightness,
308         .update_status = bl_update_status,
309 };
310
311 /* Platform LCD brightness device */
312
313 static ssize_t
314 show_max_brightness(struct device *dev,
315                     struct device_attribute *attr, char *buf)
316 {
317
318         int ret;
319
320         ret = get_max_brightness();
321         if (ret < 0)
322                 return ret;
323
324         return sprintf(buf, "%i\n", ret);
325 }
326
327 static ssize_t
328 show_brightness_changed(struct device *dev,
329                         struct device_attribute *attr, char *buf)
330 {
331
332         int ret;
333
334         ret = fujitsu->brightness_changed;
335         if (ret < 0)
336                 return ret;
337
338         return sprintf(buf, "%i\n", ret);
339 }
340
341 static ssize_t show_lcd_level(struct device *dev,
342                               struct device_attribute *attr, char *buf)
343 {
344
345         int ret;
346
347         if (use_alt_lcd_levels)
348                 ret = get_lcd_level_alt();
349         else
350                 ret = get_lcd_level();
351         if (ret < 0)
352                 return ret;
353
354         return sprintf(buf, "%i\n", ret);
355 }
356
357 static ssize_t store_lcd_level(struct device *dev,
358                                struct device_attribute *attr, const char *buf,
359                                size_t count)
360 {
361
362         int level, ret;
363
364         if (sscanf(buf, "%i", &level) != 1
365             || (level < 0 || level >= fujitsu->max_brightness))
366                 return -EINVAL;
367
368         if (use_alt_lcd_levels)
369                 ret = set_lcd_level_alt(level);
370         else
371                 ret = set_lcd_level(level);
372         if (ret < 0)
373                 return ret;
374
375         if (use_alt_lcd_levels)
376                 ret = get_lcd_level_alt();
377         else
378                 ret = get_lcd_level();
379         if (ret < 0)
380                 return ret;
381
382         return count;
383 }
384
385 /* Hardware access for hotkey device */
386
387 static int get_irb(void)
388 {
389         unsigned long long state = 0;
390         acpi_status status = AE_OK;
391
392         vdbg_printk(FUJLAPTOP_DBG_TRACE, "Get irb\n");
393
394         status =
395             acpi_evaluate_integer(fujitsu_hotkey->acpi_handle, "GIRB", NULL,
396                                   &state);
397         if (status < 0)
398                 return status;
399
400         fujitsu_hotkey->irb = state;
401
402         return fujitsu_hotkey->irb;
403 }
404
405 static ssize_t
406 ignore_store(struct device *dev,
407              struct device_attribute *attr, const char *buf, size_t count)
408 {
409         return count;
410 }
411
412 static DEVICE_ATTR(max_brightness, 0444, show_max_brightness, ignore_store);
413 static DEVICE_ATTR(brightness_changed, 0444, show_brightness_changed,
414                    ignore_store);
415 static DEVICE_ATTR(lcd_level, 0644, show_lcd_level, store_lcd_level);
416
417 static struct attribute *fujitsupf_attributes[] = {
418         &dev_attr_brightness_changed.attr,
419         &dev_attr_max_brightness.attr,
420         &dev_attr_lcd_level.attr,
421         NULL
422 };
423
424 static struct attribute_group fujitsupf_attribute_group = {
425         .attrs = fujitsupf_attributes
426 };
427
428 static struct platform_driver fujitsupf_driver = {
429         .driver = {
430                    .name = "fujitsu-laptop",
431                    .owner = THIS_MODULE,
432                    }
433 };
434
435 static void dmi_check_cb_common(const struct dmi_system_id *id)
436 {
437         acpi_handle handle;
438         int have_blnf;
439         printk(KERN_INFO "fujitsu-laptop: Identified laptop model '%s'.\n",
440                id->ident);
441         have_blnf = ACPI_SUCCESS
442             (acpi_get_handle(NULL, "\\_SB.PCI0.GFX0.LCD.BLNF", &handle));
443         if (use_alt_lcd_levels == -1) {
444                 vdbg_printk(FUJLAPTOP_DBG_TRACE, "auto-detecting usealt\n");
445                 use_alt_lcd_levels = 1;
446         }
447         if (disable_brightness_keys == -1) {
448                 vdbg_printk(FUJLAPTOP_DBG_TRACE,
449                             "auto-detecting disable_keys\n");
450                 disable_brightness_keys = have_blnf ? 1 : 0;
451         }
452         if (disable_brightness_adjust == -1) {
453                 vdbg_printk(FUJLAPTOP_DBG_TRACE,
454                             "auto-detecting disable_adjust\n");
455                 disable_brightness_adjust = have_blnf ? 0 : 1;
456         }
457 }
458
459 static int dmi_check_cb_s6410(const struct dmi_system_id *id)
460 {
461         dmi_check_cb_common(id);
462         fujitsu->keycode1 = KEY_SCREENLOCK;     /* "Lock" */
463         fujitsu->keycode2 = KEY_HELP;   /* "Mobility Center" */
464         return 0;
465 }
466
467 static int dmi_check_cb_s6420(const struct dmi_system_id *id)
468 {
469         dmi_check_cb_common(id);
470         fujitsu->keycode1 = KEY_SCREENLOCK;     /* "Lock" */
471         fujitsu->keycode2 = KEY_HELP;   /* "Mobility Center" */
472         return 0;
473 }
474
475 static int dmi_check_cb_p8010(const struct dmi_system_id *id)
476 {
477         dmi_check_cb_common(id);
478         fujitsu->keycode1 = KEY_HELP;   /* "Support" */
479         fujitsu->keycode3 = KEY_SWITCHVIDEOMODE;        /* "Presentation" */
480         fujitsu->keycode4 = KEY_WWW;    /* "Internet" */
481         return 0;
482 }
483
484 static struct dmi_system_id fujitsu_dmi_table[] = {
485         {
486          .ident = "Fujitsu Siemens S6410",
487          .matches = {
488                      DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
489                      DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK S6410"),
490                      },
491          .callback = dmi_check_cb_s6410},
492         {
493          .ident = "Fujitsu Siemens S6420",
494          .matches = {
495                      DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
496                      DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK S6420"),
497                      },
498          .callback = dmi_check_cb_s6420},
499         {
500          .ident = "Fujitsu LifeBook P8010",
501          .matches = {
502                      DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
503                      DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook P8010"),
504                      },
505          .callback = dmi_check_cb_p8010},
506         {}
507 };
508
509 /* ACPI device for LCD brightness control */
510
511 static int acpi_fujitsu_add(struct acpi_device *device)
512 {
513         acpi_status status;
514         acpi_handle handle;
515         int result = 0;
516         int state = 0;
517         struct input_dev *input;
518         int error;
519
520         if (!device)
521                 return -EINVAL;
522
523         fujitsu->acpi_handle = device->handle;
524         sprintf(acpi_device_name(device), "%s", ACPI_FUJITSU_DEVICE_NAME);
525         sprintf(acpi_device_class(device), "%s", ACPI_FUJITSU_CLASS);
526         device->driver_data = fujitsu;
527
528         status = acpi_install_notify_handler(device->handle,
529                                              ACPI_DEVICE_NOTIFY,
530                                              acpi_fujitsu_notify, fujitsu);
531
532         if (ACPI_FAILURE(status)) {
533                 printk(KERN_ERR "Error installing notify handler\n");
534                 error = -ENODEV;
535                 goto err_stop;
536         }
537
538         fujitsu->input = input = input_allocate_device();
539         if (!input) {
540                 error = -ENOMEM;
541                 goto err_uninstall_notify;
542         }
543
544         snprintf(fujitsu->phys, sizeof(fujitsu->phys),
545                  "%s/video/input0", acpi_device_hid(device));
546
547         input->name = acpi_device_name(device);
548         input->phys = fujitsu->phys;
549         input->id.bustype = BUS_HOST;
550         input->id.product = 0x06;
551         input->dev.parent = &device->dev;
552         input->evbit[0] = BIT(EV_KEY);
553         set_bit(KEY_BRIGHTNESSUP, input->keybit);
554         set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
555         set_bit(KEY_UNKNOWN, input->keybit);
556
557         error = input_register_device(input);
558         if (error)
559                 goto err_free_input_dev;
560
561         result = acpi_bus_get_power(fujitsu->acpi_handle, &state);
562         if (result) {
563                 printk(KERN_ERR "Error reading power state\n");
564                 goto end;
565         }
566
567         printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
568                acpi_device_name(device), acpi_device_bid(device),
569                !device->power.state ? "on" : "off");
570
571         fujitsu->dev = device;
572
573         if (ACPI_SUCCESS
574             (acpi_get_handle(device->handle, METHOD_NAME__INI, &handle))) {
575                 vdbg_printk(FUJLAPTOP_DBG_INFO, "Invoking _INI\n");
576                 if (ACPI_FAILURE
577                     (acpi_evaluate_object
578                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
579                         printk(KERN_ERR "_INI Method failed\n");
580         }
581
582         /* do config (detect defaults) */
583         use_alt_lcd_levels = use_alt_lcd_levels == 1 ? 1 : 0;
584         disable_brightness_keys = disable_brightness_keys == 1 ? 1 : 0;
585         disable_brightness_adjust = disable_brightness_adjust == 1 ? 1 : 0;
586         vdbg_printk(FUJLAPTOP_DBG_INFO,
587                     "config: [alt interface: %d], [key disable: %d], [adjust disable: %d]\n",
588                     use_alt_lcd_levels, disable_brightness_keys,
589                     disable_brightness_adjust);
590
591         if (get_max_brightness() <= 0)
592                 fujitsu->max_brightness = FUJITSU_LCD_N_LEVELS;
593         if (use_alt_lcd_levels)
594                 get_lcd_level_alt();
595         else
596                 get_lcd_level();
597
598         return result;
599
600 end:
601 err_free_input_dev:
602         input_free_device(input);
603 err_uninstall_notify:
604         acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
605                                    acpi_fujitsu_notify);
606 err_stop:
607
608         return result;
609 }
610
611 static int acpi_fujitsu_remove(struct acpi_device *device, int type)
612 {
613         acpi_status status;
614         struct fujitsu_t *fujitsu = NULL;
615
616         if (!device || !acpi_driver_data(device))
617                 return -EINVAL;
618
619         fujitsu = acpi_driver_data(device);
620
621         status = acpi_remove_notify_handler(fujitsu->acpi_handle,
622                                             ACPI_DEVICE_NOTIFY,
623                                             acpi_fujitsu_notify);
624
625         if (!device || !acpi_driver_data(device))
626                 return -EINVAL;
627
628         fujitsu->acpi_handle = NULL;
629
630         return 0;
631 }
632
633 /* Brightness notify */
634
635 static void acpi_fujitsu_notify(acpi_handle handle, u32 event, void *data)
636 {
637         struct input_dev *input;
638         int keycode;
639         int oldb, newb;
640
641         input = fujitsu->input;
642
643         switch (event) {
644         case ACPI_FUJITSU_NOTIFY_CODE1:
645                 keycode = 0;
646                 oldb = fujitsu->brightness_level;
647                 get_lcd_level();  /* the alt version always yields changed */
648                 newb = fujitsu->brightness_level;
649
650                 vdbg_printk(FUJLAPTOP_DBG_TRACE,
651                             "brightness button event [%i -> %i (%i)]\n",
652                             oldb, newb, fujitsu->brightness_changed);
653
654                 if (oldb == newb && fujitsu->brightness_changed) {
655                         keycode = 0;
656                         if (disable_brightness_keys != 1) {
657                                 if (oldb == 0) {
658                                         acpi_bus_generate_proc_event
659                                             (fujitsu->dev,
660                                              ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS,
661                                              0);
662                                         keycode = KEY_BRIGHTNESSDOWN;
663                                 } else if (oldb ==
664                                            (fujitsu->max_brightness) - 1) {
665                                         acpi_bus_generate_proc_event
666                                             (fujitsu->dev,
667                                              ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS,
668                                              0);
669                                         keycode = KEY_BRIGHTNESSUP;
670                                 }
671                         }
672                 } else if (oldb < newb) {
673                         if (disable_brightness_adjust != 1) {
674                                 if (use_alt_lcd_levels)
675                                         set_lcd_level_alt(newb);
676                                 else
677                                         set_lcd_level(newb);
678                         }
679                         if (disable_brightness_keys != 1) {
680                                 acpi_bus_generate_proc_event(fujitsu->dev,
681                                         ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS, 0);
682                                 keycode = KEY_BRIGHTNESSUP;
683                         }
684                 } else if (oldb > newb) {
685                         if (disable_brightness_adjust != 1) {
686                                 if (use_alt_lcd_levels)
687                                         set_lcd_level_alt(newb);
688                                 else
689                                         set_lcd_level(newb);
690                         }
691                         if (disable_brightness_keys != 1) {
692                                 acpi_bus_generate_proc_event(fujitsu->dev,
693                                         ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS, 0);
694                                 keycode = KEY_BRIGHTNESSDOWN;
695                         }
696                 } else {
697                         keycode = KEY_UNKNOWN;
698                 }
699                 break;
700         default:
701                 keycode = KEY_UNKNOWN;
702                 vdbg_printk(FUJLAPTOP_DBG_WARN,
703                             "unsupported event [0x%x]\n", event);
704                 break;
705         }
706
707         if (keycode != 0) {
708                 input_report_key(input, keycode, 1);
709                 input_sync(input);
710                 input_report_key(input, keycode, 0);
711                 input_sync(input);
712         }
713
714         return;
715 }
716
717 /* ACPI device for hotkey handling */
718
719 static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
720 {
721         acpi_status status;
722         acpi_handle handle;
723         int result = 0;
724         int state = 0;
725         struct input_dev *input;
726         int error;
727         int i;
728
729         if (!device)
730                 return -EINVAL;
731
732         fujitsu_hotkey->acpi_handle = device->handle;
733         sprintf(acpi_device_name(device), "%s",
734                 ACPI_FUJITSU_HOTKEY_DEVICE_NAME);
735         sprintf(acpi_device_class(device), "%s", ACPI_FUJITSU_CLASS);
736         device->driver_data = fujitsu_hotkey;
737
738         status = acpi_install_notify_handler(device->handle,
739                                              ACPI_DEVICE_NOTIFY,
740                                              acpi_fujitsu_hotkey_notify,
741                                              fujitsu_hotkey);
742
743         if (ACPI_FAILURE(status)) {
744                 printk(KERN_ERR "Error installing notify handler\n");
745                 error = -ENODEV;
746                 goto err_stop;
747         }
748
749         /* kfifo */
750         spin_lock_init(&fujitsu_hotkey->fifo_lock);
751         fujitsu_hotkey->fifo =
752             kfifo_alloc(RINGBUFFERSIZE * sizeof(int), GFP_KERNEL,
753                         &fujitsu_hotkey->fifo_lock);
754         if (IS_ERR(fujitsu_hotkey->fifo)) {
755                 printk(KERN_ERR "kfifo_alloc failed\n");
756                 error = PTR_ERR(fujitsu_hotkey->fifo);
757                 goto err_stop;
758         }
759
760         fujitsu_hotkey->input = input = input_allocate_device();
761         if (!input) {
762                 error = -ENOMEM;
763                 goto err_uninstall_notify;
764         }
765
766         snprintf(fujitsu_hotkey->phys, sizeof(fujitsu_hotkey->phys),
767                  "%s/video/input0", acpi_device_hid(device));
768
769         input->name = acpi_device_name(device);
770         input->phys = fujitsu_hotkey->phys;
771         input->id.bustype = BUS_HOST;
772         input->id.product = 0x06;
773         input->dev.parent = &device->dev;
774         input->evbit[0] = BIT(EV_KEY);
775         set_bit(fujitsu->keycode1, input->keybit);
776         set_bit(fujitsu->keycode2, input->keybit);
777         set_bit(fujitsu->keycode3, input->keybit);
778         set_bit(fujitsu->keycode4, input->keybit);
779         set_bit(KEY_UNKNOWN, input->keybit);
780
781         error = input_register_device(input);
782         if (error)
783                 goto err_free_input_dev;
784
785         result = acpi_bus_get_power(fujitsu_hotkey->acpi_handle, &state);
786         if (result) {
787                 printk(KERN_ERR "Error reading power state\n");
788                 goto end;
789         }
790
791         printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
792                acpi_device_name(device), acpi_device_bid(device),
793                !device->power.state ? "on" : "off");
794
795         fujitsu_hotkey->dev = device;
796
797         if (ACPI_SUCCESS
798             (acpi_get_handle(device->handle, METHOD_NAME__INI, &handle))) {
799                 vdbg_printk(FUJLAPTOP_DBG_INFO, "Invoking _INI\n");
800                 if (ACPI_FAILURE
801                     (acpi_evaluate_object
802                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
803                         printk(KERN_ERR "_INI Method failed\n");
804         }
805
806         i = 0;                  /* Discard hotkey ringbuffer */
807         while (get_irb() != 0 && (i++) < MAX_HOTKEY_RINGBUFFER_SIZE) ;
808         vdbg_printk(FUJLAPTOP_DBG_INFO, "Discarded %i ringbuffer entries\n", i);
809
810         return result;
811
812 end:
813 err_free_input_dev:
814         input_free_device(input);
815 err_uninstall_notify:
816         acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
817                                    acpi_fujitsu_hotkey_notify);
818         kfifo_free(fujitsu_hotkey->fifo);
819 err_stop:
820
821         return result;
822 }
823
824 static int acpi_fujitsu_hotkey_remove(struct acpi_device *device, int type)
825 {
826         acpi_status status;
827         struct fujitsu_hotkey_t *fujitsu_hotkey = NULL;
828
829         if (!device || !acpi_driver_data(device))
830                 return -EINVAL;
831
832         fujitsu_hotkey = acpi_driver_data(device);
833
834         status = acpi_remove_notify_handler(fujitsu_hotkey->acpi_handle,
835                                             ACPI_DEVICE_NOTIFY,
836                                             acpi_fujitsu_hotkey_notify);
837
838         fujitsu_hotkey->acpi_handle = NULL;
839
840         kfifo_free(fujitsu_hotkey->fifo);
841
842         return 0;
843 }
844
845 static void acpi_fujitsu_hotkey_notify(acpi_handle handle, u32 event,
846                                        void *data)
847 {
848         struct input_dev *input;
849         int keycode, keycode_r;
850         unsigned int irb = 1;
851         int i, status;
852
853         input = fujitsu_hotkey->input;
854
855         vdbg_printk(FUJLAPTOP_DBG_TRACE, "Hotkey event\n");
856
857         switch (event) {
858         case ACPI_FUJITSU_NOTIFY_CODE1:
859                 i = 0;
860                 while ((irb = get_irb()) != 0
861                        && (i++) < MAX_HOTKEY_RINGBUFFER_SIZE) {
862                         vdbg_printk(FUJLAPTOP_DBG_TRACE, "GIRB result [%x]\n",
863                                     irb);
864
865                         switch (irb & 0x4ff) {
866                         case KEY1_CODE:
867                                 keycode = fujitsu->keycode1;
868                                 break;
869                         case KEY2_CODE:
870                                 keycode = fujitsu->keycode2;
871                                 break;
872                         case KEY3_CODE:
873                                 keycode = fujitsu->keycode3;
874                                 break;
875                         case KEY4_CODE:
876                                 keycode = fujitsu->keycode4;
877                                 break;
878                         case 0:
879                                 keycode = 0;
880                                 break;
881                         default:
882                                 vdbg_printk(FUJLAPTOP_DBG_WARN,
883                                             "Unknown GIRB result [%x]\n", irb);
884                                 keycode = -1;
885                                 break;
886                         }
887                         if (keycode > 0) {
888                                 vdbg_printk(FUJLAPTOP_DBG_TRACE,
889                                         "Push keycode into ringbuffer [%d]\n",
890                                         keycode);
891                                 status = kfifo_put(fujitsu_hotkey->fifo,
892                                                    (unsigned char *)&keycode,
893                                                    sizeof(keycode));
894                                 if (status != sizeof(keycode)) {
895                                         vdbg_printk(FUJLAPTOP_DBG_WARN,
896                                             "Could not push keycode [0x%x]\n",
897                                             keycode);
898                                 } else {
899                                         input_report_key(input, keycode, 1);
900                                         input_sync(input);
901                                 }
902                         } else if (keycode == 0) {
903                                 while ((status =
904                                         kfifo_get
905                                         (fujitsu_hotkey->fifo, (unsigned char *)
906                                          &keycode_r,
907                                          sizeof
908                                          (keycode_r))) == sizeof(keycode_r)) {
909                                         input_report_key(input, keycode_r, 0);
910                                         input_sync(input);
911                                         vdbg_printk(FUJLAPTOP_DBG_TRACE,
912                                           "Pop keycode from ringbuffer [%d]\n",
913                                           keycode_r);
914                                 }
915                         }
916                 }
917
918                 break;
919         default:
920                 keycode = KEY_UNKNOWN;
921                 vdbg_printk(FUJLAPTOP_DBG_WARN,
922                             "Unsupported event [0x%x]\n", event);
923                 input_report_key(input, keycode, 1);
924                 input_sync(input);
925                 input_report_key(input, keycode, 0);
926                 input_sync(input);
927                 break;
928         }
929
930         return;
931 }
932
933 /* Initialization */
934
935 static const struct acpi_device_id fujitsu_device_ids[] = {
936         {ACPI_FUJITSU_HID, 0},
937         {"", 0},
938 };
939
940 static struct acpi_driver acpi_fujitsu_driver = {
941         .name = ACPI_FUJITSU_DRIVER_NAME,
942         .class = ACPI_FUJITSU_CLASS,
943         .ids = fujitsu_device_ids,
944         .ops = {
945                 .add = acpi_fujitsu_add,
946                 .remove = acpi_fujitsu_remove,
947                 },
948 };
949
950 static const struct acpi_device_id fujitsu_hotkey_device_ids[] = {
951         {ACPI_FUJITSU_HOTKEY_HID, 0},
952         {"", 0},
953 };
954
955 static struct acpi_driver acpi_fujitsu_hotkey_driver = {
956         .name = ACPI_FUJITSU_HOTKEY_DRIVER_NAME,
957         .class = ACPI_FUJITSU_CLASS,
958         .ids = fujitsu_hotkey_device_ids,
959         .ops = {
960                 .add = acpi_fujitsu_hotkey_add,
961                 .remove = acpi_fujitsu_hotkey_remove,
962                 },
963 };
964
965 static int __init fujitsu_init(void)
966 {
967         int ret, result, max_brightness;
968
969         if (acpi_disabled)
970                 return -ENODEV;
971
972         fujitsu = kmalloc(sizeof(struct fujitsu_t), GFP_KERNEL);
973         if (!fujitsu)
974                 return -ENOMEM;
975         memset(fujitsu, 0, sizeof(struct fujitsu_t));
976         fujitsu->keycode1 = KEY_PROG1;
977         fujitsu->keycode2 = KEY_PROG2;
978         fujitsu->keycode3 = KEY_PROG3;
979         fujitsu->keycode4 = KEY_PROG4;
980         dmi_check_system(fujitsu_dmi_table);
981
982         result = acpi_bus_register_driver(&acpi_fujitsu_driver);
983         if (result < 0) {
984                 ret = -ENODEV;
985                 goto fail_acpi;
986         }
987
988         /* Register platform stuff */
989
990         fujitsu->pf_device = platform_device_alloc("fujitsu-laptop", -1);
991         if (!fujitsu->pf_device) {
992                 ret = -ENOMEM;
993                 goto fail_platform_driver;
994         }
995
996         ret = platform_device_add(fujitsu->pf_device);
997         if (ret)
998                 goto fail_platform_device1;
999
1000         ret =
1001             sysfs_create_group(&fujitsu->pf_device->dev.kobj,
1002                                &fujitsupf_attribute_group);
1003         if (ret)
1004                 goto fail_platform_device2;
1005
1006         /* Register backlight stuff */
1007
1008         if (!acpi_video_backlight_support()) {
1009                 fujitsu->bl_device =
1010                         backlight_device_register("fujitsu-laptop", NULL, NULL,
1011                                                   &fujitsubl_ops);
1012                 if (IS_ERR(fujitsu->bl_device))
1013                         return PTR_ERR(fujitsu->bl_device);
1014                 max_brightness = fujitsu->max_brightness;
1015                 fujitsu->bl_device->props.max_brightness = max_brightness - 1;
1016                 fujitsu->bl_device->props.brightness = fujitsu->brightness_level;
1017         }
1018
1019         ret = platform_driver_register(&fujitsupf_driver);
1020         if (ret)
1021                 goto fail_backlight;
1022
1023         /* Register hotkey driver */
1024
1025         fujitsu_hotkey = kmalloc(sizeof(struct fujitsu_hotkey_t), GFP_KERNEL);
1026         if (!fujitsu_hotkey) {
1027                 ret = -ENOMEM;
1028                 goto fail_hotkey;
1029         }
1030         memset(fujitsu_hotkey, 0, sizeof(struct fujitsu_hotkey_t));
1031
1032         result = acpi_bus_register_driver(&acpi_fujitsu_hotkey_driver);
1033         if (result < 0) {
1034                 ret = -ENODEV;
1035                 goto fail_hotkey1;
1036         }
1037
1038         printk(KERN_INFO "fujitsu-laptop: driver " FUJITSU_DRIVER_VERSION
1039                " successfully loaded.\n");
1040
1041         return 0;
1042
1043 fail_hotkey1:
1044
1045         kfree(fujitsu_hotkey);
1046
1047 fail_hotkey:
1048
1049         platform_driver_unregister(&fujitsupf_driver);
1050
1051 fail_backlight:
1052
1053         if (fujitsu->bl_device)
1054                 backlight_device_unregister(fujitsu->bl_device);
1055
1056 fail_platform_device2:
1057
1058         platform_device_del(fujitsu->pf_device);
1059
1060 fail_platform_device1:
1061
1062         platform_device_put(fujitsu->pf_device);
1063
1064 fail_platform_driver:
1065
1066         acpi_bus_unregister_driver(&acpi_fujitsu_driver);
1067
1068 fail_acpi:
1069
1070         kfree(fujitsu);
1071
1072         return ret;
1073 }
1074
1075 static void __exit fujitsu_cleanup(void)
1076 {
1077         sysfs_remove_group(&fujitsu->pf_device->dev.kobj,
1078                            &fujitsupf_attribute_group);
1079         platform_device_unregister(fujitsu->pf_device);
1080         platform_driver_unregister(&fujitsupf_driver);
1081         if (fujitsu->bl_device)
1082                 backlight_device_unregister(fujitsu->bl_device);
1083
1084         acpi_bus_unregister_driver(&acpi_fujitsu_driver);
1085
1086         kfree(fujitsu);
1087
1088         acpi_bus_unregister_driver(&acpi_fujitsu_hotkey_driver);
1089
1090         kfree(fujitsu_hotkey);
1091
1092         printk(KERN_INFO "fujitsu-laptop: driver unloaded.\n");
1093 }
1094
1095 module_init(fujitsu_init);
1096 module_exit(fujitsu_cleanup);
1097
1098 module_param(use_alt_lcd_levels, uint, 0644);
1099 MODULE_PARM_DESC(use_alt_lcd_levels,
1100                  "Use alternative interface for lcd_levels (needed for Lifebook s6410).");
1101 module_param(disable_brightness_keys, uint, 0644);
1102 MODULE_PARM_DESC(disable_brightness_keys,
1103                  "Disable brightness keys (eg. if they are already handled by the generic ACPI_VIDEO device).");
1104 module_param(disable_brightness_adjust, uint, 0644);
1105 MODULE_PARM_DESC(disable_brightness_adjust, "Disable brightness adjustment .");
1106 #ifdef CONFIG_FUJITSU_LAPTOP_DEBUG
1107 module_param_named(debug, dbg_level, uint, 0644);
1108 MODULE_PARM_DESC(debug, "Sets debug level bit-mask");
1109 #endif
1110
1111 MODULE_AUTHOR("Jonathan Woithe, Peter Gruber");
1112 MODULE_DESCRIPTION("Fujitsu laptop extras support");
1113 MODULE_VERSION(FUJITSU_DRIVER_VERSION);
1114 MODULE_LICENSE("GPL");
1115
1116 MODULE_ALIAS("dmi:*:svnFUJITSUSIEMENS:*:pvr:rvnFUJITSU:rnFJNB1D3:*:cvrS6410:*");
1117 MODULE_ALIAS("dmi:*:svnFUJITSU:*:pvr:rvnFUJITSU:rnFJNB19C:*:cvrS7020:*");
1118
1119 static struct pnp_device_id pnp_ids[] = {
1120         {.id = "FUJ02bf"},
1121         {.id = "FUJ02B1"},
1122         {.id = "FUJ02E3"},
1123         {.id = ""}
1124 };
1125
1126 MODULE_DEVICE_TABLE(pnp, pnp_ids);