2 * REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver
4 * Copyright (C) 2001 REINER SCT
5 * Author: Matthias Bruestle
7 * Contact: linux-usb@sii.li (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
26 #include <linux/config.h>
27 #include <linux/kernel.h>
28 #include <linux/errno.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/tty.h>
32 #include <linux/tty_driver.h>
33 #include <linux/tty_flip.h>
34 #include <linux/module.h>
35 #include <linux/spinlock.h>
36 #include <asm/uaccess.h>
37 #include <linux/usb.h>
38 #include "usb-serial.h"
40 #define CYBERJACK_LOCAL_BUF_SIZE 32
47 #define DRIVER_VERSION "v1.01"
48 #define DRIVER_AUTHOR "Matthias Bruestle"
49 #define DRIVER_DESC "REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver"
52 #define CYBERJACK_VENDOR_ID 0x0C4B
53 #define CYBERJACK_PRODUCT_ID 0x0100
55 /* Function prototypes */
56 static int cyberjack_startup (struct usb_serial
*serial
);
57 static void cyberjack_shutdown (struct usb_serial
*serial
);
58 static int cyberjack_open (struct usb_serial_port
*port
, struct file
*filp
);
59 static void cyberjack_close (struct usb_serial_port
*port
, struct file
*filp
);
60 static int cyberjack_write (struct usb_serial_port
*port
, int from_user
,
61 const unsigned char *buf
, int count
);
62 static int cyberjack_write_room( struct usb_serial_port
*port
);
63 static void cyberjack_read_int_callback (struct urb
*urb
, struct pt_regs
*regs
);
64 static void cyberjack_read_bulk_callback (struct urb
*urb
, struct pt_regs
*regs
);
65 static void cyberjack_write_bulk_callback (struct urb
*urb
, struct pt_regs
*regs
);
67 static struct usb_device_id id_table
[] = {
68 { USB_DEVICE(CYBERJACK_VENDOR_ID
, CYBERJACK_PRODUCT_ID
) },
69 { } /* Terminating entry */
72 MODULE_DEVICE_TABLE (usb
, id_table
);
74 static struct usb_driver cyberjack_driver
= {
77 .probe
= usb_serial_probe
,
78 .disconnect
= usb_serial_disconnect
,
82 static struct usb_serial_device_type cyberjack_device
= {
84 .name
= "Reiner SCT Cyberjack USB card reader",
85 .short_name
= "cyberjack",
87 .num_interrupt_in
= 1,
91 .attach
= cyberjack_startup
,
92 .shutdown
= cyberjack_shutdown
,
93 .open
= cyberjack_open
,
94 .close
= cyberjack_close
,
95 .write
= cyberjack_write
,
96 .write_room
= cyberjack_write_room
,
97 .read_int_callback
= cyberjack_read_int_callback
,
98 .read_bulk_callback
= cyberjack_read_bulk_callback
,
99 .write_bulk_callback
= cyberjack_write_bulk_callback
,
102 struct cyberjack_private
{
103 spinlock_t lock
; /* Lock for SMP */
104 short rdtodo
; /* Bytes still to read */
105 unsigned char wrbuf
[5*64]; /* Buffer for collecting data to write */
106 short wrfilled
; /* Overall data size we already got */
107 short wrsent
; /* Data already sent */
110 /* do some startup allocations not currently performed by usb_serial_probe() */
111 static int cyberjack_startup (struct usb_serial
*serial
)
113 struct cyberjack_private
*priv
;
116 dbg("%s", __FUNCTION__
);
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 serial
->port
[i
]->interrupt_in_urb
->dev
= serial
->dev
;
135 result
= usb_submit_urb(serial
->port
[i
]->interrupt_in_urb
,
138 err(" usb_submit_urb(read int) failed");
139 dbg("%s - usb_submit_urb(int urb)", __FUNCTION__
);
145 static void cyberjack_shutdown (struct usb_serial
*serial
)
149 dbg("%s", __FUNCTION__
);
151 for (i
=0; i
< serial
->num_ports
; ++i
) {
152 usb_unlink_urb (serial
->port
[i
]->interrupt_in_urb
);
153 /* My special items, the standard routines free my urbs */
154 kfree(usb_get_serial_port_data(serial
->port
[i
]));
155 usb_set_serial_port_data(serial
->port
[i
], NULL
);
159 static int cyberjack_open (struct usb_serial_port
*port
, struct file
*filp
)
161 struct cyberjack_private
*priv
;
165 dbg("%s - port %d", __FUNCTION__
, port
->number
);
167 dbg("%s - usb_clear_halt", __FUNCTION__
);
168 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
170 /* force low_latency on so that our tty_push actually forces
171 * the data through, otherwise it is scheduled, and with high
172 * data rates (like with OHCI) data can get lost.
174 port
->tty
->low_latency
= 1;
176 priv
= usb_get_serial_port_data(port
);
177 spin_lock_irqsave(&priv
->lock
, flags
);
181 spin_unlock_irqrestore(&priv
->lock
, flags
);
186 static void cyberjack_close (struct usb_serial_port
*port
, struct file
*filp
)
188 dbg("%s - port %d", __FUNCTION__
, port
->number
);
190 if (port
->serial
->dev
) {
191 /* shutdown any bulk reads that might be going on */
192 usb_unlink_urb (port
->write_urb
);
193 usb_unlink_urb (port
->read_urb
);
197 static int cyberjack_write (struct usb_serial_port
*port
, int from_user
, const unsigned char *buf
, int count
)
199 struct usb_serial
*serial
= port
->serial
;
200 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
205 dbg("%s - port %d", __FUNCTION__
, port
->number
);
206 dbg("%s - from_user %d", __FUNCTION__
, from_user
);
209 dbg("%s - write request of 0 bytes", __FUNCTION__
);
213 if (port
->write_urb
->status
== -EINPROGRESS
) {
214 dbg("%s - already writing", __FUNCTION__
);
218 spin_lock_irqsave(&priv
->lock
, flags
);
220 if( (count
+priv
->wrfilled
)>sizeof(priv
->wrbuf
) ) {
221 /* To much data for buffer. Reset buffer. */
223 spin_unlock_irqrestore(&priv
->lock
, flags
);
229 if (copy_from_user(priv
->wrbuf
+priv
->wrfilled
, buf
, count
)) {
230 spin_unlock_irqrestore(&priv
->lock
, flags
);
234 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
);
278 dbg("%s - priv->wrsent=%d", __FUNCTION__
,priv
->wrsent
);
279 dbg("%s - priv->wrfilled=%d", __FUNCTION__
,priv
->wrfilled
);
281 if( priv
->wrsent
>=priv
->wrfilled
) {
282 dbg("%s - buffer cleaned", __FUNCTION__
);
283 memset( priv
->wrbuf
, 0, sizeof(priv
->wrbuf
) );
289 spin_unlock_irqrestore(&priv
->lock
, flags
);
294 static int cyberjack_write_room( struct usb_serial_port
*port
)
296 return CYBERJACK_LOCAL_BUF_SIZE
;
299 static void cyberjack_read_int_callback( struct urb
*urb
, struct pt_regs
*regs
)
301 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
302 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
303 unsigned char *data
= urb
->transfer_buffer
;
306 dbg("%s - port %d", __FUNCTION__
, port
->number
);
308 /* the urb might have been killed. */
312 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
314 /* React only to interrupts signaling a bulk_in transfer */
315 if( (urb
->actual_length
==4) && (data
[0]==0x01) ) {
319 /* This is a announcement of coming bulk_ins. */
320 unsigned short size
= ((unsigned short)data
[3]<<8)+data
[2]+3;
322 spin_lock(&priv
->lock
);
324 old_rdtodo
= priv
->rdtodo
;
326 if( (old_rdtodo
+size
)<(old_rdtodo
) ) {
327 dbg( "To many bulk_in urbs to do." );
328 spin_unlock(&priv
->lock
);
332 /* "+=" is probably more fault tollerant than "=" */
333 priv
->rdtodo
+= size
;
335 dbg("%s - rdtodo: %d", __FUNCTION__
, priv
->rdtodo
);
337 spin_unlock(&priv
->lock
);
340 port
->read_urb
->dev
= port
->serial
->dev
;
341 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
343 err("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
344 dbg("%s - usb_submit_urb(read urb)", __FUNCTION__
);
349 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
350 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
352 err(" usb_submit_urb(read int) failed");
353 dbg("%s - usb_submit_urb(int urb)", __FUNCTION__
);
356 static void cyberjack_read_bulk_callback (struct urb
*urb
, struct pt_regs
*regs
)
358 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
359 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
360 struct tty_struct
*tty
;
361 unsigned char *data
= urb
->transfer_buffer
;
366 dbg("%s - port %d", __FUNCTION__
, port
->number
);
368 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
370 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__
, urb
->status
);
376 dbg("%s - ignoring since device not open\n", __FUNCTION__
);
379 if (urb
->actual_length
) {
380 for (i
= 0; i
< urb
->actual_length
; ++i
) {
381 /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
382 if(tty
->flip
.count
>= TTY_FLIPBUF_SIZE
) {
383 tty_flip_buffer_push(tty
);
385 /* this doesn't actually push the data through unless tty->low_latency is set */
386 tty_insert_flip_char(tty
, data
[i
], 0);
388 tty_flip_buffer_push(tty
);
391 spin_lock(&priv
->lock
);
393 /* Reduce urbs to do by one. */
394 priv
->rdtodo
-=urb
->actual_length
;
395 /* Just to be sure */
396 if ( priv
->rdtodo
<0 ) priv
->rdtodo
= 0;
399 spin_unlock(&priv
->lock
);
401 dbg("%s - rdtodo: %d", __FUNCTION__
, todo
);
403 /* Continue to read if we have still urbs to do. */
404 if( todo
/* || (urb->actual_length==port->bulk_in_endpointAddress)*/ ) {
405 port
->read_urb
->dev
= port
->serial
->dev
;
406 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
408 err("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
409 dbg("%s - usb_submit_urb(read urb)", __FUNCTION__
);
413 static void cyberjack_write_bulk_callback (struct urb
*urb
, struct pt_regs
*regs
)
415 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
416 struct cyberjack_private
*priv
= usb_get_serial_port_data(port
);
418 dbg("%s - port %d", __FUNCTION__
, port
->number
);
421 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__
, urb
->status
);
425 spin_lock(&priv
->lock
);
427 /* only do something if we have more data to send */
428 if( priv
->wrfilled
) {
429 int length
, blksize
, result
;
431 if (port
->write_urb
->status
== -EINPROGRESS
) {
432 dbg("%s - already writing", __FUNCTION__
);
433 spin_unlock(&priv
->lock
);
437 dbg("%s - transmitting data (frame n)", __FUNCTION__
);
439 length
= ((priv
->wrfilled
- priv
->wrsent
) > port
->bulk_out_size
) ?
440 port
->bulk_out_size
: (priv
->wrfilled
- priv
->wrsent
);
442 memcpy (port
->write_urb
->transfer_buffer
, priv
->wrbuf
+ priv
->wrsent
,
444 priv
->wrsent
+=length
;
447 usb_fill_bulk_urb(port
->write_urb
, port
->serial
->dev
,
448 usb_sndbulkpipe(port
->serial
->dev
, port
->bulk_out_endpointAddress
),
449 port
->write_urb
->transfer_buffer
, length
,
450 ((port
->serial
->type
->write_bulk_callback
) ?
451 port
->serial
->type
->write_bulk_callback
:
452 cyberjack_write_bulk_callback
),
455 /* send the data out the bulk port */
456 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
458 err("%s - failed submitting write urb, error %d", __FUNCTION__
, result
);
459 /* Throw away data. No better idea what to do with it. */
465 dbg("%s - priv->wrsent=%d", __FUNCTION__
,priv
->wrsent
);
466 dbg("%s - priv->wrfilled=%d", __FUNCTION__
,priv
->wrfilled
);
468 blksize
= ((int)priv
->wrbuf
[2]<<8)+priv
->wrbuf
[1]+3;
470 if( (priv
->wrsent
>=priv
->wrfilled
) || (priv
->wrsent
>=blksize
) ) {
471 dbg("%s - buffer cleaned", __FUNCTION__
);
472 memset( priv
->wrbuf
, 0, sizeof(priv
->wrbuf
) );
479 spin_unlock(&priv
->lock
);
480 schedule_work(&port
->work
);
483 static int __init
cyberjack_init (void)
486 retval
= usb_serial_register(&cyberjack_device
);
488 goto failed_usb_serial_register
;
489 retval
= usb_register(&cyberjack_driver
);
491 goto failed_usb_register
;
493 info(DRIVER_VERSION
" " DRIVER_AUTHOR
);
498 usb_serial_deregister(&cyberjack_device
);
499 failed_usb_serial_register
:
503 static void __exit
cyberjack_exit (void)
505 usb_deregister (&cyberjack_driver
);
506 usb_serial_deregister (&cyberjack_device
);
509 module_init(cyberjack_init
);
510 module_exit(cyberjack_exit
);
512 MODULE_AUTHOR( DRIVER_AUTHOR
);
513 MODULE_DESCRIPTION( DRIVER_DESC
);
514 MODULE_LICENSE("GPL");
516 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
517 MODULE_PARM_DESC(debug
, "Debug enabled or not");