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