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