2 * $Id: tsdev.c,v 1.15 2002/04/10 16:50:19 jsimmons Exp $
4 * Copyright (c) 2001 "Crazy" james Simmons
6 * Compaq touchscreen protocol driver. The protocol emulated by this driver
7 * is obsolete; for new programs use the tslib library which can read directly
8 * from evdev and perform dejittering, variance filtering and calibration -
9 * all in user space, not at kernel level. The meaning of this driver is
10 * to allow usage of newer input drivers with old applications that use the
11 * old /dev/h3600_ts and /dev/h3600_tsraw devices.
13 * 09-Apr-2004: Andrew Zabolotny <zap@homelink.ru>
14 * Fixed to actually work, not just output random numbers.
15 * Added support for both h3600_ts and h3600_tsraw protocol
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU General Public License as published by
22 * the Free Software Foundation; either version 2 of the License, or
23 * (at your option) any later version.
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
30 * You should have received a copy of the GNU General Public License
31 * along with this program; if not, write to the Free Software
32 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 * Should you need to contact me, the author, you can do so either by
35 * e-mail - mail your message to <jsimmons@infradead.org>.
38 #define TSDEV_MINOR_BASE 128
39 #define TSDEV_MINORS 32
40 /* First 16 devices are h3600_ts compatible; second 16 are h3600_tsraw */
41 #define TSDEV_MINOR_MASK 15
42 #define TSDEV_BUFFER_SIZE 64
44 #include <linux/slab.h>
45 #include <linux/poll.h>
46 #include <linux/module.h>
47 #include <linux/moduleparam.h>
48 #include <linux/init.h>
49 #include <linux/input.h>
50 #include <linux/major.h>
51 #include <linux/smp_lock.h>
52 #include <linux/random.h>
53 #include <linux/time.h>
54 #include <linux/device.h>
56 #ifndef CONFIG_INPUT_TSDEV_SCREEN_X
57 #define CONFIG_INPUT_TSDEV_SCREEN_X 240
59 #ifndef CONFIG_INPUT_TSDEV_SCREEN_Y
60 #define CONFIG_INPUT_TSDEV_SCREEN_Y 320
63 /* This driver emulates both protocols of the old h3600_ts and h3600_tsraw
64 * devices. The first one must output X/Y data in 'cooked' format, e.g.
65 * filtered, dejittered and calibrated. Second device just outputs raw
66 * data received from the hardware.
68 * This driver doesn't support filtering and dejittering; it supports only
69 * calibration. Filtering and dejittering must be done in the low-level
70 * driver, if needed, because it may gain additional benefits from knowing
71 * the low-level details, the nature of noise and so on.
73 * The driver precomputes a calibration matrix given the initial xres and
74 * yres values (quite innacurate for most touchscreens) that will result
75 * in a more or less expected range of output values. The driver supports
76 * the TS_SET_CAL ioctl, which will replace the calibration matrix with a
77 * new one, supposedly generated from the values taken from the raw device.
80 MODULE_AUTHOR("James Simmons <jsimmons@transvirtual.com>");
81 MODULE_DESCRIPTION("Input driver to touchscreen converter");
82 MODULE_LICENSE("GPL");
84 static int xres
= CONFIG_INPUT_TSDEV_SCREEN_X
;
85 module_param(xres
, uint
, 0);
86 MODULE_PARM_DESC(xres
, "Horizontal screen resolution (can be negative for X-mirror)");
88 static int yres
= CONFIG_INPUT_TSDEV_SCREEN_Y
;
89 module_param(yres
, uint
, 0);
90 MODULE_PARM_DESC(yres
, "Vertical screen resolution (can be negative for Y-mirror)");
92 /* From Compaq's Touch Screen Specification version 0.2 (draft) */
100 struct ts_calibration
{
113 wait_queue_head_t wait
;
114 struct list_head list
;
115 struct input_handle handle
;
117 struct ts_calibration cal
;
121 struct fasync_struct
*fasync
;
122 struct list_head node
;
125 struct ts_event event
[TSDEV_BUFFER_SIZE
];
129 /* The following ioctl codes are defined ONLY for backward compatibility.
130 * Don't use tsdev for new developement; use the tslib library instead.
131 * Touchscreen calibration is a fully userspace task.
133 /* Use 'f' as magic number */
134 #define IOC_H3600_TS_MAGIC 'f'
135 #define TS_GET_CAL _IOR(IOC_H3600_TS_MAGIC, 10, struct ts_calibration)
136 #define TS_SET_CAL _IOW(IOC_H3600_TS_MAGIC, 11, struct ts_calibration)
138 static struct tsdev
*tsdev_table
[TSDEV_MINORS
/2];
140 static int tsdev_fasync(int fd
, struct file
*file
, int on
)
142 struct tsdev_list
*list
= file
->private_data
;
145 retval
= fasync_helper(fd
, file
, on
, &list
->fasync
);
146 return retval
< 0 ? retval
: 0;
149 static int tsdev_open(struct inode
*inode
, struct file
*file
)
151 int i
= iminor(inode
) - TSDEV_MINOR_BASE
;
152 struct tsdev_list
*list
;
154 if (i
>= TSDEV_MINORS
|| !tsdev_table
[i
& TSDEV_MINOR_MASK
])
157 if (!(list
= kzalloc(sizeof(struct tsdev_list
), GFP_KERNEL
)))
160 list
->raw
= (i
>= TSDEV_MINORS
/2) ? 1 : 0;
162 i
&= TSDEV_MINOR_MASK
;
163 list
->tsdev
= tsdev_table
[i
];
164 list_add_tail(&list
->node
, &tsdev_table
[i
]->list
);
165 file
->private_data
= list
;
167 if (!list
->tsdev
->open
++)
168 if (list
->tsdev
->exist
)
169 input_open_device(&list
->tsdev
->handle
);
173 static void tsdev_free(struct tsdev
*tsdev
)
175 tsdev_table
[tsdev
->minor
] = NULL
;
179 static int tsdev_release(struct inode
*inode
, struct file
*file
)
181 struct tsdev_list
*list
= file
->private_data
;
183 tsdev_fasync(-1, file
, 0);
184 list_del(&list
->node
);
186 if (!--list
->tsdev
->open
) {
187 if (list
->tsdev
->exist
)
188 input_close_device(&list
->tsdev
->handle
);
190 tsdev_free(list
->tsdev
);
196 static ssize_t
tsdev_read(struct file
*file
, char __user
*buffer
, size_t count
,
199 struct tsdev_list
*list
= file
->private_data
;
202 if (list
->head
== list
->tail
&& list
->tsdev
->exist
&& (file
->f_flags
& O_NONBLOCK
))
205 retval
= wait_event_interruptible(list
->tsdev
->wait
,
206 list
->head
!= list
->tail
|| !list
->tsdev
->exist
);
211 if (!list
->tsdev
->exist
)
214 while (list
->head
!= list
->tail
&&
215 retval
+ sizeof (struct ts_event
) <= count
) {
216 if (copy_to_user (buffer
+ retval
, list
->event
+ list
->tail
,
217 sizeof (struct ts_event
)))
219 list
->tail
= (list
->tail
+ 1) & (TSDEV_BUFFER_SIZE
- 1);
220 retval
+= sizeof (struct ts_event
);
226 /* No kernel lock - fine */
227 static unsigned int tsdev_poll(struct file
*file
, poll_table
* wait
)
229 struct tsdev_list
*list
= file
->private_data
;
231 poll_wait(file
, &list
->tsdev
->wait
, wait
);
232 return ((list
->head
== list
->tail
) ? 0 : (POLLIN
| POLLRDNORM
)) |
233 (list
->tsdev
->exist
? 0 : (POLLHUP
| POLLERR
));
236 static int tsdev_ioctl(struct inode
*inode
, struct file
*file
,
237 unsigned int cmd
, unsigned long arg
)
239 struct tsdev_list
*list
= file
->private_data
;
240 struct tsdev
*tsdev
= list
->tsdev
;
245 if (copy_to_user ((void __user
*)arg
, &tsdev
->cal
,
246 sizeof (struct ts_calibration
)))
251 if (copy_from_user (&tsdev
->cal
, (void __user
*)arg
,
252 sizeof (struct ts_calibration
)))
264 static const struct file_operations tsdev_fops
= {
265 .owner
= THIS_MODULE
,
267 .release
= tsdev_release
,
270 .fasync
= tsdev_fasync
,
271 .ioctl
= tsdev_ioctl
,
274 static void tsdev_event(struct input_handle
*handle
, unsigned int type
,
275 unsigned int code
, int value
)
277 struct tsdev
*tsdev
= handle
->private;
278 struct tsdev_list
*list
;
293 if (value
> handle
->dev
->absmax
[ABS_PRESSURE
])
294 value
= handle
->dev
->absmax
[ABS_PRESSURE
];
295 value
-= handle
->dev
->absmin
[ABS_PRESSURE
];
298 tsdev
->pressure
= value
;
309 else if (tsdev
->x
> xres
)
317 else if (tsdev
->y
> yres
)
324 if (code
== BTN_TOUCH
|| code
== BTN_MOUSE
) {
331 if (!tsdev
->pressure
)
339 if (type
!= EV_SYN
|| code
!= SYN_REPORT
)
342 list_for_each_entry(list
, &tsdev
->list
, node
) {
345 do_gettimeofday(&time
);
346 list
->event
[list
->head
].millisecs
= time
.tv_usec
/ 100;
347 list
->event
[list
->head
].pressure
= tsdev
->pressure
;
354 x
= ((x
* tsdev
->cal
.xscale
) >> 8) + tsdev
->cal
.xtrans
;
355 y
= ((y
* tsdev
->cal
.yscale
) >> 8) + tsdev
->cal
.ytrans
;
356 if (tsdev
->cal
.xyswap
) {
357 tmp
= x
; x
= y
; y
= tmp
;
361 list
->event
[list
->head
].x
= x
;
362 list
->event
[list
->head
].y
= y
;
363 list
->head
= (list
->head
+ 1) & (TSDEV_BUFFER_SIZE
- 1);
364 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
366 wake_up_interruptible(&tsdev
->wait
);
369 static struct input_handle
*tsdev_connect(struct input_handler
*handler
,
370 struct input_dev
*dev
,
371 const struct input_device_id
*id
)
374 struct class_device
*cdev
;
377 for (minor
= 0; minor
< TSDEV_MINORS
/ 2 && tsdev_table
[minor
]; minor
++);
378 if (minor
>= TSDEV_MINORS
/ 2) {
380 "tsdev: You have way too many touchscreens\n");
384 if (!(tsdev
= kzalloc(sizeof(struct tsdev
), GFP_KERNEL
)))
387 INIT_LIST_HEAD(&tsdev
->list
);
388 init_waitqueue_head(&tsdev
->wait
);
390 sprintf(tsdev
->name
, "ts%d", minor
);
393 tsdev
->minor
= minor
;
394 tsdev
->handle
.dev
= dev
;
395 tsdev
->handle
.name
= tsdev
->name
;
396 tsdev
->handle
.handler
= handler
;
397 tsdev
->handle
.private = tsdev
;
399 /* Precompute the rough calibration matrix */
400 delta
= dev
->absmax
[ABS_X
] - dev
->absmin
[ABS_X
] + 1;
403 tsdev
->cal
.xscale
= (xres
<< 8) / delta
;
404 tsdev
->cal
.xtrans
= - ((dev
->absmin
[ABS_X
] * tsdev
->cal
.xscale
) >> 8);
406 delta
= dev
->absmax
[ABS_Y
] - dev
->absmin
[ABS_Y
] + 1;
409 tsdev
->cal
.yscale
= (yres
<< 8) / delta
;
410 tsdev
->cal
.ytrans
= - ((dev
->absmin
[ABS_Y
] * tsdev
->cal
.yscale
) >> 8);
412 tsdev_table
[minor
] = tsdev
;
414 cdev
= class_device_create(&input_class
, &dev
->cdev
,
415 MKDEV(INPUT_MAJOR
, TSDEV_MINOR_BASE
+ minor
),
416 dev
->cdev
.dev
, tsdev
->name
);
418 /* temporary symlink to keep userspace happy */
419 sysfs_create_link(&input_class
.subsys
.kset
.kobj
, &cdev
->kobj
,
422 return &tsdev
->handle
;
425 static void tsdev_disconnect(struct input_handle
*handle
)
427 struct tsdev
*tsdev
= handle
->private;
428 struct tsdev_list
*list
;
430 sysfs_remove_link(&input_class
.subsys
.kset
.kobj
, tsdev
->name
);
431 class_device_destroy(&input_class
,
432 MKDEV(INPUT_MAJOR
, TSDEV_MINOR_BASE
+ tsdev
->minor
));
436 input_close_device(handle
);
437 wake_up_interruptible(&tsdev
->wait
);
438 list_for_each_entry(list
, &tsdev
->list
, node
)
439 kill_fasync(&list
->fasync
, SIGIO
, POLL_HUP
);
444 static const struct input_device_id tsdev_ids
[] = {
446 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_RELBIT
,
447 .evbit
= { BIT(EV_KEY
) | BIT(EV_REL
) },
448 .keybit
= { [LONG(BTN_LEFT
)] = BIT(BTN_LEFT
) },
449 .relbit
= { BIT(REL_X
) | BIT(REL_Y
) },
450 }, /* A mouse like device, at least one button, two relative axes */
453 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_ABSBIT
,
454 .evbit
= { BIT(EV_KEY
) | BIT(EV_ABS
) },
455 .keybit
= { [LONG(BTN_TOUCH
)] = BIT(BTN_TOUCH
) },
456 .absbit
= { BIT(ABS_X
) | BIT(ABS_Y
) },
457 }, /* A tablet like device, at least touch detection, two absolute axes */
460 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
| INPUT_DEVICE_ID_MATCH_ABSBIT
,
461 .evbit
= { BIT(EV_ABS
) },
462 .absbit
= { BIT(ABS_X
) | BIT(ABS_Y
) | BIT(ABS_PRESSURE
) },
463 }, /* A tablet like device with several gradations of pressure */
465 {} /* Terminating entry */
468 MODULE_DEVICE_TABLE(input
, tsdev_ids
);
470 static struct input_handler tsdev_handler
= {
471 .event
= tsdev_event
,
472 .connect
= tsdev_connect
,
473 .disconnect
= tsdev_disconnect
,
475 .minor
= TSDEV_MINOR_BASE
,
477 .id_table
= tsdev_ids
,
480 static int __init
tsdev_init(void)
482 return input_register_handler(&tsdev_handler
);
485 static void __exit
tsdev_exit(void)
487 input_unregister_handler(&tsdev_handler
);
490 module_init(tsdev_init
);
491 module_exit(tsdev_exit
);