Rantakokko.net

#include

#ifdef CONFIG_USB_DEBUG
#define DEBUG
#else
#undef DEBUG
#endif

#include
#include
#include
#include
#include
#include
#include

/* only an 8 byte buffer necessary for a single packet */
#define ITM_BUFSIZE 8
#define PATH_SIZE 64

#define USB_VENDOR_ID_ITMINC 0x0403
#define USB_PRODUCT_ID_TOUCHPANEL 0xf9e9

#define DRIVER_AUTHOR "Hans-Christian Egtvedt "
#define DRIVER_VERSION "v1.3.2"
#define DRIVER_DESC "USB ITM Inc Touch Panel Driver"
#define DRIVER_LICENSE "GPL"

MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE( DRIVER_LICENSE );

static int swapxy, swapx, swapy;

module_param(swapxy, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
MODULE_PARM_DESC(swapxy, "If set the X- and Y-axis are swapped.");
module_param(swapx, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
MODULE_PARM_DESC(swapx, "If set the X-axis is reversed in direction.");
module_param(swapy, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
MODULE_PARM_DESC(swapy, "If set the Y-axis is reversed in direction.");

struct itmtouch_dev {
struct usb_device *usbdev; /* usb device */
// struct input_dev inputdev; /* input device */
struct input_dev *inputdev; /* input device */
struct urb *readurb; /* urb */
char rbuf[ITM_BUFSIZE]; /* data */
char name[128];
char phys[64];
};

static struct usb_device_id itmtouch_ids [] = {
{ USB_DEVICE(USB_VENDOR_ID_ITMINC, USB_PRODUCT_ID_TOUCHPANEL) },
{ }
};

static void itmtouch_irq(struct urb *urb, struct pt_regs *regs)
{
struct itmtouch_dev *itmtouch = urb->context;
// struct input_dev *dev = &itmtouch->inputdev;
struct input_dev *dev = itmtouch->inputdev;
unsigned int x, y, abs, button;
int retval;
u8 *data;

switch (urb->status) {
case 0:
/* success */
break;
case -ETIMEDOUT:
/* this urb is timing out, device unplugged? */
dbg("%s - urb timed out - was the device unplugged?",
__FUNCTION__);
return;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
/* this urb is terminated, clean up */
dbg("%s - urb shutting down with status: %d",
__FUNCTION__, urb->status);
return;
default:
dbg("%s - nonzero urb status received: %d",
__FUNCTION__, urb->status);
goto exit;
}

data = (u8 *)(urb->transfer_buffer);

if (swapx)
x = (data[1] & 0x1F) << 7 | (data[4] & 0x7F);
else
x = 4096 - ((data[1] & 0x1F) << 7 | (data[4] & 0x7F));

if (swapy)
y = 4096 - ((data[0] & 0x1F) << 7 | (data[3] & 0x7F));
else
y = (data[0] & 0x1F) << 7 | (data[3] & 0x7F);

abs = (data[2] & 0x1) << 7 | (data[5] & 0x7F);

/* Value is 0x80 when pressed and 0xA0 when released */
button = !(data[7] & 0x20);

input_regs(dev, regs);

if (button) {
if (swapxy) {
input_report_abs(dev, ABS_X, y);
input_report_abs(dev, ABS_Y, x);
}
else {
input_report_abs(dev, ABS_X, x);
input_report_abs(dev, ABS_Y, y);
}
}

input_report_abs(dev, ABS_PRESSURE, abs);
input_report_key(dev, BTN_TOUCH, button);

/* If you are experiencing double clicks, turn off "input_sync(dev)". */
input_sync(dev);

exit:
retval = usb_submit_urb(urb, GFP_ATOMIC);
if (retval)
printk(KERN_ERR "%s - usb_submit_urb failed with result: %d",
__FUNCTION__, retval);
}

static int itmtouch_open(struct input_dev *input)
{
struct itmtouch_dev *itmtouch = input->private;

itmtouch->readurb->dev = itmtouch->usbdev;

if (usb_submit_urb(itmtouch->readurb, GFP_KERNEL))
return -EIO;

return 0;
}

static void itmtouch_close(struct input_dev *input)
{
struct itmtouch_dev *itmtouch = input->private;

usb_kill_urb(itmtouch->readurb);
}

static int itmtouch_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct itmtouch_dev *itmtouch;
struct input_dev *input_dev;
struct usb_host_interface *interface;
struct usb_endpoint_descriptor *endpoint;
struct usb_device *udev = interface_to_usbdev(intf);
unsigned int pipe;
unsigned int maxp;
// char path[PATH_SIZE];

interface = intf->cur_altsetting;
endpoint = &interface->endpoint[0].desc;

// if (!(itmtouch = kzalloc(sizeof(struct itmtouch_dev), GFP_KERNEL))) {
itmtouch = kzalloc(sizeof(struct itmtouch_dev), GFP_KERNEL);
input_dev = input_allocate_device();
if (!itmtouch || !input_dev) {
err("%s - Out of memory.", __FUNCTION__);
// return -ENOMEM;
goto fail;
}

itmtouch->usbdev = udev;
itmtouch->inputdev = input_dev;

// itmtouch->inputdev.private = itmtouch;
// itmtouch->inputdev.open = itmtouch_open;
// itmtouch->inputdev.close = itmtouch_close;
//
// usb_make_path(udev, path, PATH_SIZE);
//
// itmtouch->inputdev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
// itmtouch->inputdev.absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
// itmtouch->inputdev.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
//
// itmtouch->inputdev.name = itmtouch->name;
// itmtouch->inputdev.phys = itmtouch->phys;
// usb_to_input_id(udev, &itmtouch->inputdev.id);
// itmtouch->inputdev.dev = &intf->dev;

if (udev->manufacturer)
strlcpy(itmtouch->name, udev->manufacturer, sizeof(itmtouch->name));

if (udev->product) {
if (udev->manufacturer)
strlcat(itmtouch->name, " ", sizeof(itmtouch->name));
strlcat(itmtouch->name, udev->product, sizeof(itmtouch->name));
}

if (!strlen(itmtouch->name))
sprintf(itmtouch->name, "USB ITM touchscreen");

usb_make_path(udev, itmtouch->phys, sizeof(itmtouch->phys));
strlcpy(itmtouch->phys, "/input0", sizeof(itmtouch->phys));

input_dev->name = itmtouch->name;
input_dev->phys = itmtouch->phys;
usb_to_input_id(udev, &input_dev->id);
input_dev->cdev.dev = &intf->dev;
input_dev->private = itmtouch;

input_dev->open = itmtouch_open;
input_dev->close = itmtouch_close;

input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
input_dev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
input_dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);

/* device limits */
/* as specified by the ITM datasheet, X and Y are 12bit,
* Z (pressure) is 8 bit. However, the fields are defined up
* to 14 bits for future possible expansion.
*/
// input_set_abs_params(&itmtouch->inputdev, ABS_X, 0, 0x0FFF, 2, 0);
// input_set_abs_params(&itmtouch->inputdev, ABS_Y, 0, 0x0FFF, 2, 0);
// input_set_abs_params(&itmtouch->inputdev, ABS_PRESSURE, 0, 0xFF, 2, 0);
input_set_abs_params(input_dev, ABS_X, 0, 0x0FFF, 2, 0);
input_set_abs_params(input_dev, ABS_Y, 0, 0x0FFF, 2, 0);
input_set_abs_params(input_dev, ABS_PRESSURE, 0, 0xFF, 2, 0);

/* initialise the URB so we can read from the transport stream */
pipe = usb_rcvintpipe(itmtouch->usbdev, endpoint->bEndpointAddress);
maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));

if (maxp > ITM_BUFSIZE)
maxp = ITM_BUFSIZE;

itmtouch->readurb = usb_alloc_urb(0, GFP_KERNEL);
if (!itmtouch->readurb) {
dbg("%s - usb_alloc_urb failed: itmtouch->readurb", __FUNCTION__);
// kfree(itmtouch);
// return -ENOMEM;
goto fail;
}

usb_fill_int_urb(itmtouch->readurb,
itmtouch->usbdev,
pipe,
itmtouch->rbuf,
maxp,
itmtouch_irq,
itmtouch,
endpoint->bInterval);

// input_register_device(&itmtouch->inputdev);
input_register_device(itmtouch->inputdev);

// printk(KERN_INFO "itmtouch: %s registered on %s\n", itmtouch->name, path);
usb_set_intfdata(intf, itmtouch);

return 0;

fail: input_free_device(input_dev);
kfree(itmtouch);
return -ENOMEM;
}

static void itmtouch_disconnect(struct usb_interface *intf)
{
struct itmtouch_dev *itmtouch = usb_get_intfdata(intf);

usb_set_intfdata(intf, NULL);

if (itmtouch) {
// input_unregister_device(&itmtouch->inputdev);
input_unregister_device(itmtouch->inputdev);

usb_kill_urb(itmtouch->readurb);
usb_free_urb(itmtouch->readurb);
kfree(itmtouch);
}
}

MODULE_DEVICE_TABLE(usb, itmtouch_ids);

static struct usb_driver itmtouch_driver = {
.owner = THIS_MODULE,
.name = "itmtouch",
.probe = itmtouch_probe,
.disconnect = itmtouch_disconnect,
.id_table = itmtouch_ids,
};

static int __init itmtouch_init(void)
{
info(DRIVER_DESC " " DRIVER_VERSION);
info(DRIVER_AUTHOR);
return usb_register(&itmtouch_driver);
}

static void __exit itmtouch_exit(void)
{
usb_deregister(&itmtouch_driver);
}

module_init(itmtouch_init);
module_exit(itmtouch_exit);