2 * REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver
4 * Copyright (C) 2001 REINER SCT
5 * Author: Matthias Bruestle
7 * Contact: support@reiner-sct.com (see MAINTAINERS)
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.
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.
18 * Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and
21 * In case of problems, please write to the contact e-mail address
24 * Please note that later models of the cyberjack reader family are
25 * supported by a libusb-based userspace device driver.
27 * Homepage: http://www.reiner-sct.de/support/treiber_cyberjack.php#linux
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>
44 #define CYBERJACK_LOCAL_BUF_SIZE 32
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"
56 #define CYBERJACK_VENDOR_ID 0x0C4B
57 #define CYBERJACK_PRODUCT_ID 0x0100
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
);
73 static const struct usb_device_id id_table
[] = {
74 { USB_DEVICE(CYBERJACK_VENDOR_ID
, CYBERJACK_PRODUCT_ID
) },
75 { } /* Terminating entry */
78 MODULE_DEVICE_TABLE(usb
, id_table
);
80 static struct usb_serial_driver cyberjack_device
= {
85 .description
= "Reiner SCT Cyberjack USB card reader",
88 .attach
= cyberjack_startup
,
89 .disconnect
= cyberjack_disconnect
,
90 .release
= cyberjack_release
,
91 .open
= cyberjack_open
,
92 .close
= cyberjack_close
,
93 .write
= cyberjack_write
,
94 .write_room
= cyberjack_write_room
,
95 .read_int_callback
= cyberjack_read_int_callback
,
96 .read_bulk_callback
= cyberjack_read_bulk_callback
,
97 .write_bulk_callback
= cyberjack_write_bulk_callback
,
100 static struct usb_serial_driver
* const serial_drivers
[] = {
101 &cyberjack_device
, NULL
104 struct cyberjack_private
{
105 spinlock_t lock
; /* Lock for SMP */
106 short rdtodo
; /* Bytes still to read */
107 unsigned char wrbuf
[5*64]; /* Buffer for collecting data to write */
108 short wrfilled
; /* Overall data size we already got */
109 short wrsent
; /* Data already sent */
112 /* do some startup allocations not currently performed by usb_serial_probe() */
113 static int cyberjack_startup(struct usb_serial
*serial
)
115 struct cyberjack_private
*priv
;
118 /* allocate the private data structure */
119 priv
= kmalloc(sizeof(struct cyberjack_private
), GFP_KERNEL
);
123 /* set initial values */
124 spin_lock_init(&priv
->lock
);
128 usb_set_serial_port_data(serial
->port
[0], priv
);
130 init_waitqueue_head(&serial
->port
[0]->write_wait
);
132 for (i
= 0; i
< serial
->num_ports
; ++i
) {
134 result
= usb_submit_urb(serial
->port
[i
]->interrupt_in_urb
,
137 dev_err(&serial
->dev
->dev
,
138 "usb_submit_urb(read int) failed\n");
139 dbg("%s - usb_submit_urb(int urb)", __func__
);
145 static void cyberjack_disconnect(struct usb_serial
*serial
)
149 for (i
= 0; i
< serial
->num_ports
; ++i
)
150 usb_kill_urb(serial
->port
[i
]->interrupt_in_urb
);
153 static void cyberjack_release(struct usb_serial
*serial
)
157 for (i
= 0; i
< serial
->num_ports
; ++i
) {
158 /* My special items, the standard routines free my urbs */
159 kfree(usb_get_serial_port_data(serial
->port
[i
]));
163 static int cyberjack_open(struct tty_struct
*tty
,
164 struct usb_serial_port
*port
)
166 struct cyberjack_private
*priv
;
170 dbg("%s - usb_clear_halt", __func__
);
171 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
173 priv
= usb_get_serial_port_data(port
);
174 spin_lock_irqsave(&priv
->lock
, flags
);
178 spin_unlock_irqrestore(&priv
->lock
, flags
);
183 static void cyberjack_close(struct usb_serial_port
*port
)
185 if (port
->serial
->dev
) {
186 /* shutdown any bulk reads that might be going on */
187 usb_kill_urb(port
->write_urb
);
188 usb_kill_urb(port
->read_urb
);
192 static int cyberjack_write(struct tty_struct
*tty
,
193 struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
195 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
201 dbg("%s - write request of 0 bytes", __func__
);
205 if (!test_and_clear_bit(0, &port
->write_urbs_free
)) {
206 dbg("%s - already writing", __func__
);
210 spin_lock_irqsave(&priv
->lock
, flags
);
212 if (count
+priv
->wrfilled
> sizeof(priv
->wrbuf
)) {
213 /* To much data for buffer. Reset buffer. */
215 spin_unlock_irqrestore(&priv
->lock
, flags
);
216 set_bit(0, &port
->write_urbs_free
);
221 memcpy(priv
->wrbuf
+ priv
->wrfilled
, buf
, count
);
223 usb_serial_debug_data(debug
, &port
->dev
, __func__
, count
,
224 priv
->wrbuf
+ priv
->wrfilled
);
225 priv
->wrfilled
+= count
;
227 if (priv
->wrfilled
>= 3) {
228 wrexpected
= ((int)priv
->wrbuf
[2]<<8)+priv
->wrbuf
[1]+3;
229 dbg("%s - expected data: %d", __func__
, wrexpected
);
231 wrexpected
= sizeof(priv
->wrbuf
);
233 if (priv
->wrfilled
>= wrexpected
) {
234 /* We have enough data to begin transmission */
237 dbg("%s - transmitting data (frame 1)", __func__
);
238 length
= (wrexpected
> port
->bulk_out_size
) ?
239 port
->bulk_out_size
: wrexpected
;
241 memcpy(port
->write_urb
->transfer_buffer
, priv
->wrbuf
, length
);
242 priv
->wrsent
= length
;
245 port
->write_urb
->transfer_buffer_length
= length
;
247 /* send the data out the bulk port */
248 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
251 "%s - failed submitting write urb, error %d",
253 /* Throw away data. No better idea what to do with it. */
256 spin_unlock_irqrestore(&priv
->lock
, flags
);
257 set_bit(0, &port
->write_urbs_free
);
261 dbg("%s - priv->wrsent=%d", __func__
, priv
->wrsent
);
262 dbg("%s - priv->wrfilled=%d", __func__
, priv
->wrfilled
);
264 if (priv
->wrsent
>= priv
->wrfilled
) {
265 dbg("%s - buffer cleaned", __func__
);
266 memset(priv
->wrbuf
, 0, sizeof(priv
->wrbuf
));
272 spin_unlock_irqrestore(&priv
->lock
, flags
);
277 static int cyberjack_write_room(struct tty_struct
*tty
)
280 return CYBERJACK_LOCAL_BUF_SIZE
;
283 static void cyberjack_read_int_callback(struct urb
*urb
)
285 struct usb_serial_port
*port
= urb
->context
;
286 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
287 unsigned char *data
= urb
->transfer_buffer
;
288 int status
= urb
->status
;
291 /* the urb might have been killed. */
295 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
296 urb
->actual_length
, data
);
298 /* React only to interrupts signaling a bulk_in transfer */
299 if (urb
->actual_length
== 4 && data
[0] == 0x01) {
302 /* This is a announcement of coming bulk_ins. */
303 unsigned short size
= ((unsigned short)data
[3]<<8)+data
[2]+3;
305 spin_lock(&priv
->lock
);
307 old_rdtodo
= priv
->rdtodo
;
309 if (old_rdtodo
+ size
< old_rdtodo
) {
310 dbg("To many bulk_in urbs to do.");
311 spin_unlock(&priv
->lock
);
315 /* "+=" is probably more fault tollerant than "=" */
316 priv
->rdtodo
+= size
;
318 dbg("%s - rdtodo: %d", __func__
, priv
->rdtodo
);
320 spin_unlock(&priv
->lock
);
323 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
325 dev_err(&port
->dev
, "%s - failed resubmitting "
326 "read urb, error %d\n",
328 dbg("%s - usb_submit_urb(read urb)", __func__
);
333 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
335 dev_err(&port
->dev
, "usb_submit_urb(read int) failed\n");
336 dbg("%s - usb_submit_urb(int urb)", __func__
);
339 static void cyberjack_read_bulk_callback(struct urb
*urb
)
341 struct usb_serial_port
*port
= urb
->context
;
342 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
343 struct tty_struct
*tty
;
344 unsigned char *data
= urb
->transfer_buffer
;
347 int status
= urb
->status
;
349 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
350 urb
->actual_length
, data
);
352 dbg("%s - nonzero read bulk status received: %d",
357 tty
= tty_port_tty_get(&port
->port
);
359 dbg("%s - ignoring since device not open", __func__
);
362 if (urb
->actual_length
) {
363 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
364 tty_flip_buffer_push(tty
);
368 spin_lock(&priv
->lock
);
370 /* Reduce urbs to do by one. */
371 priv
->rdtodo
-= urb
->actual_length
;
372 /* Just to be sure */
373 if (priv
->rdtodo
< 0)
377 spin_unlock(&priv
->lock
);
379 dbg("%s - rdtodo: %d", __func__
, todo
);
381 /* Continue to read if we have still urbs to do. */
382 if (todo
/* || (urb->actual_length==port->bulk_in_endpointAddress)*/) {
383 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
385 dev_err(&port
->dev
, "%s - failed resubmitting read "
386 "urb, error %d\n", __func__
, result
);
387 dbg("%s - usb_submit_urb(read urb)", __func__
);
391 static void cyberjack_write_bulk_callback(struct urb
*urb
)
393 struct usb_serial_port
*port
= urb
->context
;
394 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
395 int status
= urb
->status
;
397 set_bit(0, &port
->write_urbs_free
);
399 dbg("%s - nonzero write bulk status received: %d",
404 spin_lock(&priv
->lock
);
406 /* only do something if we have more data to send */
407 if (priv
->wrfilled
) {
408 int length
, blksize
, result
;
410 dbg("%s - transmitting data (frame n)", __func__
);
412 length
= ((priv
->wrfilled
- priv
->wrsent
) > port
->bulk_out_size
) ?
413 port
->bulk_out_size
: (priv
->wrfilled
- priv
->wrsent
);
415 memcpy(port
->write_urb
->transfer_buffer
,
416 priv
->wrbuf
+ priv
->wrsent
, length
);
417 priv
->wrsent
+= length
;
420 port
->write_urb
->transfer_buffer_length
= length
;
422 /* send the data out the bulk port */
423 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
426 "%s - failed submitting write urb, error %d\n",
428 /* Throw away data. No better idea what to do with it. */
434 dbg("%s - priv->wrsent=%d", __func__
, priv
->wrsent
);
435 dbg("%s - priv->wrfilled=%d", __func__
, priv
->wrfilled
);
437 blksize
= ((int)priv
->wrbuf
[2]<<8)+priv
->wrbuf
[1]+3;
439 if (priv
->wrsent
>= priv
->wrfilled
||
440 priv
->wrsent
>= blksize
) {
441 dbg("%s - buffer cleaned", __func__
);
442 memset(priv
->wrbuf
, 0, sizeof(priv
->wrbuf
));
449 spin_unlock(&priv
->lock
);
450 usb_serial_port_softint(port
);
453 module_usb_serial_driver(serial_drivers
, id_table
);
455 MODULE_AUTHOR(DRIVER_AUTHOR
);
456 MODULE_DESCRIPTION(DRIVER_DESC
);
457 MODULE_VERSION(DRIVER_VERSION
);
458 MODULE_LICENSE("GPL");
460 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
461 MODULE_PARM_DESC(debug
, "Debug enabled or not");