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