Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/hid/hid-elo.c

  1 /*
  2  * HID driver for ELO usb touchscreen 4000/4500
  3  *
  4  * Copyright (c) 2013 Jiri Slaby
  5  *
  6  * Data parsing taken from elousb driver by Vojtech Pavlik.
  7  *
  8  * This driver is licensed under the terms of GPLv2.
  9  */
 10 
 11 #include <linux/hid.h>
 12 #include <linux/input.h>
 13 #include <linux/module.h>
 14 #include <linux/usb.h>
 15 #include <linux/workqueue.h>
 16 
 17 #include "hid-ids.h"
 18 
 19 #define ELO_PERIODIC_READ_INTERVAL      HZ
 20 #define ELO_SMARTSET_CMD_TIMEOUT        2000 /* msec */
 21 
 22 /* Elo SmartSet commands */
 23 #define ELO_FLUSH_SMARTSET_RESPONSES    0x02 /* Flush all pending smartset responses */
 24 #define ELO_SEND_SMARTSET_COMMAND       0x05 /* Send a smartset command */
 25 #define ELO_GET_SMARTSET_RESPONSE       0x06 /* Get a smartset response */
 26 #define ELO_DIAG                        0x64 /* Diagnostics command */
 27 #define ELO_SMARTSET_PACKET_SIZE        8
 28 
 29 struct elo_priv {
 30         struct usb_device *usbdev;
 31         struct delayed_work work;
 32         unsigned char buffer[ELO_SMARTSET_PACKET_SIZE];
 33 };
 34 
 35 static struct workqueue_struct *wq;
 36 static bool use_fw_quirk = true;
 37 module_param(use_fw_quirk, bool, S_IRUGO);
 38 MODULE_PARM_DESC(use_fw_quirk, "Do periodic pokes for broken M firmwares (default = true)");
 39 
 40 static int elo_input_configured(struct hid_device *hdev,
 41                 struct hid_input *hidinput)
 42 {
 43         struct input_dev *input = hidinput->input;
 44 
 45         set_bit(BTN_TOUCH, input->keybit);
 46         set_bit(ABS_PRESSURE, input->absbit);
 47         input_set_abs_params(input, ABS_PRESSURE, 0, 256, 0, 0);
 48 
 49         return 0;
 50 }
 51 
 52 static void elo_process_data(struct input_dev *input, const u8 *data, int size)
 53 {
 54         int press;
 55 
 56         input_report_abs(input, ABS_X, (data[3] << 8) | data[2]);
 57         input_report_abs(input, ABS_Y, (data[5] << 8) | data[4]);
 58 
 59         press = 0;
 60         if (data[1] & 0x80)
 61                 press = (data[7] << 8) | data[6];
 62         input_report_abs(input, ABS_PRESSURE, press);
 63 
 64         if (data[1] & 0x03) {
 65                 input_report_key(input, BTN_TOUCH, 1);
 66                 input_sync(input);
 67         }
 68 
 69         if (data[1] & 0x04)
 70                 input_report_key(input, BTN_TOUCH, 0);
 71 
 72         input_sync(input);
 73 }
 74 
 75 static int elo_raw_event(struct hid_device *hdev, struct hid_report *report,
 76          u8 *data, int size)
 77 {
 78         struct hid_input *hidinput;
 79 
 80         if (!(hdev->claimed & HID_CLAIMED_INPUT) || list_empty(&hdev->inputs))
 81                 return 0;
 82 
 83         hidinput = list_first_entry(&hdev->inputs, struct hid_input, list);
 84 
 85         switch (report->id) {
 86         case 0:
 87                 if (data[0] == 'T') {   /* Mandatory ELO packet marker */
 88                         elo_process_data(hidinput->input, data, size);
 89                         return 1;
 90                 }
 91                 break;
 92         default:        /* unknown report */
 93                 /* Unknown report type; pass upstream */
 94                 hid_info(hdev, "unknown report type %d\n", report->id);
 95                 break;
 96         }
 97 
 98         return 0;
 99 }
100 
101 static int elo_smartset_send_get(struct usb_device *dev, u8 command,
102                 void *data)
103 {
104         unsigned int pipe;
105         u8 dir;
106 
107         if (command == ELO_SEND_SMARTSET_COMMAND) {
108                 pipe = usb_sndctrlpipe(dev, 0);
109                 dir = USB_DIR_OUT;
110         } else if (command == ELO_GET_SMARTSET_RESPONSE) {
111                 pipe = usb_rcvctrlpipe(dev, 0);
112                 dir = USB_DIR_IN;
113         } else
114                 return -EINVAL;
115 
116         return usb_control_msg(dev, pipe, command,
117                         dir | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
118                         0, 0, data, ELO_SMARTSET_PACKET_SIZE,
119                         ELO_SMARTSET_CMD_TIMEOUT);
120 }
121 
122 static int elo_flush_smartset_responses(struct usb_device *dev)
123 {
124         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
125                         ELO_FLUSH_SMARTSET_RESPONSES,
126                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
127                         0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
128 }
129 
130 static void elo_work(struct work_struct *work)
131 {
132         struct elo_priv *priv = container_of(work, struct elo_priv, work.work);
133         struct usb_device *dev = priv->usbdev;
134         unsigned char *buffer = priv->buffer;
135         int ret;
136 
137         ret = elo_flush_smartset_responses(dev);
138         if (ret < 0) {
139                 dev_err(&dev->dev, "initial FLUSH_SMARTSET_RESPONSES failed, error %d\n",
140                                 ret);
141                 goto fail;
142         }
143 
144         /* send Diagnostics command */
145         *buffer = ELO_DIAG;
146         ret = elo_smartset_send_get(dev, ELO_SEND_SMARTSET_COMMAND, buffer);
147         if (ret < 0) {
148                 dev_err(&dev->dev, "send Diagnostics Command failed, error %d\n",
149                                 ret);
150                 goto fail;
151         }
152 
153         /* get the result */
154         ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE, buffer);
155         if (ret < 0) {
156                 dev_err(&dev->dev, "get Diagnostics Command response failed, error %d\n",
157                                 ret);
158                 goto fail;
159         }
160 
161         /* read the ack */
162         if (*buffer != 'A') {
163                 ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE,
164                                 buffer);
165                 if (ret < 0) {
166                         dev_err(&dev->dev, "get acknowledge response failed, error %d\n",
167                                         ret);
168                         goto fail;
169                 }
170         }
171 
172 fail:
173         ret = elo_flush_smartset_responses(dev);
174         if (ret < 0)
175                 dev_err(&dev->dev, "final FLUSH_SMARTSET_RESPONSES failed, error %d\n",
176                                 ret);
177         queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
178 }
179 
180 /*
181  * Not all Elo devices need the periodic HID descriptor reads.
182  * Only firmware version M needs this.
183  */
184 static bool elo_broken_firmware(struct usb_device *dev)
185 {
186         struct usb_device *hub = dev->parent;
187         struct usb_device *child = NULL;
188         u16 fw_lvl = le16_to_cpu(dev->descriptor.bcdDevice);
189         u16 child_vid, child_pid;
190         int i;
191     
192         if (!use_fw_quirk)
193                 return false;
194         if (fw_lvl != 0x10d)
195                 return false;
196 
197         /* iterate sibling devices of the touch controller */
198         usb_hub_for_each_child(hub, i, child) {
199                 child_vid = le16_to_cpu(child->descriptor.idVendor);
200                 child_pid = le16_to_cpu(child->descriptor.idProduct);
201 
202                 /*
203                  * If one of the devices below is present attached as a sibling of 
204                  * the touch controller then  this is a newer IBM 4820 monitor that 
205                  * does not need the IBM-requested workaround if fw level is
206                  * 0x010d - aka 'M'.
207                  * No other HW can have this combination.
208                  */
209                 if (child_vid==0x04b3) {
210                         switch (child_pid) {
211                         case 0x4676: /* 4820 21x Video */
212                         case 0x4677: /* 4820 51x Video */
213                         case 0x4678: /* 4820 2Lx Video */
214                         case 0x4679: /* 4820 5Lx Video */
215                                 return false;
216                         }
217                 }
218         }
219         return true;
220 }
221 
222 static int elo_probe(struct hid_device *hdev, const struct hid_device_id *id)
223 {
224         struct elo_priv *priv;
225         int ret;
226 
227         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
228         if (!priv)
229                 return -ENOMEM;
230 
231         INIT_DELAYED_WORK(&priv->work, elo_work);
232         priv->usbdev = interface_to_usbdev(to_usb_interface(hdev->dev.parent));
233 
234         hid_set_drvdata(hdev, priv);
235 
236         ret = hid_parse(hdev);
237         if (ret) {
238                 hid_err(hdev, "parse failed\n");
239                 goto err_free;
240         }
241 
242         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
243         if (ret) {
244                 hid_err(hdev, "hw start failed\n");
245                 goto err_free;
246         }
247 
248         if (elo_broken_firmware(priv->usbdev)) {
249                 hid_info(hdev, "broken firmware found, installing workaround\n");
250                 queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
251         }
252 
253         return 0;
254 err_free:
255         kfree(priv);
256         return ret;
257 }
258 
259 static void elo_remove(struct hid_device *hdev)
260 {
261         struct elo_priv *priv = hid_get_drvdata(hdev);
262 
263         hid_hw_stop(hdev);
264         cancel_delayed_work_sync(&priv->work);
265         kfree(priv);
266 }
267 
268 static const struct hid_device_id elo_devices[] = {
269         { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009), },
270         { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030), },
271         { }
272 };
273 MODULE_DEVICE_TABLE(hid, elo_devices);
274 
275 static struct hid_driver elo_driver = {
276         .name = "elo",
277         .id_table = elo_devices,
278         .probe = elo_probe,
279         .remove = elo_remove,
280         .raw_event = elo_raw_event,
281         .input_configured = elo_input_configured,
282 };
283 
284 static int __init elo_driver_init(void)
285 {
286         int ret;
287 
288         wq = create_singlethread_workqueue("elousb");
289         if (!wq)
290                 return -ENOMEM;
291 
292         ret = hid_register_driver(&elo_driver);
293         if (ret)
294                 destroy_workqueue(wq);
295 
296         return ret;
297 }
298 module_init(elo_driver_init);
299 
300 static void __exit elo_driver_exit(void)
301 {
302         hid_unregister_driver(&elo_driver);
303         destroy_workqueue(wq);
304 }
305 module_exit(elo_driver_exit);
306 
307 MODULE_AUTHOR("Jiri Slaby <jslaby@suse.cz>");
308 MODULE_LICENSE("GPL");
309 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us