URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [tablet/] [wacom_sys.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * drivers/input/tablet/wacom_sys.c
 *
 *  USB Wacom Graphire and Wacom Intuos tablet support - system specific code
 */
 
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
 
#include "wacom.h"
#include "wacom_wac.h"
 
#define USB_REQ_GET_REPORT      0x01
#define USB_REQ_SET_REPORT      0x09
 
static int usb_get_report(struct usb_interface *intf, unsigned char type,
                                unsigned char id, void *buf, int size)
{
        return usb_control_msg(interface_to_usbdev(intf),
                usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
                USB_REQ_GET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                (type << 8) + id, intf->altsetting[0].desc.bInterfaceNumber,
                buf, size, 100);
}
 
static int usb_set_report(struct usb_interface *intf, unsigned char type,
                                unsigned char id, void *buf, int size)
{
        return usb_control_msg(interface_to_usbdev(intf),
                usb_sndctrlpipe(interface_to_usbdev(intf), 0),
                USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                (type << 8) + id, intf->altsetting[0].desc.bInterfaceNumber,
                buf, size, 1000);
}
 
static struct input_dev * get_input_dev(struct wacom_combo *wcombo)
{
        return wcombo->wacom->dev;
}
 
static void wacom_sys_irq(struct urb *urb)
{
        struct wacom *wacom = urb->context;
        struct wacom_combo wcombo;
        int retval;
 
        switch (urb->status) {
        case 0:
                /* success */
                break;
        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;
        }
 
        wcombo.wacom = wacom;
        wcombo.urb = urb;
 
        if (wacom_wac_irq(wacom->wacom_wac, (void *)&wcombo))
                input_sync(get_input_dev(&wcombo));
 
 exit:
        retval = usb_submit_urb (urb, GFP_ATOMIC);
        if (retval)
                err ("%s - usb_submit_urb failed with result %d",
                     __FUNCTION__, retval);
}
 
void wacom_report_key(void *wcombo, unsigned int key_type, int key_data)
{
        input_report_key(get_input_dev((struct wacom_combo *)wcombo), key_type, key_data);
        return;
}
 
void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data)
{
        input_report_abs(get_input_dev((struct wacom_combo *)wcombo), abs_type, abs_data);
        return;
}
 
void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data)
{
        input_report_rel(get_input_dev((struct wacom_combo *)wcombo), rel_type, rel_data);
        return;
}
 
void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value)
{
        input_event(get_input_dev((struct wacom_combo *)wcombo), type, code, value);
        return;
}
 
__u16 wacom_be16_to_cpu(unsigned char *data)
{
        __u16 value;
        value = be16_to_cpu(*(__be16 *) data);
        return value;
}
 
__u16 wacom_le16_to_cpu(unsigned char *data)
{
        __u16 value;
        value = le16_to_cpu(*(__le16 *) data);
        return value;
}
 
void wacom_input_sync(void *wcombo)
{
        input_sync(get_input_dev((struct wacom_combo *)wcombo));
        return;
}
 
static int wacom_open(struct input_dev *dev)
{
        struct wacom *wacom = input_get_drvdata(dev);
 
        wacom->irq->dev = wacom->usbdev;
        if (usb_submit_urb(wacom->irq, GFP_KERNEL))
                return -EIO;
 
        return 0;
}
 
static void wacom_close(struct input_dev *dev)
{
        struct wacom *wacom = input_get_drvdata(dev);
 
        usb_kill_urb(wacom->irq);
}
 
void input_dev_mo(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_1) |
                BIT_MASK(BTN_5);
        input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
}
 
void input_dev_g4(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->evbit[0] |= BIT_MASK(EV_MSC);
        input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
        input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_0) |
                BIT_MASK(BTN_4);
}
 
void input_dev_g(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->evbit[0] |= BIT_MASK(EV_REL);
        input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
        input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) |
                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
                BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_STYLUS2);
        input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);
}
 
void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
        input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_0) |
                BIT_MASK(BTN_1) | BIT_MASK(BTN_2) | BIT_MASK(BTN_3);
        input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
}
 
void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_4) |
                BIT_MASK(BTN_5) | BIT_MASK(BTN_6) | BIT_MASK(BTN_7);
        input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
}
 
void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->evbit[0] |= BIT_MASK(EV_MSC) | BIT_MASK(EV_REL);
        input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
        input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
        input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) |
                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE) |
                BIT_MASK(BTN_SIDE) | BIT_MASK(BTN_EXTRA);
        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
                BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_TOOL_BRUSH) |
                BIT_MASK(BTN_TOOL_PENCIL) | BIT_MASK(BTN_TOOL_AIRBRUSH) |
                BIT_MASK(BTN_TOOL_LENS) | BIT_MASK(BTN_STYLUS2);
        input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);
        input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
        input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
        input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
        input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
        input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
}
 
void input_dev_pl(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_STYLUS2) |
                BIT_MASK(BTN_TOOL_RUBBER);
}
 
void input_dev_pt(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
{
        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER);
}
 
static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
        struct usb_device *dev = interface_to_usbdev(intf);
        struct usb_endpoint_descriptor *endpoint;
        struct wacom *wacom;
        struct wacom_wac *wacom_wac;
        struct input_dev *input_dev;
        int error = -ENOMEM;
        char rep_data[2], limit = 0;
 
        wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
        wacom_wac = kzalloc(sizeof(struct wacom_wac), GFP_KERNEL);
        input_dev = input_allocate_device();
        if (!wacom || !input_dev || !wacom_wac)
                goto fail1;
 
        wacom_wac->data = usb_buffer_alloc(dev, 10, GFP_KERNEL, &wacom->data_dma);
        if (!wacom_wac->data)
                goto fail1;
 
        wacom->irq = usb_alloc_urb(0, GFP_KERNEL);
        if (!wacom->irq)
                goto fail2;
 
        wacom->usbdev = dev;
        wacom->dev = input_dev;
        usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
        strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
 
        wacom_wac->features = get_wacom_feature(id);
        BUG_ON(wacom_wac->features->pktlen > 10);
 
        input_dev->name = wacom_wac->features->name;
        wacom->wacom_wac = wacom_wac;
        usb_to_input_id(dev, &input_dev->id);
 
        input_dev->dev.parent = &intf->dev;
 
        input_set_drvdata(input_dev, wacom);
 
        input_dev->open = wacom_open;
        input_dev->close = wacom_close;
 
        input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) |
                BIT_MASK(BTN_TOUCH) | BIT_MASK(BTN_STYLUS);
        input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);
        input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);
        input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);
        input_dev->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
 
        wacom_init_input_dev(input_dev, wacom_wac);
 
        endpoint = &intf->cur_altsetting->endpoint[0].desc;
 
        usb_fill_int_urb(wacom->irq, dev,
                         usb_rcvintpipe(dev, endpoint->bEndpointAddress),
                         wacom_wac->data, wacom_wac->features->pktlen,
                         wacom_sys_irq, wacom, endpoint->bInterval);
        wacom->irq->transfer_dma = wacom->data_dma;
        wacom->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
        error = input_register_device(wacom->dev);
        if (error)
                goto fail3;
 
        /* Ask the tablet to report tablet data. Repeat until it succeeds */
        do {
                rep_data[0] = 2;
                rep_data[1] = 2;
                usb_set_report(intf, 3, 2, rep_data, 2);
                usb_get_report(intf, 3, 2, rep_data, 2);
        } while (rep_data[1] != 2 && limit++ < 5);
 
        usb_set_intfdata(intf, wacom);
        return 0;
 
 fail3: usb_free_urb(wacom->irq);
 fail2: usb_buffer_free(dev, 10, wacom_wac->data, wacom->data_dma);
 fail1: input_free_device(input_dev);
        kfree(wacom);
        kfree(wacom_wac);
        return error;
}
 
static void wacom_disconnect(struct usb_interface *intf)
{
        struct wacom *wacom = usb_get_intfdata (intf);
 
        usb_set_intfdata(intf, NULL);
        if (wacom) {
                usb_kill_urb(wacom->irq);
                input_unregister_device(wacom->dev);
                usb_free_urb(wacom->irq);
                usb_buffer_free(interface_to_usbdev(intf), 10, wacom->wacom_wac->data, wacom->data_dma);
                kfree(wacom->wacom_wac);
                kfree(wacom);
        }
}
 
static struct usb_driver wacom_driver = {
        .name =         "wacom",
        .probe =        wacom_probe,
        .disconnect =   wacom_disconnect,
};
 
static int __init wacom_init(void)
{
        int result;
        wacom_driver.id_table = get_device_table();
        result = usb_register(&wacom_driver);
        if (result == 0)
                info(DRIVER_VERSION ":" DRIVER_DESC);
        return result;
}
 
static void __exit wacom_exit(void)
{
        usb_deregister(&wacom_driver);
}
 
module_init(wacom_init);
module_exit(wacom_exit);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [tablet/] [wacom_sys.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* drivers/input/tablet/wacom_sys.c`
3			`*`
4			`* USB Wacom Graphire and Wacom Intuos tablet support - system specific code`
5			`*/`
6
7			`/*`
8			`* This program is free software; you can redistribute it and/or modify`
9			`* it under the terms of the GNU General Public License as published by`
10			`* the Free Software Foundation; either version 2 of the License, or`
11			`* (at your option) any later version.`
12			`*/`
13
14			`#include "wacom.h"`
15			`#include "wacom_wac.h"`
16
17			`#define USB_REQ_GET_REPORT 0x01`
18			`#define USB_REQ_SET_REPORT 0x09`
19
20			`static int usb_get_report(struct usb_interface *intf, unsigned char type,`
21			`unsigned char id, void *buf, int size)`
22			`{`
23			`return usb_control_msg(interface_to_usbdev(intf),`
24			`usb_rcvctrlpipe(interface_to_usbdev(intf), 0),`
25			`USB_REQ_GET_REPORT, USB_TYPE_CLASS \| USB_RECIP_INTERFACE,`
26			`(type << 8) + id, intf->altsetting[0].desc.bInterfaceNumber,`
27			`buf, size, 100);`
28			`}`
29
30			`static int usb_set_report(struct usb_interface *intf, unsigned char type,`
31			`unsigned char id, void *buf, int size)`
32			`{`
33			`return usb_control_msg(interface_to_usbdev(intf),`
34			`usb_sndctrlpipe(interface_to_usbdev(intf), 0),`
35			`USB_REQ_SET_REPORT, USB_TYPE_CLASS \| USB_RECIP_INTERFACE,`
36			`(type << 8) + id, intf->altsetting[0].desc.bInterfaceNumber,`
37			`buf, size, 1000);`
38			`}`
39
40			`static struct input_dev * get_input_dev(struct wacom_combo *wcombo)`
41			`{`
42			`return wcombo->wacom->dev;`
43			`}`
44
45			`static void wacom_sys_irq(struct urb *urb)`
46			`{`
47			`struct wacom *wacom = urb->context;`
48			`struct wacom_combo wcombo;`
49			`int retval;`
50
51			`switch (urb->status) {`
52			`case 0:`
53			`/* success */`
54			`break;`
55			`case -ECONNRESET:`
56			`case -ENOENT:`
57			`case -ESHUTDOWN:`
58			`/* this urb is terminated, clean up */`
59			`dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);`
60			`return;`
61			`default:`
62			`dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);`
63			`goto exit;`
64			`}`
65
66			`wcombo.wacom = wacom;`
67			`wcombo.urb = urb;`
68
69			`if (wacom_wac_irq(wacom->wacom_wac, (void *)&wcombo))`
70			`input_sync(get_input_dev(&wcombo));`
71
72			`exit:`
73			`retval = usb_submit_urb (urb, GFP_ATOMIC);`
74			`if (retval)`
75			`err ("%s - usb_submit_urb failed with result %d",`
76			`__FUNCTION__, retval);`
77			`}`
78
79			`void wacom_report_key(void *wcombo, unsigned int key_type, int key_data)`
80			`{`
81			`input_report_key(get_input_dev((struct wacom_combo *)wcombo), key_type, key_data);`
82			`return;`
83			`}`
84
85			`void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data)`
86			`{`
87			`input_report_abs(get_input_dev((struct wacom_combo *)wcombo), abs_type, abs_data);`
88			`return;`
89			`}`
90
91			`void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data)`
92			`{`
93			`input_report_rel(get_input_dev((struct wacom_combo *)wcombo), rel_type, rel_data);`
94			`return;`
95			`}`
96
97			`void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value)`
98			`{`
99			`input_event(get_input_dev((struct wacom_combo *)wcombo), type, code, value);`
100			`return;`
101			`}`
102
103			`__u16 wacom_be16_to_cpu(unsigned char *data)`
104			`{`
105			`__u16 value;`
106			`value = be16_to_cpu((__be16 ) data);`
107			`return value;`
108			`}`
109
110			`__u16 wacom_le16_to_cpu(unsigned char *data)`
111			`{`
112			`__u16 value;`
113			`value = le16_to_cpu((__le16 ) data);`
114			`return value;`
115			`}`
116
117			`void wacom_input_sync(void *wcombo)`
118			`{`
119			`input_sync(get_input_dev((struct wacom_combo *)wcombo));`
120			`return;`
121			`}`
122
123			`static int wacom_open(struct input_dev *dev)`
124			`{`
125			`struct wacom *wacom = input_get_drvdata(dev);`
126
127			`wacom->irq->dev = wacom->usbdev;`
128			`if (usb_submit_urb(wacom->irq, GFP_KERNEL))`
129			`return -EIO;`
130
131			`return 0;`
132			`}`
133
134			`static void wacom_close(struct input_dev *dev)`
135			`{`
136			`struct wacom *wacom = input_get_drvdata(dev);`
137
138			`usb_kill_urb(wacom->irq);`
139			`}`
140
141			`void input_dev_mo(struct input_dev input_dev, struct wacom_wac wacom_wac)`
142			`{`
143			`input_dev->keybit[BIT_WORD(BTN_LEFT)] \|= BIT_MASK(BTN_1) \|`
144			`BIT_MASK(BTN_5);`
145			`input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);`
146			`}`
147
148			`void input_dev_g4(struct input_dev input_dev, struct wacom_wac wacom_wac)`
149			`{`
150			`input_dev->evbit[0] \|= BIT_MASK(EV_MSC);`
151			`input_dev->mscbit[0] \|= BIT_MASK(MSC_SERIAL);`
152			`input_dev->keybit[BIT_WORD(BTN_DIGI)] \|= BIT_MASK(BTN_TOOL_FINGER);`
153			`input_dev->keybit[BIT_WORD(BTN_LEFT)] \|= BIT_MASK(BTN_0) \|`
154			`BIT_MASK(BTN_4);`
155			`}`
156
157			`void input_dev_g(struct input_dev input_dev, struct wacom_wac wacom_wac)`
158			`{`
159			`input_dev->evbit[0] \|= BIT_MASK(EV_REL);`
160			`input_dev->relbit[0] \|= BIT_MASK(REL_WHEEL);`
161			`input_dev->keybit[BIT_WORD(BTN_LEFT)] \|= BIT_MASK(BTN_LEFT) \|`
162			`BIT_MASK(BTN_RIGHT) \| BIT_MASK(BTN_MIDDLE);`
163			`input_dev->keybit[BIT_WORD(BTN_DIGI)] \|= BIT_MASK(BTN_TOOL_RUBBER) \|`
164			`BIT_MASK(BTN_TOOL_MOUSE) \| BIT_MASK(BTN_STYLUS2);`
165			`input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);`
166			`}`
167
168			`void input_dev_i3s(struct input_dev input_dev, struct wacom_wac wacom_wac)`
169			`{`
170			`input_dev->keybit[BIT_WORD(BTN_DIGI)] \|= BIT_MASK(BTN_TOOL_FINGER);`
171			`input_dev->keybit[BIT_WORD(BTN_LEFT)] \|= BIT_MASK(BTN_0) \|`
172			`BIT_MASK(BTN_1) \| BIT_MASK(BTN_2) \| BIT_MASK(BTN_3);`
173			`input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);`
174			`}`
175
176			`void input_dev_i3(struct input_dev input_dev, struct wacom_wac wacom_wac)`
177			`{`
178			`input_dev->keybit[BIT_WORD(BTN_LEFT)] \|= BIT_MASK(BTN_4) \|`
179			`BIT_MASK(BTN_5) \| BIT_MASK(BTN_6) \| BIT_MASK(BTN_7);`
180			`input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);`
181			`}`
182
183			`void input_dev_i(struct input_dev input_dev, struct wacom_wac wacom_wac)`
184			`{`
185			`input_dev->evbit[0] \|= BIT_MASK(EV_MSC) \| BIT_MASK(EV_REL);`
186			`input_dev->mscbit[0] \|= BIT_MASK(MSC_SERIAL);`
187			`input_dev->relbit[0] \|= BIT_MASK(REL_WHEEL);`
188			`input_dev->keybit[BIT_WORD(BTN_LEFT)] \|= BIT_MASK(BTN_LEFT) \|`
189			`BIT_MASK(BTN_RIGHT) \| BIT_MASK(BTN_MIDDLE) \|`
190			`BIT_MASK(BTN_SIDE) \| BIT_MASK(BTN_EXTRA);`
191			`input_dev->keybit[BIT_WORD(BTN_DIGI)] \|= BIT_MASK(BTN_TOOL_RUBBER) \|`
192			`BIT_MASK(BTN_TOOL_MOUSE) \| BIT_MASK(BTN_TOOL_BRUSH) \|`
193			`BIT_MASK(BTN_TOOL_PENCIL) \| BIT_MASK(BTN_TOOL_AIRBRUSH) \|`
194			`BIT_MASK(BTN_TOOL_LENS) \| BIT_MASK(BTN_STYLUS2);`
195			`input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);`
196			`input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);`
197			`input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);`
198			`input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);`
199			`input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);`
200			`input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);`
201			`}`
202
203			`void input_dev_pl(struct input_dev input_dev, struct wacom_wac wacom_wac)`
204			`{`
205			`input_dev->keybit[BIT_WORD(BTN_DIGI)] \|= BIT_MASK(BTN_STYLUS2) \|`
206			`BIT_MASK(BTN_TOOL_RUBBER);`
207			`}`
208
209			`void input_dev_pt(struct input_dev input_dev, struct wacom_wac wacom_wac)`
210			`{`
211			`input_dev->keybit[BIT_WORD(BTN_DIGI)] \|= BIT_MASK(BTN_TOOL_RUBBER);`
212			`}`
213
214			`static int wacom_probe(struct usb_interface intf, const struct usb_device_id id)`
215			`{`
216			`struct usb_device *dev = interface_to_usbdev(intf);`
217			`struct usb_endpoint_descriptor *endpoint;`
218			`struct wacom *wacom;`
219			`struct wacom_wac *wacom_wac;`
220			`struct input_dev *input_dev;`
221			`int error = -ENOMEM;`
222			`char rep_data[2], limit = 0;`
223
224			`wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);`
225			`wacom_wac = kzalloc(sizeof(struct wacom_wac), GFP_KERNEL);`
226			`input_dev = input_allocate_device();`
227			`if (!wacom \|\| !input_dev \|\| !wacom_wac)`
228			`goto fail1;`
229
230			`wacom_wac->data = usb_buffer_alloc(dev, 10, GFP_KERNEL, &wacom->data_dma);`
231			`if (!wacom_wac->data)`
232			`goto fail1;`
233
234			`wacom->irq = usb_alloc_urb(0, GFP_KERNEL);`
235			`if (!wacom->irq)`
236			`goto fail2;`
237
238			`wacom->usbdev = dev;`
239			`wacom->dev = input_dev;`
240			`usb_make_path(dev, wacom->phys, sizeof(wacom->phys));`
241			`strlcat(wacom->phys, "/input0", sizeof(wacom->phys));`
242
243			`wacom_wac->features = get_wacom_feature(id);`
244			`BUG_ON(wacom_wac->features->pktlen > 10);`
245
246			`input_dev->name = wacom_wac->features->name;`
247			`wacom->wacom_wac = wacom_wac;`
248			`usb_to_input_id(dev, &input_dev->id);`
249
250			`input_dev->dev.parent = &intf->dev;`
251
252			`input_set_drvdata(input_dev, wacom);`
253
254			`input_dev->open = wacom_open;`
255			`input_dev->close = wacom_close;`
256
257			`input_dev->evbit[0] \|= BIT_MASK(EV_KEY) \| BIT_MASK(EV_ABS);`
258			`input_dev->keybit[BIT_WORD(BTN_DIGI)] \|= BIT_MASK(BTN_TOOL_PEN) \|`
259			`BIT_MASK(BTN_TOUCH) \| BIT_MASK(BTN_STYLUS);`
260			`input_set_abs_params(input_dev, ABS_X, 0, wacom_wac->features->x_max, 4, 0);`
261			`input_set_abs_params(input_dev, ABS_Y, 0, wacom_wac->features->y_max, 4, 0);`
262			`input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_wac->features->pressure_max, 0, 0);`
263			`input_dev->absbit[BIT_WORD(ABS_MISC)] \|= BIT_MASK(ABS_MISC);`
264
265			`wacom_init_input_dev(input_dev, wacom_wac);`
266
267			`endpoint = &intf->cur_altsetting->endpoint[0].desc;`
268
269			`usb_fill_int_urb(wacom->irq, dev,`
270			`usb_rcvintpipe(dev, endpoint->bEndpointAddress),`
271			`wacom_wac->data, wacom_wac->features->pktlen,`
272			`wacom_sys_irq, wacom, endpoint->bInterval);`
273			`wacom->irq->transfer_dma = wacom->data_dma;`
274			`wacom->irq->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;`
275
276			`error = input_register_device(wacom->dev);`
277			`if (error)`
278			`goto fail3;`
279
280			`/* Ask the tablet to report tablet data. Repeat until it succeeds */`
281			`do {`
282			`rep_data[0] = 2;`
283			`rep_data[1] = 2;`
284			`usb_set_report(intf, 3, 2, rep_data, 2);`
285			`usb_get_report(intf, 3, 2, rep_data, 2);`
286			`} while (rep_data[1] != 2 && limit++ < 5);`
287
288			`usb_set_intfdata(intf, wacom);`
289			`return 0;`
290
291			`fail3: usb_free_urb(wacom->irq);`
292			`fail2: usb_buffer_free(dev, 10, wacom_wac->data, wacom->data_dma);`
293			`fail1: input_free_device(input_dev);`
294			`kfree(wacom);`
295			`kfree(wacom_wac);`
296			`return error;`
297			`}`
298
299			`static void wacom_disconnect(struct usb_interface *intf)`
300			`{`
301			`struct wacom *wacom = usb_get_intfdata (intf);`
302
303			`usb_set_intfdata(intf, NULL);`
304			`if (wacom) {`
305			`usb_kill_urb(wacom->irq);`
306			`input_unregister_device(wacom->dev);`
307			`usb_free_urb(wacom->irq);`
308			`usb_buffer_free(interface_to_usbdev(intf), 10, wacom->wacom_wac->data, wacom->data_dma);`
309			`kfree(wacom->wacom_wac);`
310			`kfree(wacom);`
311			`}`
312			`}`
313
314			`static struct usb_driver wacom_driver = {`
315			`.name = "wacom",`
316			`.probe = wacom_probe,`
317			`.disconnect = wacom_disconnect,`
318			`};`
319
320			`static int __init wacom_init(void)`
321			`{`
322			`int result;`
323			`wacom_driver.id_table = get_device_table();`
324			`result = usb_register(&wacom_driver);`
325			`if (result == 0)`
326			`info(DRIVER_VERSION ":" DRIVER_DESC);`
327			`return result;`
328			`}`
329
330			`static void __exit wacom_exit(void)`
331			`{`
332			`usb_deregister(&wacom_driver);`
333			`}`
334
335			`module_init(wacom_init);`
336			`module_exit(wacom_exit);`