xref: /openbmc/linux/drivers/usb/serial/cyberjack.c (revision 7bcae826) 
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/slab.h>
34 #include <linux/tty.h>
35 #include <linux/tty_driver.h>
36 #include <linux/tty_flip.h>
37 #include <linux/module.h>
38 #include <linux/spinlock.h>
39 #include <linux/uaccess.h>
40 #include <linux/usb.h>
41 #include <linux/usb/serial.h>
42 
43 #define CYBERJACK_LOCAL_BUF_SIZE 32
44 
45 #define DRIVER_AUTHOR "Matthias Bruestle"
46 #define DRIVER_DESC "REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver"
47 
48 
49 #define CYBERJACK_VENDOR_ID	0x0C4B
50 #define CYBERJACK_PRODUCT_ID	0x0100
51 
52 /* Function prototypes */
53 static int cyberjack_attach(struct usb_serial *serial);
54 static int cyberjack_port_probe(struct usb_serial_port *port);
55 static int cyberjack_port_remove(struct usb_serial_port *port);
56 static int  cyberjack_open(struct tty_struct *tty,
57 	struct usb_serial_port *port);
58 static void cyberjack_close(struct usb_serial_port *port);
59 static int cyberjack_write(struct tty_struct *tty,
60 	struct usb_serial_port *port, const unsigned char *buf, int count);
61 static int cyberjack_write_room(struct tty_struct *tty);
62 static void cyberjack_read_int_callback(struct urb *urb);
63 static void cyberjack_read_bulk_callback(struct urb *urb);
64 static void cyberjack_write_bulk_callback(struct urb *urb);
65 
66 static const struct usb_device_id id_table[] = {
67 	{ USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
68 	{ }			/* Terminating entry */
69 };
70 
71 MODULE_DEVICE_TABLE(usb, id_table);
72 
73 static struct usb_serial_driver cyberjack_device = {
74 	.driver = {
75 		.owner =	THIS_MODULE,
76 		.name =		"cyberjack",
77 	},
78 	.description =		"Reiner SCT Cyberjack USB card reader",
79 	.id_table =		id_table,
80 	.num_ports =		1,
81 	.attach =		cyberjack_attach,
82 	.port_probe =		cyberjack_port_probe,
83 	.port_remove =		cyberjack_port_remove,
84 	.open =			cyberjack_open,
85 	.close =		cyberjack_close,
86 	.write =		cyberjack_write,
87 	.write_room =		cyberjack_write_room,
88 	.read_int_callback =	cyberjack_read_int_callback,
89 	.read_bulk_callback =	cyberjack_read_bulk_callback,
90 	.write_bulk_callback =	cyberjack_write_bulk_callback,
91 };
92 
93 static struct usb_serial_driver * const serial_drivers[] = {
94 	&cyberjack_device, NULL
95 };
96 
97 struct cyberjack_private {
98 	spinlock_t	lock;		/* Lock for SMP */
99 	short		rdtodo;		/* Bytes still to read */
100 	unsigned char	wrbuf[5*64];	/* Buffer for collecting data to write */
101 	short		wrfilled;	/* Overall data size we already got */
102 	short		wrsent;		/* Data already sent */
103 };
104 
105 static int cyberjack_attach(struct usb_serial *serial)
106 {
107 	if (serial->num_bulk_out < serial->num_ports)
108 		return -ENODEV;
109 
110 	return 0;
111 }
112 
113 static int cyberjack_port_probe(struct usb_serial_port *port)
114 {
115 	struct cyberjack_private *priv;
116 	int result;
117 
118 	priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL);
119 	if (!priv)
120 		return -ENOMEM;
121 
122 	spin_lock_init(&priv->lock);
123 	priv->rdtodo = 0;
124 	priv->wrfilled = 0;
125 	priv->wrsent = 0;
126 
127 	usb_set_serial_port_data(port, priv);
128 
129 	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
130 	if (result)
131 		dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
132 
133 	return 0;
134 }
135 
136 static int cyberjack_port_remove(struct usb_serial_port *port)
137 {
138 	struct cyberjack_private *priv;
139 
140 	usb_kill_urb(port->interrupt_in_urb);
141 
142 	priv = usb_get_serial_port_data(port);
143 	kfree(priv);
144 
145 	return 0;
146 }
147 
148 static int  cyberjack_open(struct tty_struct *tty,
149 					struct usb_serial_port *port)
150 {
151 	struct cyberjack_private *priv;
152 	unsigned long flags;
153 
154 	dev_dbg(&port->dev, "%s - usb_clear_halt\n", __func__);
155 	usb_clear_halt(port->serial->dev, port->write_urb->pipe);
156 
157 	priv = usb_get_serial_port_data(port);
158 	spin_lock_irqsave(&priv->lock, flags);
159 	priv->rdtodo = 0;
160 	priv->wrfilled = 0;
161 	priv->wrsent = 0;
162 	spin_unlock_irqrestore(&priv->lock, flags);
163 
164 	return 0;
165 }
166 
167 static void cyberjack_close(struct usb_serial_port *port)
168 {
169 	usb_kill_urb(port->write_urb);
170 	usb_kill_urb(port->read_urb);
171 }
172 
173 static int cyberjack_write(struct tty_struct *tty,
174 	struct usb_serial_port *port, const unsigned char *buf, int count)
175 {
176 	struct device *dev = &port->dev;
177 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
178 	unsigned long flags;
179 	int result;
180 	int wrexpected;
181 
182 	if (count == 0) {
183 		dev_dbg(dev, "%s - write request of 0 bytes\n", __func__);
184 		return 0;
185 	}
186 
187 	if (!test_and_clear_bit(0, &port->write_urbs_free)) {
188 		dev_dbg(dev, "%s - already writing\n", __func__);
189 		return 0;
190 	}
191 
192 	spin_lock_irqsave(&priv->lock, flags);
193 
194 	if (count+priv->wrfilled > sizeof(priv->wrbuf)) {
195 		/* To much data for buffer. Reset buffer. */
196 		priv->wrfilled = 0;
197 		spin_unlock_irqrestore(&priv->lock, flags);
198 		set_bit(0, &port->write_urbs_free);
199 		return 0;
200 	}
201 
202 	/* Copy data */
203 	memcpy(priv->wrbuf + priv->wrfilled, buf, count);
204 
205 	usb_serial_debug_data(dev, __func__, count, priv->wrbuf + priv->wrfilled);
206 	priv->wrfilled += count;
207 
208 	if (priv->wrfilled >= 3) {
209 		wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
210 		dev_dbg(dev, "%s - expected data: %d\n", __func__, wrexpected);
211 	} else
212 		wrexpected = sizeof(priv->wrbuf);
213 
214 	if (priv->wrfilled >= wrexpected) {
215 		/* We have enough data to begin transmission */
216 		int length;
217 
218 		dev_dbg(dev, "%s - transmitting data (frame 1)\n", __func__);
219 		length = (wrexpected > port->bulk_out_size) ?
220 					port->bulk_out_size : wrexpected;
221 
222 		memcpy(port->write_urb->transfer_buffer, priv->wrbuf, length);
223 		priv->wrsent = length;
224 
225 		/* set up our urb */
226 		port->write_urb->transfer_buffer_length = length;
227 
228 		/* send the data out the bulk port */
229 		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
230 		if (result) {
231 			dev_err(&port->dev,
232 				"%s - failed submitting write urb, error %d\n",
233 				__func__, result);
234 			/* Throw away data. No better idea what to do with it. */
235 			priv->wrfilled = 0;
236 			priv->wrsent = 0;
237 			spin_unlock_irqrestore(&priv->lock, flags);
238 			set_bit(0, &port->write_urbs_free);
239 			return 0;
240 		}
241 
242 		dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent);
243 		dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled);
244 
245 		if (priv->wrsent >= priv->wrfilled) {
246 			dev_dbg(dev, "%s - buffer cleaned\n", __func__);
247 			memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
248 			priv->wrfilled = 0;
249 			priv->wrsent = 0;
250 		}
251 	}
252 
253 	spin_unlock_irqrestore(&priv->lock, flags);
254 
255 	return count;
256 }
257 
258 static int cyberjack_write_room(struct tty_struct *tty)
259 {
260 	/* FIXME: .... */
261 	return CYBERJACK_LOCAL_BUF_SIZE;
262 }
263 
264 static void cyberjack_read_int_callback(struct urb *urb)
265 {
266 	struct usb_serial_port *port = urb->context;
267 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
268 	struct device *dev = &port->dev;
269 	unsigned char *data = urb->transfer_buffer;
270 	int status = urb->status;
271 	int result;
272 
273 	/* the urb might have been killed. */
274 	if (status)
275 		return;
276 
277 	usb_serial_debug_data(dev, __func__, urb->actual_length, data);
278 
279 	/* React only to interrupts signaling a bulk_in transfer */
280 	if (urb->actual_length == 4 && data[0] == 0x01) {
281 		short old_rdtodo;
282 
283 		/* This is a announcement of coming bulk_ins. */
284 		unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3;
285 
286 		spin_lock(&priv->lock);
287 
288 		old_rdtodo = priv->rdtodo;
289 
290 		if (old_rdtodo > SHRT_MAX - size) {
291 			dev_dbg(dev, "To many bulk_in urbs to do.\n");
292 			spin_unlock(&priv->lock);
293 			goto resubmit;
294 		}
295 
296 		/* "+=" is probably more fault tolerant than "=" */
297 		priv->rdtodo += size;
298 
299 		dev_dbg(dev, "%s - rdtodo: %d\n", __func__, priv->rdtodo);
300 
301 		spin_unlock(&priv->lock);
302 
303 		if (!old_rdtodo) {
304 			result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
305 			if (result)
306 				dev_err(dev, "%s - failed resubmitting read urb, error %d\n",
307 					__func__, result);
308 			dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__);
309 		}
310 	}
311 
312 resubmit:
313 	result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
314 	if (result)
315 		dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
316 	dev_dbg(dev, "%s - usb_submit_urb(int urb)\n", __func__);
317 }
318 
319 static void cyberjack_read_bulk_callback(struct urb *urb)
320 {
321 	struct usb_serial_port *port = urb->context;
322 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
323 	struct device *dev = &port->dev;
324 	unsigned char *data = urb->transfer_buffer;
325 	short todo;
326 	int result;
327 	int status = urb->status;
328 
329 	usb_serial_debug_data(dev, __func__, urb->actual_length, data);
330 	if (status) {
331 		dev_dbg(dev, "%s - nonzero read bulk status received: %d\n",
332 			__func__, status);
333 		return;
334 	}
335 
336 	if (urb->actual_length) {
337 		tty_insert_flip_string(&port->port, data, urb->actual_length);
338 		tty_flip_buffer_push(&port->port);
339 	}
340 
341 	spin_lock(&priv->lock);
342 
343 	/* Reduce urbs to do by one. */
344 	priv->rdtodo -= urb->actual_length;
345 	/* Just to be sure */
346 	if (priv->rdtodo < 0)
347 		priv->rdtodo = 0;
348 	todo = priv->rdtodo;
349 
350 	spin_unlock(&priv->lock);
351 
352 	dev_dbg(dev, "%s - rdtodo: %d\n", __func__, todo);
353 
354 	/* Continue to read if we have still urbs to do. */
355 	if (todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/) {
356 		result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
357 		if (result)
358 			dev_err(dev, "%s - failed resubmitting read urb, error %d\n",
359 				__func__, result);
360 		dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__);
361 	}
362 }
363 
364 static void cyberjack_write_bulk_callback(struct urb *urb)
365 {
366 	struct usb_serial_port *port = urb->context;
367 	struct cyberjack_private *priv = usb_get_serial_port_data(port);
368 	struct device *dev = &port->dev;
369 	int status = urb->status;
370 
371 	set_bit(0, &port->write_urbs_free);
372 	if (status) {
373 		dev_dbg(dev, "%s - nonzero write bulk status received: %d\n",
374 			__func__, status);
375 		return;
376 	}
377 
378 	spin_lock(&priv->lock);
379 
380 	/* only do something if we have more data to send */
381 	if (priv->wrfilled) {
382 		int length, blksize, result;
383 
384 		dev_dbg(dev, "%s - transmitting data (frame n)\n", __func__);
385 
386 		length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
387 			port->bulk_out_size : (priv->wrfilled - priv->wrsent);
388 
389 		memcpy(port->write_urb->transfer_buffer,
390 					priv->wrbuf + priv->wrsent, length);
391 		priv->wrsent += length;
392 
393 		/* set up our urb */
394 		port->write_urb->transfer_buffer_length = length;
395 
396 		/* send the data out the bulk port */
397 		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
398 		if (result) {
399 			dev_err(dev, "%s - failed submitting write urb, error %d\n",
400 				__func__, result);
401 			/* Throw away data. No better idea what to do with it. */
402 			priv->wrfilled = 0;
403 			priv->wrsent = 0;
404 			goto exit;
405 		}
406 
407 		dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent);
408 		dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled);
409 
410 		blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
411 
412 		if (priv->wrsent >= priv->wrfilled ||
413 					priv->wrsent >= blksize) {
414 			dev_dbg(dev, "%s - buffer cleaned\n", __func__);
415 			memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
416 			priv->wrfilled = 0;
417 			priv->wrsent = 0;
418 		}
419 	}
420 
421 exit:
422 	spin_unlock(&priv->lock);
423 	usb_serial_port_softint(port);
424 }
425 
426 module_usb_serial_driver(serial_drivers, id_table);
427 
428 MODULE_AUTHOR(DRIVER_AUTHOR);
429 MODULE_DESCRIPTION(DRIVER_DESC);
430 MODULE_LICENSE("GPL");
431