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 
32 static const struct acpi_device_id fujitsu_ids[] = {
33 	{ .id = "FUJ02BD" },
34 	{ .id = "FUJ02BF" },
35 	{ .id = "" }
36 };
37 
38 struct fujitsu_config {
39 	unsigned short keymap[KEYMAP_LEN];
40 	unsigned int quirks;
41 };
42 
43 static 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 
62 static 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 
81 static 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 
100 static 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 
119 static 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 
138 static 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 
157 static 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 
169 static u8 fujitsu_ack(void)
170 {
171 	return inb(fujitsu.io_base + 2);
172 }
173 
174 static u8 fujitsu_status(void)
175 {
176 	return inb(fujitsu.io_base + 6);
177 }
178 
179 static u8 fujitsu_read_register(const u8 addr)
180 {
181 	outb(addr, fujitsu.io_base);
182 	return inb(fujitsu.io_base + 4);
183 }
184 
185 static 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 
209 static 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 
221 static 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 
265 static void input_fujitsu_remove(void)
266 {
267 	input_unregister_device(fujitsu.idev);
268 }
269 
270 static 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 
306 static 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 
313 static 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 
320 static 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 
328 static 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 
422 static 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 
445 static 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 
487 static int 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 	return 0;
493 }
494 
495 #ifdef CONFIG_PM_SLEEP
496 static int acpi_fujitsu_resume(struct device *dev)
497 {
498 	fujitsu_reset();
499 	return 0;
500 }
501 #endif
502 
503 static SIMPLE_DEV_PM_OPS(acpi_fujitsu_pm, NULL, acpi_fujitsu_resume);
504 
505 static struct acpi_driver acpi_fujitsu_driver = {
506 	.name  = MODULENAME,
507 	.class = "hotkey",
508 	.ids   = fujitsu_ids,
509 	.ops   = {
510 		.add    = acpi_fujitsu_add,
511 		.remove	= acpi_fujitsu_remove,
512 	},
513 	.drv.pm = &acpi_fujitsu_pm,
514 };
515 
516 static int __init fujitsu_module_init(void)
517 {
518 	int error;
519 
520 	dmi_check_system(dmi_ids);
521 
522 	error = acpi_bus_register_driver(&acpi_fujitsu_driver);
523 	if (error)
524 		return error;
525 
526 	return 0;
527 }
528 
529 static void __exit fujitsu_module_exit(void)
530 {
531 	acpi_bus_unregister_driver(&acpi_fujitsu_driver);
532 }
533 
534 module_init(fujitsu_module_init);
535 module_exit(fujitsu_module_exit);
536 
537 MODULE_AUTHOR("Robert Gerlach <khnz@gmx.de>");
538 MODULE_DESCRIPTION("Fujitsu tablet pc extras driver");
539 MODULE_LICENSE("GPL");
540 MODULE_VERSION("2.5");
541 
542 MODULE_DEVICE_TABLE(acpi, fujitsu_ids);
543