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_driver cyberjack_driver
= {
82 .probe
= usb_serial_probe
,
83 .disconnect
= usb_serial_disconnect
,
88 static struct usb_serial_driver cyberjack_device
= {
93 .description
= "Reiner SCT Cyberjack USB card reader",
94 .usb_driver
= &cyberjack_driver
,
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
,
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 */
117 /* do some startup allocations not currently performed by usb_serial_probe() */
118 static int cyberjack_startup(struct usb_serial
*serial
)
120 struct cyberjack_private
*priv
;
125 /* allocate the private data structure */
126 priv
= kmalloc(sizeof(struct cyberjack_private
), GFP_KERNEL
);
130 /* set initial values */
131 spin_lock_init(&priv
->lock
);
135 usb_set_serial_port_data(serial
->port
[0], priv
);
137 init_waitqueue_head(&serial
->port
[0]->write_wait
);
139 for (i
= 0; i
< serial
->num_ports
; ++i
) {
141 serial
->port
[i
]->interrupt_in_urb
->dev
= serial
->dev
;
142 result
= usb_submit_urb(serial
->port
[i
]->interrupt_in_urb
,
145 dev_err(&serial
->dev
->dev
,
146 "usb_submit_urb(read int) failed\n");
147 dbg("%s - usb_submit_urb(int urb)", __func__
);
153 static void cyberjack_disconnect(struct usb_serial
*serial
)
159 for (i
= 0; i
< serial
->num_ports
; ++i
)
160 usb_kill_urb(serial
->port
[i
]->interrupt_in_urb
);
163 static void cyberjack_release(struct usb_serial
*serial
)
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
]));
175 static int cyberjack_open(struct tty_struct
*tty
,
176 struct usb_serial_port
*port
)
178 struct cyberjack_private
*priv
;
182 dbg("%s - port %d", __func__
, port
->number
);
184 dbg("%s - usb_clear_halt", __func__
);
185 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
187 priv
= usb_get_serial_port_data(port
);
188 spin_lock_irqsave(&priv
->lock
, flags
);
192 spin_unlock_irqrestore(&priv
->lock
, flags
);
197 static void cyberjack_close(struct usb_serial_port
*port
)
199 dbg("%s - port %d", __func__
, port
->number
);
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
);
208 static int cyberjack_write(struct tty_struct
*tty
,
209 struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
211 struct usb_serial
*serial
= port
->serial
;
212 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
217 dbg("%s - port %d", __func__
, port
->number
);
220 dbg("%s - write request of 0 bytes", __func__
);
224 spin_lock_bh(&port
->lock
);
225 if (port
->write_urb_busy
) {
226 spin_unlock_bh(&port
->lock
);
227 dbg("%s - already writing", __func__
);
230 port
->write_urb_busy
= 1;
231 spin_unlock_bh(&port
->lock
);
233 spin_lock_irqsave(&priv
->lock
, flags
);
235 if (count
+priv
->wrfilled
> sizeof(priv
->wrbuf
)) {
236 /* To much data for buffer. Reset buffer. */
238 port
->write_urb_busy
= 0;
239 spin_unlock_irqrestore(&priv
->lock
, flags
);
244 memcpy(priv
->wrbuf
+ priv
->wrfilled
, buf
, count
);
246 usb_serial_debug_data(debug
, &port
->dev
, __func__
, count
,
247 priv
->wrbuf
+ priv
->wrfilled
);
248 priv
->wrfilled
+= count
;
250 if (priv
->wrfilled
>= 3) {
251 wrexpected
= ((int)priv
->wrbuf
[2]<<8)+priv
->wrbuf
[1]+3;
252 dbg("%s - expected data: %d", __func__
, wrexpected
);
254 wrexpected
= sizeof(priv
->wrbuf
);
256 if (priv
->wrfilled
>= wrexpected
) {
257 /* We have enough data to begin transmission */
260 dbg("%s - transmitting data (frame 1)", __func__
);
261 length
= (wrexpected
> port
->bulk_out_size
) ?
262 port
->bulk_out_size
: wrexpected
;
264 memcpy(port
->write_urb
->transfer_buffer
, priv
->wrbuf
, length
);
265 priv
->wrsent
= length
;
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
),
276 /* send the data out the bulk port */
277 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
280 "%s - failed submitting write urb, error %d",
282 /* Throw away data. No better idea what to do with it. */
285 spin_unlock_irqrestore(&priv
->lock
, flags
);
286 port
->write_urb_busy
= 0;
290 dbg("%s - priv->wrsent=%d", __func__
, priv
->wrsent
);
291 dbg("%s - priv->wrfilled=%d", __func__
, priv
->wrfilled
);
293 if (priv
->wrsent
>= priv
->wrfilled
) {
294 dbg("%s - buffer cleaned", __func__
);
295 memset(priv
->wrbuf
, 0, sizeof(priv
->wrbuf
));
301 spin_unlock_irqrestore(&priv
->lock
, flags
);
306 static int cyberjack_write_room(struct tty_struct
*tty
)
308 return CYBERJACK_LOCAL_BUF_SIZE
;
311 static void cyberjack_read_int_callback(struct urb
*urb
)
313 struct usb_serial_port
*port
= urb
->context
;
314 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
315 unsigned char *data
= urb
->transfer_buffer
;
316 int status
= urb
->status
;
319 dbg("%s - port %d", __func__
, port
->number
);
321 /* the urb might have been killed. */
325 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
326 urb
->actual_length
, data
);
328 /* React only to interrupts signaling a bulk_in transfer */
329 if (urb
->actual_length
== 4 && data
[0] == 0x01) {
332 /* This is a announcement of coming bulk_ins. */
333 unsigned short size
= ((unsigned short)data
[3]<<8)+data
[2]+3;
335 spin_lock(&priv
->lock
);
337 old_rdtodo
= priv
->rdtodo
;
339 if (old_rdtodo
+ size
< old_rdtodo
) {
340 dbg("To many bulk_in urbs to do.");
341 spin_unlock(&priv
->lock
);
345 /* "+=" is probably more fault tollerant than "=" */
346 priv
->rdtodo
+= size
;
348 dbg("%s - rdtodo: %d", __func__
, priv
->rdtodo
);
350 spin_unlock(&priv
->lock
);
353 port
->read_urb
->dev
= port
->serial
->dev
;
354 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
356 dev_err(&port
->dev
, "%s - failed resubmitting "
357 "read urb, error %d\n",
359 dbg("%s - usb_submit_urb(read urb)", __func__
);
364 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
365 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
367 dev_err(&port
->dev
, "usb_submit_urb(read int) failed\n");
368 dbg("%s - usb_submit_urb(int urb)", __func__
);
371 static void cyberjack_read_bulk_callback(struct urb
*urb
)
373 struct usb_serial_port
*port
= urb
->context
;
374 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
375 struct tty_struct
*tty
;
376 unsigned char *data
= urb
->transfer_buffer
;
379 int status
= urb
->status
;
381 dbg("%s - port %d", __func__
, port
->number
);
383 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
384 urb
->actual_length
, data
);
386 dbg("%s - nonzero read bulk status received: %d",
391 tty
= tty_port_tty_get(&port
->port
);
393 dbg("%s - ignoring since device not open", __func__
);
396 if (urb
->actual_length
) {
397 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
398 tty_flip_buffer_push(tty
);
402 spin_lock(&priv
->lock
);
404 /* Reduce urbs to do by one. */
405 priv
->rdtodo
-= urb
->actual_length
;
406 /* Just to be sure */
407 if (priv
->rdtodo
< 0)
411 spin_unlock(&priv
->lock
);
413 dbg("%s - rdtodo: %d", __func__
, todo
);
415 /* Continue to read if we have still urbs to do. */
416 if (todo
/* || (urb->actual_length==port->bulk_in_endpointAddress)*/) {
417 port
->read_urb
->dev
= port
->serial
->dev
;
418 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
420 dev_err(&port
->dev
, "%s - failed resubmitting read "
421 "urb, error %d\n", __func__
, result
);
422 dbg("%s - usb_submit_urb(read urb)", __func__
);
426 static void cyberjack_write_bulk_callback(struct urb
*urb
)
428 struct usb_serial_port
*port
= urb
->context
;
429 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
430 int status
= urb
->status
;
432 dbg("%s - port %d", __func__
, port
->number
);
434 port
->write_urb_busy
= 0;
436 dbg("%s - nonzero write bulk status received: %d",
441 spin_lock(&priv
->lock
);
443 /* only do something if we have more data to send */
444 if (priv
->wrfilled
) {
445 int length
, blksize
, result
;
447 dbg("%s - transmitting data (frame n)", __func__
);
449 length
= ((priv
->wrfilled
- priv
->wrsent
) > port
->bulk_out_size
) ?
450 port
->bulk_out_size
: (priv
->wrfilled
- priv
->wrsent
);
452 memcpy(port
->write_urb
->transfer_buffer
,
453 priv
->wrbuf
+ priv
->wrsent
, length
);
454 priv
->wrsent
+= length
;
457 usb_fill_bulk_urb(port
->write_urb
, port
->serial
->dev
,
458 usb_sndbulkpipe(port
->serial
->dev
, port
->bulk_out_endpointAddress
),
459 port
->write_urb
->transfer_buffer
, length
,
460 ((port
->serial
->type
->write_bulk_callback
) ?
461 port
->serial
->type
->write_bulk_callback
:
462 cyberjack_write_bulk_callback
),
465 /* send the data out the bulk port */
466 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
469 "%s - failed submitting write urb, error %d\n",
471 /* Throw away data. No better idea what to do with it. */
477 dbg("%s - priv->wrsent=%d", __func__
, priv
->wrsent
);
478 dbg("%s - priv->wrfilled=%d", __func__
, priv
->wrfilled
);
480 blksize
= ((int)priv
->wrbuf
[2]<<8)+priv
->wrbuf
[1]+3;
482 if (priv
->wrsent
>= priv
->wrfilled
||
483 priv
->wrsent
>= blksize
) {
484 dbg("%s - buffer cleaned", __func__
);
485 memset(priv
->wrbuf
, 0, sizeof(priv
->wrbuf
));
492 spin_unlock(&priv
->lock
);
493 usb_serial_port_softint(port
);
496 static int __init
cyberjack_init(void)
499 retval
= usb_serial_register(&cyberjack_device
);
501 goto failed_usb_serial_register
;
502 retval
= usb_register(&cyberjack_driver
);
504 goto failed_usb_register
;
506 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
" "
508 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_DESC
"\n");
512 usb_serial_deregister(&cyberjack_device
);
513 failed_usb_serial_register
:
517 static void __exit
cyberjack_exit(void)
519 usb_deregister(&cyberjack_driver
);
520 usb_serial_deregister(&cyberjack_device
);
523 module_init(cyberjack_init
);
524 module_exit(cyberjack_exit
);
526 MODULE_AUTHOR(DRIVER_AUTHOR
);
527 MODULE_DESCRIPTION(DRIVER_DESC
);
528 MODULE_VERSION(DRIVER_VERSION
);
529 MODULE_LICENSE("GPL");
531 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
532 MODULE_PARM_DESC(debug
, "Debug enabled or not");