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_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 
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_DIRECTION,
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_DIRECTION,
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 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 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 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);
555