xref: /openbmc/linux/drivers/usb/misc/idmouse.c (revision 20b8c456)
1 // SPDX-License-Identifier: GPL-2.0+
2 /* Siemens ID Mouse driver v0.6
3 
4   Copyright (C) 2004-5 by Florian 'Floe' Echtler  <echtler@fs.tum.de>
5                       and Andreas  'ad'  Deresch <aderesch@fs.tum.de>
6 
7   Derived from the USB Skeleton driver 1.1,
8   Copyright (C) 2003 Greg Kroah-Hartman (greg@kroah.com)
9 
10   Additional information provided by Martin Reising
11   <Martin.Reising@natural-computing.de>
12 
13 */
14 
15 #include <linux/kernel.h>
16 #include <linux/sched/signal.h>
17 #include <linux/errno.h>
18 #include <linux/delay.h>
19 #include <linux/slab.h>
20 #include <linux/module.h>
21 #include <linux/completion.h>
22 #include <linux/mutex.h>
23 #include <linux/uaccess.h>
24 #include <linux/usb.h>
25 
26 /* image constants */
27 #define WIDTH 225
28 #define HEIGHT 289
29 #define HEADER "P5 225 289 255 "
30 #define IMGSIZE ((WIDTH * HEIGHT) + sizeof(HEADER)-1)
31 
32 #define DRIVER_SHORT   "idmouse"
33 #define DRIVER_AUTHOR  "Florian 'Floe' Echtler <echtler@fs.tum.de>"
34 #define DRIVER_DESC    "Siemens ID Mouse FingerTIP Sensor Driver"
35 
36 /* minor number for misc USB devices */
37 #define USB_IDMOUSE_MINOR_BASE 132
38 
39 /* vendor and device IDs */
40 #define ID_SIEMENS 0x0681
41 #define ID_IDMOUSE 0x0005
42 #define ID_CHERRY  0x0010
43 
44 /* device ID table */
45 static const struct usb_device_id idmouse_table[] = {
46 	{USB_DEVICE(ID_SIEMENS, ID_IDMOUSE)}, /* Siemens ID Mouse (Professional) */
47 	{USB_DEVICE(ID_SIEMENS, ID_CHERRY )}, /* Cherry FingerTIP ID Board       */
48 	{}                                    /* terminating null entry          */
49 };
50 
51 /* sensor commands */
52 #define FTIP_RESET   0x20
53 #define FTIP_ACQUIRE 0x21
54 #define FTIP_RELEASE 0x22
55 #define FTIP_BLINK   0x23  /* LSB of value = blink pulse width */
56 #define FTIP_SCROLL  0x24
57 
58 #define ftip_command(dev, command, value, index) \
59 	usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), command, \
60 	USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, value, index, NULL, 0, 1000)
61 
62 MODULE_DEVICE_TABLE(usb, idmouse_table);
63 
64 /* structure to hold all of our device specific stuff */
65 struct usb_idmouse {
66 
67 	struct usb_device *udev; /* save off the usb device pointer */
68 	struct usb_interface *interface; /* the interface for this device */
69 
70 	unsigned char *bulk_in_buffer; /* the buffer to receive data */
71 	size_t bulk_in_size; /* the maximum bulk packet size */
72 	size_t orig_bi_size; /* same as above, but reported by the device */
73 	__u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */
74 
75 	int open; /* if the port is open or not */
76 	int present; /* if the device is not disconnected */
77 	struct mutex lock; /* locks this structure */
78 
79 };
80 
81 /* local function prototypes */
82 static ssize_t idmouse_read(struct file *file, char __user *buffer,
83 				size_t count, loff_t * ppos);
84 
85 static int idmouse_open(struct inode *inode, struct file *file);
86 static int idmouse_release(struct inode *inode, struct file *file);
87 
88 static int idmouse_probe(struct usb_interface *interface,
89 				const struct usb_device_id *id);
90 
91 static void idmouse_disconnect(struct usb_interface *interface);
92 static int idmouse_suspend(struct usb_interface *intf, pm_message_t message);
93 static int idmouse_resume(struct usb_interface *intf);
94 
95 /* file operation pointers */
96 static const struct file_operations idmouse_fops = {
97 	.owner = THIS_MODULE,
98 	.read = idmouse_read,
99 	.open = idmouse_open,
100 	.release = idmouse_release,
101 	.llseek = default_llseek,
102 };
103 
104 /* class driver information */
105 static struct usb_class_driver idmouse_class = {
106 	.name = "idmouse%d",
107 	.fops = &idmouse_fops,
108 	.minor_base = USB_IDMOUSE_MINOR_BASE,
109 };
110 
111 /* usb specific object needed to register this driver with the usb subsystem */
112 static struct usb_driver idmouse_driver = {
113 	.name = DRIVER_SHORT,
114 	.probe = idmouse_probe,
115 	.disconnect = idmouse_disconnect,
116 	.suspend = idmouse_suspend,
117 	.resume = idmouse_resume,
118 	.reset_resume = idmouse_resume,
119 	.id_table = idmouse_table,
120 	.supports_autosuspend = 1,
121 };
122 
idmouse_create_image(struct usb_idmouse * dev)123 static int idmouse_create_image(struct usb_idmouse *dev)
124 {
125 	int bytes_read;
126 	int bulk_read;
127 	int result;
128 
129 	memcpy(dev->bulk_in_buffer, HEADER, sizeof(HEADER)-1);
130 	bytes_read = sizeof(HEADER)-1;
131 
132 	/* reset the device and set a fast blink rate */
133 	result = ftip_command(dev, FTIP_RELEASE, 0, 0);
134 	if (result < 0)
135 		goto reset;
136 	result = ftip_command(dev, FTIP_BLINK,   1, 0);
137 	if (result < 0)
138 		goto reset;
139 
140 	/* initialize the sensor - sending this command twice */
141 	/* significantly reduces the rate of failed reads     */
142 	result = ftip_command(dev, FTIP_ACQUIRE, 0, 0);
143 	if (result < 0)
144 		goto reset;
145 	result = ftip_command(dev, FTIP_ACQUIRE, 0, 0);
146 	if (result < 0)
147 		goto reset;
148 
149 	/* start the readout - sending this command twice */
150 	/* presumably enables the high dynamic range mode */
151 	result = ftip_command(dev, FTIP_RESET,   0, 0);
152 	if (result < 0)
153 		goto reset;
154 	result = ftip_command(dev, FTIP_RESET,   0, 0);
155 	if (result < 0)
156 		goto reset;
157 
158 	/* loop over a blocking bulk read to get data from the device */
159 	while (bytes_read < IMGSIZE) {
160 		result = usb_bulk_msg(dev->udev,
161 				usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
162 				dev->bulk_in_buffer + bytes_read,
163 				dev->bulk_in_size, &bulk_read, 5000);
164 		if (result < 0) {
165 			/* Maybe this error was caused by the increased packet size? */
166 			/* Reset to the original value and tell userspace to retry.  */
167 			if (dev->bulk_in_size != dev->orig_bi_size) {
168 				dev->bulk_in_size = dev->orig_bi_size;
169 				result = -EAGAIN;
170 			}
171 			break;
172 		}
173 		if (signal_pending(current)) {
174 			result = -EINTR;
175 			break;
176 		}
177 		bytes_read += bulk_read;
178 	}
179 
180 	/* check for valid image */
181 	/* right border should be black (0x00) */
182 	for (bytes_read = sizeof(HEADER)-1 + WIDTH-1; bytes_read < IMGSIZE; bytes_read += WIDTH)
183 		if (dev->bulk_in_buffer[bytes_read] != 0x00)
184 			return -EAGAIN;
185 
186 	/* lower border should be white (0xFF) */
187 	for (bytes_read = IMGSIZE-WIDTH; bytes_read < IMGSIZE-1; bytes_read++)
188 		if (dev->bulk_in_buffer[bytes_read] != 0xFF)
189 			return -EAGAIN;
190 
191 	/* reset the device */
192 reset:
193 	ftip_command(dev, FTIP_RELEASE, 0, 0);
194 
195 	/* should be IMGSIZE == 65040 */
196 	dev_dbg(&dev->interface->dev, "read %d bytes fingerprint data\n",
197 		bytes_read);
198 	return result;
199 }
200 
201 /* PM operations are nops as this driver does IO only during open() */
idmouse_suspend(struct usb_interface * intf,pm_message_t message)202 static int idmouse_suspend(struct usb_interface *intf, pm_message_t message)
203 {
204 	return 0;
205 }
206 
idmouse_resume(struct usb_interface * intf)207 static int idmouse_resume(struct usb_interface *intf)
208 {
209 	return 0;
210 }
211 
idmouse_delete(struct usb_idmouse * dev)212 static inline void idmouse_delete(struct usb_idmouse *dev)
213 {
214 	kfree(dev->bulk_in_buffer);
215 	kfree(dev);
216 }
217 
idmouse_open(struct inode * inode,struct file * file)218 static int idmouse_open(struct inode *inode, struct file *file)
219 {
220 	struct usb_idmouse *dev;
221 	struct usb_interface *interface;
222 	int result;
223 
224 	/* get the interface from minor number and driver information */
225 	interface = usb_find_interface(&idmouse_driver, iminor(inode));
226 	if (!interface)
227 		return -ENODEV;
228 
229 	/* get the device information block from the interface */
230 	dev = usb_get_intfdata(interface);
231 	if (!dev)
232 		return -ENODEV;
233 
234 	/* lock this device */
235 	mutex_lock(&dev->lock);
236 
237 	/* check if already open */
238 	if (dev->open) {
239 
240 		/* already open, so fail */
241 		result = -EBUSY;
242 
243 	} else {
244 
245 		/* create a new image and check for success */
246 		result = usb_autopm_get_interface(interface);
247 		if (result)
248 			goto error;
249 		result = idmouse_create_image(dev);
250 		usb_autopm_put_interface(interface);
251 		if (result)
252 			goto error;
253 
254 		/* increment our usage count for the driver */
255 		++dev->open;
256 
257 		/* save our object in the file's private structure */
258 		file->private_data = dev;
259 
260 	}
261 
262 error:
263 
264 	/* unlock this device */
265 	mutex_unlock(&dev->lock);
266 	return result;
267 }
268 
idmouse_release(struct inode * inode,struct file * file)269 static int idmouse_release(struct inode *inode, struct file *file)
270 {
271 	struct usb_idmouse *dev;
272 
273 	dev = file->private_data;
274 
275 	if (dev == NULL)
276 		return -ENODEV;
277 
278 	/* lock our device */
279 	mutex_lock(&dev->lock);
280 
281 	--dev->open;
282 
283 	if (!dev->present) {
284 		/* the device was unplugged before the file was released */
285 		mutex_unlock(&dev->lock);
286 		idmouse_delete(dev);
287 	} else {
288 		mutex_unlock(&dev->lock);
289 	}
290 	return 0;
291 }
292 
idmouse_read(struct file * file,char __user * buffer,size_t count,loff_t * ppos)293 static ssize_t idmouse_read(struct file *file, char __user *buffer, size_t count,
294 				loff_t * ppos)
295 {
296 	struct usb_idmouse *dev = file->private_data;
297 	int result;
298 
299 	/* lock this object */
300 	mutex_lock(&dev->lock);
301 
302 	/* verify that the device wasn't unplugged */
303 	if (!dev->present) {
304 		mutex_unlock(&dev->lock);
305 		return -ENODEV;
306 	}
307 
308 	result = simple_read_from_buffer(buffer, count, ppos,
309 					dev->bulk_in_buffer, IMGSIZE);
310 	/* unlock the device */
311 	mutex_unlock(&dev->lock);
312 	return result;
313 }
314 
idmouse_probe(struct usb_interface * interface,const struct usb_device_id * id)315 static int idmouse_probe(struct usb_interface *interface,
316 				const struct usb_device_id *id)
317 {
318 	struct usb_device *udev = interface_to_usbdev(interface);
319 	struct usb_idmouse *dev;
320 	struct usb_host_interface *iface_desc;
321 	struct usb_endpoint_descriptor *endpoint;
322 	int result;
323 
324 	/* check if we have gotten the data or the hid interface */
325 	iface_desc = interface->cur_altsetting;
326 	if (iface_desc->desc.bInterfaceClass != 0x0A)
327 		return -ENODEV;
328 
329 	if (iface_desc->desc.bNumEndpoints < 1)
330 		return -ENODEV;
331 
332 	/* allocate memory for our device state and initialize it */
333 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
334 	if (dev == NULL)
335 		return -ENOMEM;
336 
337 	mutex_init(&dev->lock);
338 	dev->udev = udev;
339 	dev->interface = interface;
340 
341 	/* set up the endpoint information - use only the first bulk-in endpoint */
342 	result = usb_find_bulk_in_endpoint(iface_desc, &endpoint);
343 	if (result) {
344 		dev_err(&interface->dev, "Unable to find bulk-in endpoint.\n");
345 		idmouse_delete(dev);
346 		return result;
347 	}
348 
349 	dev->orig_bi_size = usb_endpoint_maxp(endpoint);
350 	dev->bulk_in_size = 0x200; /* works _much_ faster */
351 	dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
352 	dev->bulk_in_buffer = kmalloc(IMGSIZE + dev->bulk_in_size, GFP_KERNEL);
353 	if (!dev->bulk_in_buffer) {
354 		idmouse_delete(dev);
355 		return -ENOMEM;
356 	}
357 
358 	/* allow device read, write and ioctl */
359 	dev->present = 1;
360 
361 	/* we can register the device now, as it is ready */
362 	usb_set_intfdata(interface, dev);
363 	result = usb_register_dev(interface, &idmouse_class);
364 	if (result) {
365 		/* something prevented us from registering this device */
366 		dev_err(&interface->dev, "Unable to allocate minor number.\n");
367 		idmouse_delete(dev);
368 		return result;
369 	}
370 
371 	/* be noisy */
372 	dev_info(&interface->dev,"%s now attached\n",DRIVER_DESC);
373 
374 	return 0;
375 }
376 
idmouse_disconnect(struct usb_interface * interface)377 static void idmouse_disconnect(struct usb_interface *interface)
378 {
379 	struct usb_idmouse *dev = usb_get_intfdata(interface);
380 
381 	/* give back our minor */
382 	usb_deregister_dev(interface, &idmouse_class);
383 
384 	/* lock the device */
385 	mutex_lock(&dev->lock);
386 
387 	/* prevent device read, write and ioctl */
388 	dev->present = 0;
389 
390 	/* if the device is opened, idmouse_release will clean this up */
391 	if (!dev->open) {
392 		mutex_unlock(&dev->lock);
393 		idmouse_delete(dev);
394 	} else {
395 		/* unlock */
396 		mutex_unlock(&dev->lock);
397 	}
398 
399 	dev_info(&interface->dev, "disconnected\n");
400 }
401 
402 module_usb_driver(idmouse_driver);
403 
404 MODULE_AUTHOR(DRIVER_AUTHOR);
405 MODULE_DESCRIPTION(DRIVER_DESC);
406 MODULE_LICENSE("GPL");
407 
408