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, const unsigned char *buf, int count);
61 static int cyberjack_write_room( struct usb_serial_port *port );
62 static void cyberjack_read_int_callback (struct urb *urb, struct pt_regs *regs);
63 static void cyberjack_read_bulk_callback (struct urb *urb, struct pt_regs *regs);
64 static void cyberjack_write_bulk_callback (struct urb *urb, struct pt_regs *regs);
66 static struct usb_device_id id_table [] = {
67 { USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
68 { } /* Terminating entry */
71 MODULE_DEVICE_TABLE (usb, id_table);
73 static struct usb_driver cyberjack_driver = {
76 .probe = usb_serial_probe,
77 .disconnect = usb_serial_disconnect,
81 static struct usb_serial_device_type cyberjack_device = {
83 .name = "Reiner SCT Cyberjack USB card reader",
84 .short_name = "cyberjack",
86 .num_interrupt_in = 1,
90 .attach = cyberjack_startup,
91 .shutdown = cyberjack_shutdown,
92 .open = cyberjack_open,
93 .close = cyberjack_close,
94 .write = cyberjack_write,
95 .write_room = cyberjack_write_room,
96 .read_int_callback = cyberjack_read_int_callback,
97 .read_bulk_callback = cyberjack_read_bulk_callback,
98 .write_bulk_callback = cyberjack_write_bulk_callback,
101 struct cyberjack_private {
102 spinlock_t lock; /* Lock for SMP */
103 short rdtodo; /* Bytes still to read */
104 unsigned char wrbuf[5*64]; /* Buffer for collecting data to write */
105 short wrfilled; /* Overall data size we already got */
106 short wrsent; /* Data already sent */
109 /* do some startup allocations not currently performed by usb_serial_probe() */
110 static int cyberjack_startup (struct usb_serial *serial)
112 struct cyberjack_private *priv;
115 dbg("%s", __FUNCTION__);
117 /* allocate the private data structure */
118 priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL);
122 /* set initial values */
123 spin_lock_init(&priv->lock);
127 usb_set_serial_port_data(serial->port[0], priv);
129 init_waitqueue_head(&serial->port[0]->write_wait);
131 for (i = 0; i < serial->num_ports; ++i) {
133 serial->port[i]->interrupt_in_urb->dev = serial->dev;
134 result = usb_submit_urb(serial->port[i]->interrupt_in_urb,
137 err(" usb_submit_urb(read int) failed");
138 dbg("%s - usb_submit_urb(int urb)", __FUNCTION__);
144 static void cyberjack_shutdown (struct usb_serial *serial)
148 dbg("%s", __FUNCTION__);
150 for (i=0; i < serial->num_ports; ++i) {
151 usb_kill_urb(serial->port[i]->interrupt_in_urb);
152 /* My special items, the standard routines free my urbs */
153 kfree(usb_get_serial_port_data(serial->port[i]));
154 usb_set_serial_port_data(serial->port[i], NULL);
158 static int cyberjack_open (struct usb_serial_port *port, struct file *filp)
160 struct cyberjack_private *priv;
164 dbg("%s - port %d", __FUNCTION__, port->number);
166 dbg("%s - usb_clear_halt", __FUNCTION__ );
167 usb_clear_halt(port->serial->dev, port->write_urb->pipe);
169 /* force low_latency on so that our tty_push actually forces
170 * the data through, otherwise it is scheduled, and with high
171 * data rates (like with OHCI) data can get lost.
173 port->tty->low_latency = 1;
175 priv = usb_get_serial_port_data(port);
176 spin_lock_irqsave(&priv->lock, flags);
180 spin_unlock_irqrestore(&priv->lock, flags);
185 static void cyberjack_close (struct usb_serial_port *port, struct file *filp)
187 dbg("%s - port %d", __FUNCTION__, port->number);
189 if (port->serial->dev) {
190 /* shutdown any bulk reads that might be going on */
191 usb_kill_urb(port->write_urb);
192 usb_kill_urb(port->read_urb);
196 static int cyberjack_write (struct usb_serial_port *port, const unsigned char *buf, int count)
198 struct usb_serial *serial = port->serial;
199 struct cyberjack_private *priv = usb_get_serial_port_data(port);
204 dbg("%s - port %d", __FUNCTION__, port->number);
207 dbg("%s - write request of 0 bytes", __FUNCTION__);
211 if (port->write_urb->status == -EINPROGRESS) {
212 dbg("%s - already writing", __FUNCTION__);
216 spin_lock_irqsave(&priv->lock, flags);
218 if( (count+priv->wrfilled)>sizeof(priv->wrbuf) ) {
219 /* To much data for buffer. Reset buffer. */
221 spin_unlock_irqrestore(&priv->lock, flags);
226 memcpy (priv->wrbuf+priv->wrfilled, buf, count);
228 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count,
229 priv->wrbuf+priv->wrfilled);
230 priv->wrfilled += count;
232 if( priv->wrfilled >= 3 ) {
233 wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
234 dbg("%s - expected data: %d", __FUNCTION__, wrexpected);
236 wrexpected = sizeof(priv->wrbuf);
239 if( priv->wrfilled >= wrexpected ) {
240 /* We have enough data to begin transmission */
243 dbg("%s - transmitting data (frame 1)", __FUNCTION__);
244 length = (wrexpected > port->bulk_out_size) ? port->bulk_out_size : wrexpected;
246 memcpy (port->write_urb->transfer_buffer, priv->wrbuf, length );
250 usb_fill_bulk_urb(port->write_urb, serial->dev,
251 usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
252 port->write_urb->transfer_buffer, length,
253 ((serial->type->write_bulk_callback) ?
254 serial->type->write_bulk_callback :
255 cyberjack_write_bulk_callback),
258 /* send the data out the bulk port */
259 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
261 err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
262 /* Throw away data. No better idea what to do with it. */
265 spin_unlock_irqrestore(&priv->lock, flags);
269 dbg("%s - priv->wrsent=%d", __FUNCTION__,priv->wrsent);
270 dbg("%s - priv->wrfilled=%d", __FUNCTION__,priv->wrfilled);
272 if( priv->wrsent>=priv->wrfilled ) {
273 dbg("%s - buffer cleaned", __FUNCTION__);
274 memset( priv->wrbuf, 0, sizeof(priv->wrbuf) );
280 spin_unlock_irqrestore(&priv->lock, flags);
285 static int cyberjack_write_room( struct usb_serial_port *port )
287 return CYBERJACK_LOCAL_BUF_SIZE;
290 static void cyberjack_read_int_callback( struct urb *urb, struct pt_regs *regs )
292 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
293 struct cyberjack_private *priv = usb_get_serial_port_data(port);
294 unsigned char *data = urb->transfer_buffer;
297 dbg("%s - port %d", __FUNCTION__, port->number);
299 /* the urb might have been killed. */
303 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
305 /* React only to interrupts signaling a bulk_in transfer */
306 if( (urb->actual_length==4) && (data[0]==0x01) ) {
310 /* This is a announcement of coming bulk_ins. */
311 unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3;
313 spin_lock(&priv->lock);
315 old_rdtodo = priv->rdtodo;
317 if( (old_rdtodo+size)<(old_rdtodo) ) {
318 dbg( "To many bulk_in urbs to do." );
319 spin_unlock(&priv->lock);
323 /* "+=" is probably more fault tollerant than "=" */
324 priv->rdtodo += size;
326 dbg("%s - rdtodo: %d", __FUNCTION__, priv->rdtodo);
328 spin_unlock(&priv->lock);
331 port->read_urb->dev = port->serial->dev;
332 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
334 err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
335 dbg("%s - usb_submit_urb(read urb)", __FUNCTION__);
340 port->interrupt_in_urb->dev = port->serial->dev;
341 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
343 err(" usb_submit_urb(read int) failed");
344 dbg("%s - usb_submit_urb(int urb)", __FUNCTION__);
347 static void cyberjack_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
349 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
350 struct cyberjack_private *priv = usb_get_serial_port_data(port);
351 struct tty_struct *tty;
352 unsigned char *data = urb->transfer_buffer;
357 dbg("%s - port %d", __FUNCTION__, port->number);
359 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
361 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status);
367 dbg("%s - ignoring since device not open\n", __FUNCTION__);
370 if (urb->actual_length) {
371 for (i = 0; i < urb->actual_length ; ++i) {
372 /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
373 if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
374 tty_flip_buffer_push(tty);
376 /* this doesn't actually push the data through unless tty->low_latency is set */
377 tty_insert_flip_char(tty, data[i], 0);
379 tty_flip_buffer_push(tty);
382 spin_lock(&priv->lock);
384 /* Reduce urbs to do by one. */
385 priv->rdtodo-=urb->actual_length;
386 /* Just to be sure */
387 if ( priv->rdtodo<0 ) priv->rdtodo = 0;
390 spin_unlock(&priv->lock);
392 dbg("%s - rdtodo: %d", __FUNCTION__, todo);
394 /* Continue to read if we have still urbs to do. */
395 if( todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/ ) {
396 port->read_urb->dev = port->serial->dev;
397 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
399 err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
400 dbg("%s - usb_submit_urb(read urb)", __FUNCTION__);
404 static void cyberjack_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
406 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
407 struct cyberjack_private *priv = usb_get_serial_port_data(port);
409 dbg("%s - port %d", __FUNCTION__, port->number);
412 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
416 spin_lock(&priv->lock);
418 /* only do something if we have more data to send */
419 if( priv->wrfilled ) {
420 int length, blksize, result;
422 if (port->write_urb->status == -EINPROGRESS) {
423 dbg("%s - already writing", __FUNCTION__);
424 spin_unlock(&priv->lock);
428 dbg("%s - transmitting data (frame n)", __FUNCTION__);
430 length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
431 port->bulk_out_size : (priv->wrfilled - priv->wrsent);
433 memcpy (port->write_urb->transfer_buffer, priv->wrbuf + priv->wrsent,
435 priv->wrsent+=length;
438 usb_fill_bulk_urb(port->write_urb, port->serial->dev,
439 usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
440 port->write_urb->transfer_buffer, length,
441 ((port->serial->type->write_bulk_callback) ?
442 port->serial->type->write_bulk_callback :
443 cyberjack_write_bulk_callback),
446 /* send the data out the bulk port */
447 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
449 err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
450 /* Throw away data. No better idea what to do with it. */
456 dbg("%s - priv->wrsent=%d", __FUNCTION__,priv->wrsent);
457 dbg("%s - priv->wrfilled=%d", __FUNCTION__,priv->wrfilled);
459 blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
461 if( (priv->wrsent>=priv->wrfilled) || (priv->wrsent>=blksize) ) {
462 dbg("%s - buffer cleaned", __FUNCTION__);
463 memset( priv->wrbuf, 0, sizeof(priv->wrbuf) );
470 spin_unlock(&priv->lock);
471 schedule_work(&port->work);
474 static int __init cyberjack_init (void)
477 retval = usb_serial_register(&cyberjack_device);
479 goto failed_usb_serial_register;
480 retval = usb_register(&cyberjack_driver);
482 goto failed_usb_register;
484 info(DRIVER_VERSION " " DRIVER_AUTHOR);
489 usb_serial_deregister(&cyberjack_device);
490 failed_usb_serial_register:
494 static void __exit cyberjack_exit (void)
496 usb_deregister (&cyberjack_driver);
497 usb_serial_deregister (&cyberjack_device);
500 module_init(cyberjack_init);
501 module_exit(cyberjack_exit);
503 MODULE_AUTHOR( DRIVER_AUTHOR );
504 MODULE_DESCRIPTION( DRIVER_DESC );
505 MODULE_VERSION( DRIVER_VERSION );
506 MODULE_LICENSE("GPL");
508 module_param(debug, bool, S_IRUGO | S_IWUSR);
509 MODULE_PARM_DESC(debug, "Debug enabled or not");