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 <asm/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_shutdown (struct usb_serial
*serial
);
62 static int cyberjack_open (struct usb_serial_port
*port
, struct file
*filp
);
63 static void cyberjack_close (struct usb_serial_port
*port
, struct file
*filp
);
64 static int cyberjack_write (struct usb_serial_port
*port
, const unsigned char *buf
, int count
);
65 static int cyberjack_write_room( struct usb_serial_port
*port
);
66 static void cyberjack_read_int_callback (struct urb
*urb
);
67 static void cyberjack_read_bulk_callback (struct urb
*urb
);
68 static void cyberjack_write_bulk_callback (struct urb
*urb
);
70 static struct usb_device_id id_table
[] = {
71 { USB_DEVICE(CYBERJACK_VENDOR_ID
, CYBERJACK_PRODUCT_ID
) },
72 { } /* Terminating entry */
75 MODULE_DEVICE_TABLE (usb
, id_table
);
77 static struct usb_driver cyberjack_driver
= {
79 .probe
= usb_serial_probe
,
80 .disconnect
= usb_serial_disconnect
,
85 static struct usb_serial_driver cyberjack_device
= {
90 .description
= "Reiner SCT Cyberjack USB card reader",
91 .usb_driver
= &cyberjack_driver
,
94 .attach
= cyberjack_startup
,
95 .shutdown
= cyberjack_shutdown
,
96 .open
= cyberjack_open
,
97 .close
= cyberjack_close
,
98 .write
= cyberjack_write
,
99 .write_room
= cyberjack_write_room
,
100 .read_int_callback
= cyberjack_read_int_callback
,
101 .read_bulk_callback
= cyberjack_read_bulk_callback
,
102 .write_bulk_callback
= cyberjack_write_bulk_callback
,
105 struct cyberjack_private
{
106 spinlock_t lock
; /* Lock for SMP */
107 short rdtodo
; /* Bytes still to read */
108 unsigned char wrbuf
[5*64]; /* Buffer for collecting data to write */
109 short wrfilled
; /* Overall data size we already got */
110 short wrsent
; /* Data already sent */
113 /* do some startup allocations not currently performed by usb_serial_probe() */
114 static int cyberjack_startup (struct usb_serial
*serial
)
116 struct cyberjack_private
*priv
;
119 dbg("%s", __FUNCTION__
);
121 /* allocate the private data structure */
122 priv
= kmalloc(sizeof(struct cyberjack_private
), GFP_KERNEL
);
126 /* set initial values */
127 spin_lock_init(&priv
->lock
);
131 usb_set_serial_port_data(serial
->port
[0], priv
);
133 init_waitqueue_head(&serial
->port
[0]->write_wait
);
135 for (i
= 0; i
< serial
->num_ports
; ++i
) {
137 serial
->port
[i
]->interrupt_in_urb
->dev
= serial
->dev
;
138 result
= usb_submit_urb(serial
->port
[i
]->interrupt_in_urb
,
141 err(" usb_submit_urb(read int) failed");
142 dbg("%s - usb_submit_urb(int urb)", __FUNCTION__
);
148 static void cyberjack_shutdown (struct usb_serial
*serial
)
152 dbg("%s", __FUNCTION__
);
154 for (i
=0; i
< serial
->num_ports
; ++i
) {
155 usb_kill_urb(serial
->port
[i
]->interrupt_in_urb
);
156 /* My special items, the standard routines free my urbs */
157 kfree(usb_get_serial_port_data(serial
->port
[i
]));
158 usb_set_serial_port_data(serial
->port
[i
], NULL
);
162 static int cyberjack_open (struct usb_serial_port
*port
, struct file
*filp
)
164 struct cyberjack_private
*priv
;
168 dbg("%s - port %d", __FUNCTION__
, port
->number
);
170 dbg("%s - usb_clear_halt", __FUNCTION__
);
171 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
173 /* force low_latency on so that our tty_push actually forces
174 * the data through, otherwise it is scheduled, and with high
175 * data rates (like with OHCI) data can get lost.
177 port
->tty
->low_latency
= 1;
179 priv
= usb_get_serial_port_data(port
);
180 spin_lock_irqsave(&priv
->lock
, flags
);
184 spin_unlock_irqrestore(&priv
->lock
, flags
);
189 static void cyberjack_close (struct usb_serial_port
*port
, struct file
*filp
)
191 dbg("%s - port %d", __FUNCTION__
, port
->number
);
193 if (port
->serial
->dev
) {
194 /* shutdown any bulk reads that might be going on */
195 usb_kill_urb(port
->write_urb
);
196 usb_kill_urb(port
->read_urb
);
200 static int cyberjack_write (struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
202 struct usb_serial
*serial
= port
->serial
;
203 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
208 dbg("%s - port %d", __FUNCTION__
, port
->number
);
211 dbg("%s - write request of 0 bytes", __FUNCTION__
);
215 spin_lock_bh(&port
->lock
);
216 if (port
->write_urb_busy
) {
217 spin_unlock_bh(&port
->lock
);
218 dbg("%s - already writing", __FUNCTION__
);
221 port
->write_urb_busy
= 1;
222 spin_unlock_bh(&port
->lock
);
224 spin_lock_irqsave(&priv
->lock
, flags
);
226 if( (count
+priv
->wrfilled
)>sizeof(priv
->wrbuf
) ) {
227 /* To much data for buffer. Reset buffer. */
229 spin_unlock_irqrestore(&priv
->lock
, flags
);
230 port
->write_urb_busy
= 0;
235 memcpy (priv
->wrbuf
+priv
->wrfilled
, buf
, count
);
237 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, count
,
238 priv
->wrbuf
+priv
->wrfilled
);
239 priv
->wrfilled
+= count
;
241 if( priv
->wrfilled
>= 3 ) {
242 wrexpected
= ((int)priv
->wrbuf
[2]<<8)+priv
->wrbuf
[1]+3;
243 dbg("%s - expected data: %d", __FUNCTION__
, wrexpected
);
245 wrexpected
= sizeof(priv
->wrbuf
);
248 if( priv
->wrfilled
>= wrexpected
) {
249 /* We have enough data to begin transmission */
252 dbg("%s - transmitting data (frame 1)", __FUNCTION__
);
253 length
= (wrexpected
> port
->bulk_out_size
) ? port
->bulk_out_size
: wrexpected
;
255 memcpy (port
->write_urb
->transfer_buffer
, priv
->wrbuf
, length
);
259 usb_fill_bulk_urb(port
->write_urb
, serial
->dev
,
260 usb_sndbulkpipe(serial
->dev
, port
->bulk_out_endpointAddress
),
261 port
->write_urb
->transfer_buffer
, length
,
262 ((serial
->type
->write_bulk_callback
) ?
263 serial
->type
->write_bulk_callback
:
264 cyberjack_write_bulk_callback
),
267 /* send the data out the bulk port */
268 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
270 err("%s - failed submitting write urb, error %d", __FUNCTION__
, result
);
271 /* Throw away data. No better idea what to do with it. */
274 spin_unlock_irqrestore(&priv
->lock
, flags
);
275 port
->write_urb_busy
= 0;
279 dbg("%s - priv->wrsent=%d", __FUNCTION__
,priv
->wrsent
);
280 dbg("%s - priv->wrfilled=%d", __FUNCTION__
,priv
->wrfilled
);
282 if( priv
->wrsent
>=priv
->wrfilled
) {
283 dbg("%s - buffer cleaned", __FUNCTION__
);
284 memset( priv
->wrbuf
, 0, sizeof(priv
->wrbuf
) );
290 spin_unlock_irqrestore(&priv
->lock
, flags
);
295 static int cyberjack_write_room( struct usb_serial_port
*port
)
297 return CYBERJACK_LOCAL_BUF_SIZE
;
300 static void cyberjack_read_int_callback( struct urb
*urb
)
302 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
303 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
304 unsigned char *data
= urb
->transfer_buffer
;
305 int status
= urb
->status
;
308 dbg("%s - port %d", __FUNCTION__
, port
->number
);
310 /* the urb might have been killed. */
314 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
316 /* React only to interrupts signaling a bulk_in transfer */
317 if( (urb
->actual_length
==4) && (data
[0]==0x01) ) {
320 /* This is a announcement of coming bulk_ins. */
321 unsigned short size
= ((unsigned short)data
[3]<<8)+data
[2]+3;
323 spin_lock(&priv
->lock
);
325 old_rdtodo
= priv
->rdtodo
;
327 if( (old_rdtodo
+size
)<(old_rdtodo
) ) {
328 dbg( "To many bulk_in urbs to do." );
329 spin_unlock(&priv
->lock
);
333 /* "+=" is probably more fault tollerant than "=" */
334 priv
->rdtodo
+= size
;
336 dbg("%s - rdtodo: %d", __FUNCTION__
, priv
->rdtodo
);
338 spin_unlock(&priv
->lock
);
341 port
->read_urb
->dev
= port
->serial
->dev
;
342 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
344 err("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
345 dbg("%s - usb_submit_urb(read urb)", __FUNCTION__
);
350 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
351 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
353 err(" usb_submit_urb(read int) failed");
354 dbg("%s - usb_submit_urb(int urb)", __FUNCTION__
);
357 static void cyberjack_read_bulk_callback (struct urb
*urb
)
359 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
360 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
361 struct tty_struct
*tty
;
362 unsigned char *data
= urb
->transfer_buffer
;
365 int status
= urb
->status
;
367 dbg("%s - port %d", __FUNCTION__
, port
->number
);
369 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
371 dbg("%s - nonzero read bulk status received: %d",
372 __FUNCTION__
, status
);
378 dbg("%s - ignoring since device not open\n", __FUNCTION__
);
381 if (urb
->actual_length
) {
382 tty_buffer_request_room(tty
, urb
->actual_length
);
383 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
384 tty_flip_buffer_push(tty
);
387 spin_lock(&priv
->lock
);
389 /* Reduce urbs to do by one. */
390 priv
->rdtodo
-=urb
->actual_length
;
391 /* Just to be sure */
392 if ( priv
->rdtodo
<0 ) priv
->rdtodo
= 0;
395 spin_unlock(&priv
->lock
);
397 dbg("%s - rdtodo: %d", __FUNCTION__
, todo
);
399 /* Continue to read if we have still urbs to do. */
400 if( todo
/* || (urb->actual_length==port->bulk_in_endpointAddress)*/ ) {
401 port
->read_urb
->dev
= port
->serial
->dev
;
402 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
404 err("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
405 dbg("%s - usb_submit_urb(read urb)", __FUNCTION__
);
409 static void cyberjack_write_bulk_callback (struct urb
*urb
)
411 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
412 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
413 int status
= urb
->status
;
415 dbg("%s - port %d", __FUNCTION__
, port
->number
);
417 port
->write_urb_busy
= 0;
419 dbg("%s - nonzero write bulk status received: %d",
420 __FUNCTION__
, status
);
424 spin_lock(&priv
->lock
);
426 /* only do something if we have more data to send */
427 if( priv
->wrfilled
) {
428 int length
, blksize
, result
;
430 dbg("%s - transmitting data (frame n)", __FUNCTION__
);
432 length
= ((priv
->wrfilled
- priv
->wrsent
) > port
->bulk_out_size
) ?
433 port
->bulk_out_size
: (priv
->wrfilled
- priv
->wrsent
);
435 memcpy (port
->write_urb
->transfer_buffer
, priv
->wrbuf
+ priv
->wrsent
,
437 priv
->wrsent
+=length
;
440 usb_fill_bulk_urb(port
->write_urb
, port
->serial
->dev
,
441 usb_sndbulkpipe(port
->serial
->dev
, port
->bulk_out_endpointAddress
),
442 port
->write_urb
->transfer_buffer
, length
,
443 ((port
->serial
->type
->write_bulk_callback
) ?
444 port
->serial
->type
->write_bulk_callback
:
445 cyberjack_write_bulk_callback
),
448 /* send the data out the bulk port */
449 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
451 err("%s - failed submitting write urb, error %d", __FUNCTION__
, result
);
452 /* Throw away data. No better idea what to do with it. */
458 dbg("%s - priv->wrsent=%d", __FUNCTION__
,priv
->wrsent
);
459 dbg("%s - priv->wrfilled=%d", __FUNCTION__
,priv
->wrfilled
);
461 blksize
= ((int)priv
->wrbuf
[2]<<8)+priv
->wrbuf
[1]+3;
463 if( (priv
->wrsent
>=priv
->wrfilled
) || (priv
->wrsent
>=blksize
) ) {
464 dbg("%s - buffer cleaned", __FUNCTION__
);
465 memset( priv
->wrbuf
, 0, sizeof(priv
->wrbuf
) );
472 spin_unlock(&priv
->lock
);
473 usb_serial_port_softint(port
);
476 static int __init
cyberjack_init (void)
479 retval
= usb_serial_register(&cyberjack_device
);
481 goto failed_usb_serial_register
;
482 retval
= usb_register(&cyberjack_driver
);
484 goto failed_usb_register
;
486 info(DRIVER_VERSION
" " DRIVER_AUTHOR
);
491 usb_serial_deregister(&cyberjack_device
);
492 failed_usb_serial_register
:
496 static void __exit
cyberjack_exit (void)
498 usb_deregister (&cyberjack_driver
);
499 usb_serial_deregister (&cyberjack_device
);
502 module_init(cyberjack_init
);
503 module_exit(cyberjack_exit
);
505 MODULE_AUTHOR( DRIVER_AUTHOR
);
506 MODULE_DESCRIPTION( DRIVER_DESC
);
507 MODULE_VERSION( DRIVER_VERSION
);
508 MODULE_LICENSE("GPL");
510 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
511 MODULE_PARM_DESC(debug
, "Debug enabled or not");