xref: /openbmc/linux/drivers/usb/serial/cyberjack.c (revision b6dcefde)
1 /*
2  *  REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver
3  *
4  *  Copyright (C) 2001  REINER SCT
5  *  Author: Matthias Bruestle
6  *
7  *  Contact: support@reiner-sct.com (see MAINTAINERS)
8  *
9  *  This program is largely derived from work by the linux-usb group
10  *  and associated source files.  Please see the usb/serial files for
11  *  individual credits and copyrights.
12  *
13  *  This program is free software; you can redistribute it and/or modify
14  *  it under the terms of the GNU General Public License as published by
15  *  the Free Software Foundation; either version 2 of the License, or
16  *  (at your option) any later version.
17  *
18  *  Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and
19  *  patience.
20  *
21  *  In case of problems, please write to the contact e-mail address
22  *  mentioned above.
23  *
24  *  Please note that later models of the cyberjack reader family are
25  *  supported by a libusb-based userspace device driver.
26  *
27  *  Homepage: http://www.reiner-sct.de/support/treiber_cyberjack.php#linux
28  */
29 
30 
31 #include <linux/kernel.h>
32 #include <linux/errno.h>
33 #include <linux/init.h>
34 #include <linux/slab.h>
35 #include <linux/tty.h>
36 #include <linux/tty_driver.h>
37 #include <linux/tty_flip.h>
38 #include <linux/module.h>
39 #include <linux/spinlock.h>
40 #include <linux/uaccess.h>
41 #include <linux/usb.h>
42 #include <linux/usb/serial.h>
43 
44 #define CYBERJACK_LOCAL_BUF_SIZE 32
45 
46 static int debug;
47 
48 /*
49  * Version Information
50  */
51 #define DRIVER_VERSION "v1.01"
52 #define DRIVER_AUTHOR "Matthias Bruestle"
53 #define DRIVER_DESC "REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver"
54 
55 
56 #define CYBERJACK_VENDOR_ID	0x0C4B
57 #define CYBERJACK_PRODUCT_ID	0x0100
58 
59 /* Function prototypes */
60 static int cyberjack_startup(struct usb_serial *serial);
61 static void cyberjack_disconnect(struct usb_serial *serial);
62 static void cyberjack_release(struct usb_serial *serial);
63 static int  cyberjack_open(struct tty_struct *tty,
64 	struct usb_serial_port *port);
65 static void cyberjack_close(struct usb_serial_port *port);
66 static int cyberjack_write(struct tty_struct *tty,
67 	struct usb_serial_port *port, const unsigned char *buf, int count);
68 static int cyberjack_write_room(struct tty_struct *tty);
69 static void cyberjack_read_int_callback(struct urb *urb);
70 static void cyberjack_read_bulk_callback(struct urb *urb);
71 static void cyberjack_write_bulk_callback(struct urb *urb);
72 
73 static struct usb_device_id id_table [] = {
74 	{ USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
75 	{ }			/* Terminating entry */
76 };
77 
78 MODULE_DEVICE_TABLE(usb, id_table);
79 
80 static struct usb_driver cyberjack_driver = {
81 	.name =		"cyberjack",
82 	.probe =	usb_serial_probe,
83 	.disconnect =	usb_serial_disconnect,
84 	.id_table =	id_table,
85 	.no_dynamic_id = 	1,
86 };
87 
88 static struct usb_serial_driver cyberjack_device = {
89 	.driver = {
90 		.owner =	THIS_MODULE,
91 		.name =		"cyberjack",
92 	},
93 	.description =		"Reiner SCT Cyberjack USB card reader",
94 	.usb_driver = 		&cyberjack_driver,
95 	.id_table =		id_table,
96 	.num_ports =		1,
97 	.attach =		cyberjack_startup,
98 	.disconnect =		cyberjack_disconnect,
99 	.release =		cyberjack_release,
100 	.open =			cyberjack_open,
101 	.close =		cyberjack_close,
102 	.write =		cyberjack_write,
103 	.write_room =		cyberjack_write_room,
104 	.read_int_callback =	cyberjack_read_int_callback,
105 	.read_bulk_callback =	cyberjack_read_bulk_callback,
106 	.write_bulk_callback =	cyberjack_write_bulk_callback,
107 };
108 
109 struct cyberjack_private {
110 	spinlock_t	lock;		/* Lock for SMP */
111 	short		rdtodo;		/* Bytes still to read */
112 	unsigned char	wrbuf[5*64];	/* Buffer for collecting data to write */
113 	short		wrfilled;	/* Overall data size we already got */
114 	short		wrsent;		/* Data already sent */
115 };
116 
117 /* do some startup allocations not currently performed by usb_serial_probe() */
118 static int cyberjack_startup(struct usb_serial *serial)
119 {
120 	struct cyberjack_private *priv;
121 	int i;
122 
123 	dbg("%s", __func__);
124 
125 	/* allocate the private data structure */
126 	priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL);
127 	if (!priv)
128 		return -ENOMEM;
129 
130 	/* set initial values */
131 	spin_lock_init(&priv->lock);
132 	priv->rdtodo = 0;
133 	priv->wrfilled = 0;
134 	priv->wrsent = 0;
135 	usb_set_serial_port_data(serial->port[0], priv);
136 
137 	init_waitqueue_head(&serial->port[0]->write_wait);
138 
139 	for (i = 0; i < serial->num_ports; ++i) {
140 		int result;
141 		serial->port[i]->interrupt_in_urb->dev = serial->dev;
142 		result = usb_submit_urb(serial->port[i]->interrupt_in_urb,
143 					GFP_KERNEL);
144 		if (result)
145 			dev_err(&serial->dev->dev,
146 				"usb_submit_urb(read int) failed\n");
147 		dbg("%s - usb_submit_urb(int urb)", __func__);
148 	}
149 
150 	return 0;
151 }
152 
153 static void cyberjack_disconnect(struct usb_serial *serial)
154 {
155 	int i;
156 
157 	dbg("%s", __func__);
158 
159 	for (i = 0; i < serial->num_ports; ++i)
160 		usb_kill_urb(serial->port[i]->interrupt_in_urb);
161 }
162 
163 static void cyberjack_release(struct usb_serial *serial)
164 {
165 	int i;
166 
167 	dbg("%s", __func__);
168 
169 	for (i = 0; i < serial->num_ports; ++i) {
170 		/* My special items, the standard routines free my urbs */
171 		kfree(usb_get_serial_port_data(serial->port[i]));
172 	}
173 }
174 
175 static int  cyberjack_open(struct tty_struct *tty,
176 					struct usb_serial_port *port)
177 {
178 	struct cyberjack_private *priv;
179 	unsigned long flags;
180 	int result = 0;
181 
182 	dbg("%s - port %d", __func__, port->number);
183 
184 	dbg("%s - usb_clear_halt", __func__);
185 	usb_clear_halt(port->serial->dev, port->write_urb->pipe);
186 
187 	priv = usb_get_serial_port_data(port);
188 	spin_lock_irqsave(&priv->lock, flags);
189 	priv->rdtodo = 0;
190 	priv->wrfilled = 0;
191 	priv->wrsent = 0;
192 	spin_unlock_irqrestore(&priv->lock, flags);
193 
194 	return result;
195 }
196 
197 static void cyberjack_close(struct usb_serial_port *port)
198 {
199 	dbg("%s - port %d", __func__, port->number);
200 
201 	if (port->serial->dev) {
202 		/* shutdown any bulk reads that might be going on */
203 		usb_kill_urb(port->write_urb);
204 		usb_kill_urb(port->read_urb);
205 	}
206 }
207 
208 static int cyberjack_write(struct tty_struct *tty,
209 	struct usb_serial_port *port, const unsigned char *buf, int count)
210 {
211 	struct usb_serial *serial = port->serial;
212 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
213 	unsigned long flags;
214 	int result;
215 	int wrexpected;
216 
217 	dbg("%s - port %d", __func__, port->number);
218 
219 	if (count == 0) {
220 		dbg("%s - write request of 0 bytes", __func__);
221 		return 0;
222 	}
223 
224 	spin_lock_bh(&port->lock);
225 	if (port->write_urb_busy) {
226 		spin_unlock_bh(&port->lock);
227 		dbg("%s - already writing", __func__);
228 		return 0;
229 	}
230 	port->write_urb_busy = 1;
231 	spin_unlock_bh(&port->lock);
232 
233 	spin_lock_irqsave(&priv->lock, flags);
234 
235 	if (count+priv->wrfilled > sizeof(priv->wrbuf)) {
236 		/* To much data for buffer. Reset buffer. */
237 		priv->wrfilled = 0;
238 		port->write_urb_busy = 0;
239 		spin_unlock_irqrestore(&priv->lock, flags);
240 		return 0;
241 	}
242 
243 	/* Copy data */
244 	memcpy(priv->wrbuf + priv->wrfilled, buf, count);
245 
246 	usb_serial_debug_data(debug, &port->dev, __func__, count,
247 		priv->wrbuf + priv->wrfilled);
248 	priv->wrfilled += count;
249 
250 	if (priv->wrfilled >= 3) {
251 		wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
252 		dbg("%s - expected data: %d", __func__, wrexpected);
253 	} else
254 		wrexpected = sizeof(priv->wrbuf);
255 
256 	if (priv->wrfilled >= wrexpected) {
257 		/* We have enough data to begin transmission */
258 		int length;
259 
260 		dbg("%s - transmitting data (frame 1)", __func__);
261 		length = (wrexpected > port->bulk_out_size) ?
262 					port->bulk_out_size : wrexpected;
263 
264 		memcpy(port->write_urb->transfer_buffer, priv->wrbuf, length);
265 		priv->wrsent = length;
266 
267 		/* set up our urb */
268 		usb_fill_bulk_urb(port->write_urb, serial->dev,
269 			      usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
270 			      port->write_urb->transfer_buffer, length,
271 			      ((serial->type->write_bulk_callback) ?
272 			       serial->type->write_bulk_callback :
273 			       cyberjack_write_bulk_callback),
274 			      port);
275 
276 		/* send the data out the bulk port */
277 		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
278 		if (result) {
279 			dev_err(&port->dev,
280 				"%s - failed submitting write urb, error %d",
281 				__func__, result);
282 			/* Throw away data. No better idea what to do with it. */
283 			priv->wrfilled = 0;
284 			priv->wrsent = 0;
285 			spin_unlock_irqrestore(&priv->lock, flags);
286 			port->write_urb_busy = 0;
287 			return 0;
288 		}
289 
290 		dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
291 		dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);
292 
293 		if (priv->wrsent >= priv->wrfilled) {
294 			dbg("%s - buffer cleaned", __func__);
295 			memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
296 			priv->wrfilled = 0;
297 			priv->wrsent = 0;
298 		}
299 	}
300 
301 	spin_unlock_irqrestore(&priv->lock, flags);
302 
303 	return count;
304 }
305 
306 static int cyberjack_write_room(struct tty_struct *tty)
307 {
308 	/* FIXME: .... */
309 	return CYBERJACK_LOCAL_BUF_SIZE;
310 }
311 
312 static void cyberjack_read_int_callback(struct urb *urb)
313 {
314 	struct usb_serial_port *port = urb->context;
315 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
316 	unsigned char *data = urb->transfer_buffer;
317 	int status = urb->status;
318 	int result;
319 
320 	dbg("%s - port %d", __func__, port->number);
321 
322 	/* the urb might have been killed. */
323 	if (status)
324 		return;
325 
326 	usb_serial_debug_data(debug, &port->dev, __func__,
327 						urb->actual_length, data);
328 
329 	/* React only to interrupts signaling a bulk_in transfer */
330 	if (urb->actual_length == 4 && data[0] == 0x01) {
331 		short old_rdtodo;
332 
333 		/* This is a announcement of coming bulk_ins. */
334 		unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3;
335 
336 		spin_lock(&priv->lock);
337 
338 		old_rdtodo = priv->rdtodo;
339 
340 		if (old_rdtodo + size < old_rdtodo) {
341 			dbg("To many bulk_in urbs to do.");
342 			spin_unlock(&priv->lock);
343 			goto resubmit;
344 		}
345 
346 		/* "+=" is probably more fault tollerant than "=" */
347 		priv->rdtodo += size;
348 
349 		dbg("%s - rdtodo: %d", __func__, priv->rdtodo);
350 
351 		spin_unlock(&priv->lock);
352 
353 		if (!old_rdtodo) {
354 			port->read_urb->dev = port->serial->dev;
355 			result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
356 			if (result)
357 				dev_err(&port->dev, "%s - failed resubmitting "
358 					"read urb, error %d\n",
359 					__func__, result);
360 			dbg("%s - usb_submit_urb(read urb)", __func__);
361 		}
362 	}
363 
364 resubmit:
365 	port->interrupt_in_urb->dev = port->serial->dev;
366 	result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
367 	if (result)
368 		dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
369 	dbg("%s - usb_submit_urb(int urb)", __func__);
370 }
371 
372 static void cyberjack_read_bulk_callback(struct urb *urb)
373 {
374 	struct usb_serial_port *port = urb->context;
375 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
376 	struct tty_struct *tty;
377 	unsigned char *data = urb->transfer_buffer;
378 	short todo;
379 	int result;
380 	int status = urb->status;
381 
382 	dbg("%s - port %d", __func__, port->number);
383 
384 	usb_serial_debug_data(debug, &port->dev, __func__,
385 						urb->actual_length, data);
386 	if (status) {
387 		dbg("%s - nonzero read bulk status received: %d",
388 		    __func__, status);
389 		return;
390 	}
391 
392 	tty = tty_port_tty_get(&port->port);
393 	if (!tty) {
394 		dbg("%s - ignoring since device not open\n", __func__);
395 		return;
396 	}
397 	if (urb->actual_length) {
398 		tty_buffer_request_room(tty, urb->actual_length);
399 		tty_insert_flip_string(tty, data, urb->actual_length);
400 		tty_flip_buffer_push(tty);
401 	}
402 	tty_kref_put(tty);
403 
404 	spin_lock(&priv->lock);
405 
406 	/* Reduce urbs to do by one. */
407 	priv->rdtodo -= urb->actual_length;
408 	/* Just to be sure */
409 	if (priv->rdtodo < 0)
410 		priv->rdtodo = 0;
411 	todo = priv->rdtodo;
412 
413 	spin_unlock(&priv->lock);
414 
415 	dbg("%s - rdtodo: %d", __func__, todo);
416 
417 	/* Continue to read if we have still urbs to do. */
418 	if (todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/) {
419 		port->read_urb->dev = port->serial->dev;
420 		result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
421 		if (result)
422 			dev_err(&port->dev, "%s - failed resubmitting read "
423 				"urb, error %d\n", __func__, result);
424 		dbg("%s - usb_submit_urb(read urb)", __func__);
425 	}
426 }
427 
428 static void cyberjack_write_bulk_callback(struct urb *urb)
429 {
430 	struct usb_serial_port *port = urb->context;
431 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
432 	int status = urb->status;
433 
434 	dbg("%s - port %d", __func__, port->number);
435 
436 	port->write_urb_busy = 0;
437 	if (status) {
438 		dbg("%s - nonzero write bulk status received: %d",
439 		    __func__, status);
440 		return;
441 	}
442 
443 	spin_lock(&priv->lock);
444 
445 	/* only do something if we have more data to send */
446 	if (priv->wrfilled) {
447 		int length, blksize, result;
448 
449 		dbg("%s - transmitting data (frame n)", __func__);
450 
451 		length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
452 			port->bulk_out_size : (priv->wrfilled - priv->wrsent);
453 
454 		memcpy(port->write_urb->transfer_buffer,
455 					priv->wrbuf + priv->wrsent, length);
456 		priv->wrsent += length;
457 
458 		/* set up our urb */
459 		usb_fill_bulk_urb(port->write_urb, port->serial->dev,
460 			      usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
461 			      port->write_urb->transfer_buffer, length,
462 			      ((port->serial->type->write_bulk_callback) ?
463 			       port->serial->type->write_bulk_callback :
464 			       cyberjack_write_bulk_callback),
465 			      port);
466 
467 		/* send the data out the bulk port */
468 		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
469 		if (result) {
470 			dev_err(&port->dev,
471 				"%s - failed submitting write urb, error %d\n",
472 				__func__, result);
473 			/* Throw away data. No better idea what to do with it. */
474 			priv->wrfilled = 0;
475 			priv->wrsent = 0;
476 			goto exit;
477 		}
478 
479 		dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
480 		dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);
481 
482 		blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
483 
484 		if (priv->wrsent >= priv->wrfilled ||
485 					priv->wrsent >= blksize) {
486 			dbg("%s - buffer cleaned", __func__);
487 			memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
488 			priv->wrfilled = 0;
489 			priv->wrsent = 0;
490 		}
491 	}
492 
493 exit:
494 	spin_unlock(&priv->lock);
495 	usb_serial_port_softint(port);
496 }
497 
498 static int __init cyberjack_init(void)
499 {
500 	int retval;
501 	retval  = usb_serial_register(&cyberjack_device);
502 	if (retval)
503 		goto failed_usb_serial_register;
504 	retval = usb_register(&cyberjack_driver);
505 	if (retval)
506 		goto failed_usb_register;
507 
508 	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION " "
509 	       DRIVER_AUTHOR "\n");
510 	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
511 
512 	return 0;
513 failed_usb_register:
514 	usb_serial_deregister(&cyberjack_device);
515 failed_usb_serial_register:
516 	return retval;
517 }
518 
519 static void __exit cyberjack_exit(void)
520 {
521 	usb_deregister(&cyberjack_driver);
522 	usb_serial_deregister(&cyberjack_device);
523 }
524 
525 module_init(cyberjack_init);
526 module_exit(cyberjack_exit);
527 
528 MODULE_AUTHOR(DRIVER_AUTHOR);
529 MODULE_DESCRIPTION(DRIVER_DESC);
530 MODULE_VERSION(DRIVER_VERSION);
531 MODULE_LICENSE("GPL");
532 
533 module_param(debug, bool, S_IRUGO | S_IWUSR);
534 MODULE_PARM_DESC(debug, "Debug enabled or not");
535