GNU Linux-libre 4.9.328-gnu1
[releases.git] / drivers / platform / x86 / fujitsu-tablet.c
1 /*
2  * Copyright (C) 2006-2012 Robert Gerlach <khnz@gmx.de>
3  * Copyright (C) 2005-2006 Jan Rychter <jan@rychter.com>
4  *
5  * You can redistribute and/or modify this program under the terms of the
6  * GNU General Public License version 2 as published by the Free Software
7  * Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
12  * Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 59 Temple Place Suite 330, Boston, MA 02111-1307, USA.
17  */
18
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/bitops.h>
25 #include <linux/io.h>
26 #include <linux/ioport.h>
27 #include <linux/acpi.h>
28 #include <linux/device.h>
29 #include <linux/interrupt.h>
30 #include <linux/input.h>
31 #include <linux/delay.h>
32 #include <linux/dmi.h>
33
34 #define MODULENAME "fujitsu-tablet"
35
36 #define ACPI_FUJITSU_CLASS "fujitsu"
37
38 #define INVERT_TABLET_MODE_BIT      0x01
39 #define INVERT_DOCK_STATE_BIT       0x02
40 #define FORCE_TABLET_MODE_IF_UNDOCK 0x04
41
42 #define KEYMAP_LEN 16
43
44 static const struct acpi_device_id fujitsu_ids[] = {
45         { .id = "FUJ02BD" },
46         { .id = "FUJ02BF" },
47         { .id = "" }
48 };
49
50 struct fujitsu_config {
51         unsigned short keymap[KEYMAP_LEN];
52         unsigned int quirks;
53 };
54
55 static unsigned short keymap_Lifebook_Tseries[KEYMAP_LEN] __initdata = {
56         KEY_RESERVED,
57         KEY_RESERVED,
58         KEY_RESERVED,
59         KEY_RESERVED,
60         KEY_SCROLLDOWN,
61         KEY_SCROLLUP,
62         KEY_ROTATE_DISPLAY,
63         KEY_LEFTCTRL,
64         KEY_BRIGHTNESSUP,
65         KEY_BRIGHTNESSDOWN,
66         KEY_BRIGHTNESS_ZERO,
67         KEY_RESERVED,
68         KEY_RESERVED,
69         KEY_RESERVED,
70         KEY_RESERVED,
71         KEY_LEFTALT
72 };
73
74 static unsigned short keymap_Lifebook_T901[KEYMAP_LEN] __initdata = {
75         KEY_RESERVED,
76         KEY_RESERVED,
77         KEY_RESERVED,
78         KEY_RESERVED,
79         KEY_SCROLLDOWN,
80         KEY_SCROLLUP,
81         KEY_CYCLEWINDOWS,
82         KEY_LEFTCTRL,
83         KEY_RESERVED,
84         KEY_RESERVED,
85         KEY_RESERVED,
86         KEY_RESERVED,
87         KEY_RESERVED,
88         KEY_RESERVED,
89         KEY_RESERVED,
90         KEY_LEFTMETA
91 };
92
93 static unsigned short keymap_Lifebook_T902[KEYMAP_LEN] __initdata = {
94         KEY_RESERVED,
95         KEY_VOLUMEDOWN,
96         KEY_VOLUMEUP,
97         KEY_CYCLEWINDOWS,
98         KEY_PROG1,
99         KEY_PROG2,
100         KEY_LEFTMETA,
101         KEY_RESERVED,
102         KEY_RESERVED,
103         KEY_RESERVED,
104         KEY_RESERVED,
105         KEY_RESERVED,
106         KEY_RESERVED,
107         KEY_RESERVED,
108         KEY_RESERVED,
109         KEY_RESERVED,
110 };
111
112 static unsigned short keymap_Lifebook_U810[KEYMAP_LEN] __initdata = {
113         KEY_RESERVED,
114         KEY_RESERVED,
115         KEY_RESERVED,
116         KEY_RESERVED,
117         KEY_PROG1,
118         KEY_PROG2,
119         KEY_ROTATE_DISPLAY,
120         KEY_RESERVED,
121         KEY_RESERVED,
122         KEY_RESERVED,
123         KEY_UP,
124         KEY_DOWN,
125         KEY_RESERVED,
126         KEY_RESERVED,
127         KEY_LEFTCTRL,
128         KEY_LEFTALT
129 };
130
131 static unsigned short keymap_Stylistic_Tseries[KEYMAP_LEN] __initdata = {
132         KEY_RESERVED,
133         KEY_RESERVED,
134         KEY_RESERVED,
135         KEY_RESERVED,
136         KEY_PRINT,
137         KEY_BACKSPACE,
138         KEY_SPACE,
139         KEY_ENTER,
140         KEY_BRIGHTNESSUP,
141         KEY_BRIGHTNESSDOWN,
142         KEY_DOWN,
143         KEY_UP,
144         KEY_SCROLLUP,
145         KEY_SCROLLDOWN,
146         KEY_LEFTCTRL,
147         KEY_LEFTALT
148 };
149
150 static unsigned short keymap_Stylistic_ST5xxx[KEYMAP_LEN] __initdata = {
151         KEY_RESERVED,
152         KEY_RESERVED,
153         KEY_RESERVED,
154         KEY_RESERVED,
155         KEY_MAIL,
156         KEY_ROTATE_DISPLAY,
157         KEY_ESC,
158         KEY_ENTER,
159         KEY_BRIGHTNESSUP,
160         KEY_BRIGHTNESSDOWN,
161         KEY_DOWN,
162         KEY_UP,
163         KEY_SCROLLUP,
164         KEY_SCROLLDOWN,
165         KEY_LEFTCTRL,
166         KEY_LEFTALT
167 };
168
169 static struct {
170         struct input_dev *idev;
171         struct fujitsu_config config;
172         unsigned long prev_keymask;
173
174         char phys[21];
175
176         int irq;
177         int io_base;
178         int io_length;
179 } fujitsu;
180
181 static u8 fujitsu_ack(void)
182 {
183         return inb(fujitsu.io_base + 2);
184 }
185
186 static u8 fujitsu_status(void)
187 {
188         return inb(fujitsu.io_base + 6);
189 }
190
191 static u8 fujitsu_read_register(const u8 addr)
192 {
193         outb(addr, fujitsu.io_base);
194         return inb(fujitsu.io_base + 4);
195 }
196
197 static void fujitsu_send_state(void)
198 {
199         int state;
200         int dock, tablet_mode;
201
202         state = fujitsu_read_register(0xdd);
203
204         dock = state & 0x02;
205         if (fujitsu.config.quirks & INVERT_DOCK_STATE_BIT)
206                 dock = !dock;
207
208         if ((fujitsu.config.quirks & FORCE_TABLET_MODE_IF_UNDOCK) && (!dock)) {
209                 tablet_mode = 1;
210         } else{
211                 tablet_mode = state & 0x01;
212                 if (fujitsu.config.quirks & INVERT_TABLET_MODE_BIT)
213                         tablet_mode = !tablet_mode;
214         }
215
216         input_report_switch(fujitsu.idev, SW_DOCK, dock);
217         input_report_switch(fujitsu.idev, SW_TABLET_MODE, tablet_mode);
218         input_sync(fujitsu.idev);
219 }
220
221 static void fujitsu_reset(void)
222 {
223         int timeout = 50;
224
225         fujitsu_ack();
226
227         while ((fujitsu_status() & 0x02) && (--timeout))
228                 msleep(20);
229
230         fujitsu_send_state();
231 }
232
233 static int input_fujitsu_setup(struct device *parent, const char *name,
234                                const char *phys)
235 {
236         struct input_dev *idev;
237         int error;
238         int i;
239
240         idev = input_allocate_device();
241         if (!idev)
242                 return -ENOMEM;
243
244         idev->dev.parent = parent;
245         idev->phys = phys;
246         idev->name = name;
247         idev->id.bustype = BUS_HOST;
248         idev->id.vendor  = 0x1734;      /* Fujitsu Siemens Computer GmbH */
249         idev->id.product = 0x0001;
250         idev->id.version = 0x0101;
251
252         idev->keycode = fujitsu.config.keymap;
253         idev->keycodesize = sizeof(fujitsu.config.keymap[0]);
254         idev->keycodemax = ARRAY_SIZE(fujitsu.config.keymap);
255
256         __set_bit(EV_REP, idev->evbit);
257
258         for (i = 0; i < ARRAY_SIZE(fujitsu.config.keymap); i++)
259                 if (fujitsu.config.keymap[i])
260                         input_set_capability(idev, EV_KEY, fujitsu.config.keymap[i]);
261
262         input_set_capability(idev, EV_MSC, MSC_SCAN);
263
264         input_set_capability(idev, EV_SW, SW_DOCK);
265         input_set_capability(idev, EV_SW, SW_TABLET_MODE);
266
267         error = input_register_device(idev);
268         if (error) {
269                 input_free_device(idev);
270                 return error;
271         }
272
273         fujitsu.idev = idev;
274         return 0;
275 }
276
277 static void input_fujitsu_remove(void)
278 {
279         input_unregister_device(fujitsu.idev);
280 }
281
282 static irqreturn_t fujitsu_interrupt(int irq, void *dev_id)
283 {
284         unsigned long keymask, changed;
285         unsigned int keycode;
286         int pressed;
287         int i;
288
289         if (unlikely(!(fujitsu_status() & 0x01)))
290                 return IRQ_NONE;
291
292         fujitsu_send_state();
293
294         keymask  = fujitsu_read_register(0xde);
295         keymask |= fujitsu_read_register(0xdf) << 8;
296         keymask ^= 0xffff;
297
298         changed = keymask ^ fujitsu.prev_keymask;
299         if (changed) {
300                 fujitsu.prev_keymask = keymask;
301
302                 for_each_set_bit(i, &changed, KEYMAP_LEN) {
303                         keycode = fujitsu.config.keymap[i];
304                         pressed = keymask & changed & BIT(i);
305
306                         if (pressed)
307                                 input_event(fujitsu.idev, EV_MSC, MSC_SCAN, i);
308
309                         input_report_key(fujitsu.idev, keycode, pressed);
310                         input_sync(fujitsu.idev);
311                 }
312         }
313
314         fujitsu_ack();
315         return IRQ_HANDLED;
316 }
317
318 static void __init fujitsu_dmi_common(const struct dmi_system_id *dmi)
319 {
320         pr_info("%s\n", dmi->ident);
321         memcpy(fujitsu.config.keymap, dmi->driver_data,
322                         sizeof(fujitsu.config.keymap));
323 }
324
325 static int __init fujitsu_dmi_lifebook(const struct dmi_system_id *dmi)
326 {
327         fujitsu_dmi_common(dmi);
328         fujitsu.config.quirks |= INVERT_TABLET_MODE_BIT;
329         return 1;
330 }
331
332 static int __init fujitsu_dmi_stylistic(const struct dmi_system_id *dmi)
333 {
334         fujitsu_dmi_common(dmi);
335         fujitsu.config.quirks |= FORCE_TABLET_MODE_IF_UNDOCK;
336         fujitsu.config.quirks |= INVERT_DOCK_STATE_BIT;
337         return 1;
338 }
339
340 static const struct dmi_system_id dmi_ids[] __initconst = {
341         {
342                 .callback = fujitsu_dmi_lifebook,
343                 .ident = "Fujitsu Lifebook T901",
344                 .matches = {
345                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
346                         DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook T901")
347                 },
348                 .driver_data = keymap_Lifebook_T901
349         },
350         {
351                 .callback = fujitsu_dmi_lifebook,
352                 .ident = "Fujitsu Lifebook T901",
353                 .matches = {
354                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
355                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T901")
356                 },
357                 .driver_data = keymap_Lifebook_T901
358         },
359         {
360                 .callback = fujitsu_dmi_lifebook,
361                 .ident = "Fujitsu Lifebook T902",
362                 .matches = {
363                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
364                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T902")
365                 },
366                 .driver_data = keymap_Lifebook_T902
367         },
368         {
369                 .callback = fujitsu_dmi_lifebook,
370                 .ident = "Fujitsu Siemens P/T Series",
371                 .matches = {
372                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
373                         DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK")
374                 },
375                 .driver_data = keymap_Lifebook_Tseries
376         },
377         {
378                 .callback = fujitsu_dmi_lifebook,
379                 .ident = "Fujitsu Lifebook T Series",
380                 .matches = {
381                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
382                         DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook T")
383                 },
384                 .driver_data = keymap_Lifebook_Tseries
385         },
386         {
387                 .callback = fujitsu_dmi_stylistic,
388                 .ident = "Fujitsu Siemens Stylistic T Series",
389                 .matches = {
390                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
391                         DMI_MATCH(DMI_PRODUCT_NAME, "Stylistic T")
392                 },
393                 .driver_data = keymap_Stylistic_Tseries
394         },
395         {
396                 .callback = fujitsu_dmi_lifebook,
397                 .ident = "Fujitsu LifeBook U810",
398                 .matches = {
399                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
400                         DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook U810")
401                 },
402                 .driver_data = keymap_Lifebook_U810
403         },
404         {
405                 .callback = fujitsu_dmi_stylistic,
406                 .ident = "Fujitsu Siemens Stylistic ST5xxx Series",
407                 .matches = {
408                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
409                         DMI_MATCH(DMI_PRODUCT_NAME, "STYLISTIC ST5")
410                 },
411                 .driver_data = keymap_Stylistic_ST5xxx
412         },
413         {
414                 .callback = fujitsu_dmi_stylistic,
415                 .ident = "Fujitsu Siemens Stylistic ST5xxx Series",
416                 .matches = {
417                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
418                         DMI_MATCH(DMI_PRODUCT_NAME, "Stylistic ST5")
419                 },
420                 .driver_data = keymap_Stylistic_ST5xxx
421         },
422         {
423                 .callback = fujitsu_dmi_lifebook,
424                 .ident = "Unknown (using defaults)",
425                 .matches = {
426                         DMI_MATCH(DMI_SYS_VENDOR, ""),
427                         DMI_MATCH(DMI_PRODUCT_NAME, "")
428                 },
429                 .driver_data = keymap_Lifebook_Tseries
430         },
431         { NULL }
432 };
433
434 static acpi_status fujitsu_walk_resources(struct acpi_resource *res, void *data)
435 {
436         switch (res->type) {
437         case ACPI_RESOURCE_TYPE_IRQ:
438                 fujitsu.irq = res->data.irq.interrupts[0];
439                 return AE_OK;
440
441         case ACPI_RESOURCE_TYPE_IO:
442                 fujitsu.io_base = res->data.io.minimum;
443                 fujitsu.io_length = res->data.io.address_length;
444                 return AE_OK;
445
446         case ACPI_RESOURCE_TYPE_END_TAG:
447                 if (fujitsu.irq && fujitsu.io_base)
448                         return AE_OK;
449                 else
450                         return AE_NOT_FOUND;
451
452         default:
453                 return AE_ERROR;
454         }
455 }
456
457 static int acpi_fujitsu_add(struct acpi_device *adev)
458 {
459         acpi_status status;
460         int error;
461
462         if (!adev)
463                 return -EINVAL;
464
465         status = acpi_walk_resources(adev->handle, METHOD_NAME__CRS,
466                         fujitsu_walk_resources, NULL);
467         if (ACPI_FAILURE(status) || !fujitsu.irq || !fujitsu.io_base)
468                 return -ENODEV;
469
470         sprintf(acpi_device_name(adev), "Fujitsu %s", acpi_device_hid(adev));
471         sprintf(acpi_device_class(adev), "%s", ACPI_FUJITSU_CLASS);
472
473         snprintf(fujitsu.phys, sizeof(fujitsu.phys),
474                         "%s/input0", acpi_device_hid(adev));
475
476         error = input_fujitsu_setup(&adev->dev,
477                 acpi_device_name(adev), fujitsu.phys);
478         if (error)
479                 return error;
480
481         if (!request_region(fujitsu.io_base, fujitsu.io_length, MODULENAME)) {
482                 input_fujitsu_remove();
483                 return -EBUSY;
484         }
485
486         fujitsu_reset();
487
488         error = request_irq(fujitsu.irq, fujitsu_interrupt,
489                         IRQF_SHARED, MODULENAME, fujitsu_interrupt);
490         if (error) {
491                 release_region(fujitsu.io_base, fujitsu.io_length);
492                 input_fujitsu_remove();
493                 return error;
494         }
495
496         return 0;
497 }
498
499 static int acpi_fujitsu_remove(struct acpi_device *adev)
500 {
501         free_irq(fujitsu.irq, fujitsu_interrupt);
502         release_region(fujitsu.io_base, fujitsu.io_length);
503         input_fujitsu_remove();
504         return 0;
505 }
506
507 #ifdef CONFIG_PM_SLEEP
508 static int acpi_fujitsu_resume(struct device *dev)
509 {
510         fujitsu_reset();
511         return 0;
512 }
513 #endif
514
515 static SIMPLE_DEV_PM_OPS(acpi_fujitsu_pm, NULL, acpi_fujitsu_resume);
516
517 static struct acpi_driver acpi_fujitsu_driver = {
518         .name  = MODULENAME,
519         .class = "hotkey",
520         .ids   = fujitsu_ids,
521         .ops   = {
522                 .add    = acpi_fujitsu_add,
523                 .remove = acpi_fujitsu_remove,
524         },
525         .drv.pm = &acpi_fujitsu_pm,
526 };
527
528 static int __init fujitsu_module_init(void)
529 {
530         int error;
531
532         dmi_check_system(dmi_ids);
533
534         error = acpi_bus_register_driver(&acpi_fujitsu_driver);
535         if (error)
536                 return error;
537
538         return 0;
539 }
540
541 static void __exit fujitsu_module_exit(void)
542 {
543         acpi_bus_unregister_driver(&acpi_fujitsu_driver);
544 }
545
546 module_init(fujitsu_module_init);
547 module_exit(fujitsu_module_exit);
548
549 MODULE_AUTHOR("Robert Gerlach <khnz@gmx.de>");
550 MODULE_DESCRIPTION("Fujitsu tablet pc extras driver");
551 MODULE_LICENSE("GPL");
552 MODULE_VERSION("2.5");
553
554 MODULE_DEVICE_TABLE(acpi, fujitsu_ids);