1 /* 2 * REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver 3 * 4 * Copyright (C) 2001 REINER SCT 5 * Author: Matthias Bruestle 6 * 7 * Contact: support@reiner-sct.com (see MAINTAINERS) 8 * 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. 12 * 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. 17 * 18 * Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and 19 * patience. 20 * 21 * In case of problems, please write to the contact e-mail address 22 * mentioned above. 23 * 24 * Please note that later models of the cyberjack reader family are 25 * supported by a libusb-based userspace device driver. 26 * 27 * Homepage: http://www.reiner-sct.de/support/treiber_cyberjack.php#linux 28 */ 29 30 31 #include <linux/kernel.h> 32 #include <linux/errno.h> 33 #include <linux/slab.h> 34 #include <linux/tty.h> 35 #include <linux/tty_driver.h> 36 #include <linux/tty_flip.h> 37 #include <linux/module.h> 38 #include <linux/spinlock.h> 39 #include <linux/uaccess.h> 40 #include <linux/usb.h> 41 #include <linux/usb/serial.h> 42 43 #define CYBERJACK_LOCAL_BUF_SIZE 32 44 45 #define DRIVER_AUTHOR "Matthias Bruestle" 46 #define DRIVER_DESC "REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver" 47 48 49 #define CYBERJACK_VENDOR_ID 0x0C4B 50 #define CYBERJACK_PRODUCT_ID 0x0100 51 52 /* Function prototypes */ 53 static int cyberjack_port_probe(struct usb_serial_port *port); 54 static int cyberjack_port_remove(struct usb_serial_port *port); 55 static int cyberjack_open(struct tty_struct *tty, 56 struct usb_serial_port *port); 57 static void cyberjack_close(struct usb_serial_port *port); 58 static int cyberjack_write(struct tty_struct *tty, 59 struct usb_serial_port *port, const unsigned char *buf, int count); 60 static int cyberjack_write_room(struct tty_struct *tty); 61 static void cyberjack_read_int_callback(struct urb *urb); 62 static void cyberjack_read_bulk_callback(struct urb *urb); 63 static void cyberjack_write_bulk_callback(struct urb *urb); 64 65 static const struct usb_device_id id_table[] = { 66 { USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) }, 67 { } /* Terminating entry */ 68 }; 69 70 MODULE_DEVICE_TABLE(usb, id_table); 71 72 static struct usb_serial_driver cyberjack_device = { 73 .driver = { 74 .owner = THIS_MODULE, 75 .name = "cyberjack", 76 }, 77 .description = "Reiner SCT Cyberjack USB card reader", 78 .id_table = id_table, 79 .num_ports = 1, 80 .port_probe = cyberjack_port_probe, 81 .port_remove = cyberjack_port_remove, 82 .open = cyberjack_open, 83 .close = cyberjack_close, 84 .write = cyberjack_write, 85 .write_room = cyberjack_write_room, 86 .read_int_callback = cyberjack_read_int_callback, 87 .read_bulk_callback = cyberjack_read_bulk_callback, 88 .write_bulk_callback = cyberjack_write_bulk_callback, 89 }; 90 91 static struct usb_serial_driver * const serial_drivers[] = { 92 &cyberjack_device, NULL 93 }; 94 95 struct cyberjack_private { 96 spinlock_t lock; /* Lock for SMP */ 97 short rdtodo; /* Bytes still to read */ 98 unsigned char wrbuf[5*64]; /* Buffer for collecting data to write */ 99 short wrfilled; /* Overall data size we already got */ 100 short wrsent; /* Data already sent */ 101 }; 102 103 static int cyberjack_port_probe(struct usb_serial_port *port) 104 { 105 struct cyberjack_private *priv; 106 int result; 107 108 priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL); 109 if (!priv) 110 return -ENOMEM; 111 112 spin_lock_init(&priv->lock); 113 priv->rdtodo = 0; 114 priv->wrfilled = 0; 115 priv->wrsent = 0; 116 117 usb_set_serial_port_data(port, priv); 118 119 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 120 if (result) 121 dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); 122 123 return 0; 124 } 125 126 static int cyberjack_port_remove(struct usb_serial_port *port) 127 { 128 struct cyberjack_private *priv; 129 130 usb_kill_urb(port->interrupt_in_urb); 131 132 priv = usb_get_serial_port_data(port); 133 kfree(priv); 134 135 return 0; 136 } 137 138 static int cyberjack_open(struct tty_struct *tty, 139 struct usb_serial_port *port) 140 { 141 struct cyberjack_private *priv; 142 unsigned long flags; 143 int result = 0; 144 145 dev_dbg(&port->dev, "%s - usb_clear_halt\n", __func__); 146 usb_clear_halt(port->serial->dev, port->write_urb->pipe); 147 148 priv = usb_get_serial_port_data(port); 149 spin_lock_irqsave(&priv->lock, flags); 150 priv->rdtodo = 0; 151 priv->wrfilled = 0; 152 priv->wrsent = 0; 153 spin_unlock_irqrestore(&priv->lock, flags); 154 155 return result; 156 } 157 158 static void cyberjack_close(struct usb_serial_port *port) 159 { 160 usb_kill_urb(port->write_urb); 161 usb_kill_urb(port->read_urb); 162 } 163 164 static int cyberjack_write(struct tty_struct *tty, 165 struct usb_serial_port *port, const unsigned char *buf, int count) 166 { 167 struct device *dev = &port->dev; 168 struct cyberjack_private *priv = usb_get_serial_port_data(port); 169 unsigned long flags; 170 int result; 171 int wrexpected; 172 173 if (count == 0) { 174 dev_dbg(dev, "%s - write request of 0 bytes\n", __func__); 175 return 0; 176 } 177 178 if (!test_and_clear_bit(0, &port->write_urbs_free)) { 179 dev_dbg(dev, "%s - already writing\n", __func__); 180 return 0; 181 } 182 183 spin_lock_irqsave(&priv->lock, flags); 184 185 if (count+priv->wrfilled > sizeof(priv->wrbuf)) { 186 /* To much data for buffer. Reset buffer. */ 187 priv->wrfilled = 0; 188 spin_unlock_irqrestore(&priv->lock, flags); 189 set_bit(0, &port->write_urbs_free); 190 return 0; 191 } 192 193 /* Copy data */ 194 memcpy(priv->wrbuf + priv->wrfilled, buf, count); 195 196 usb_serial_debug_data(dev, __func__, count, priv->wrbuf + priv->wrfilled); 197 priv->wrfilled += count; 198 199 if (priv->wrfilled >= 3) { 200 wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3; 201 dev_dbg(dev, "%s - expected data: %d\n", __func__, wrexpected); 202 } else 203 wrexpected = sizeof(priv->wrbuf); 204 205 if (priv->wrfilled >= wrexpected) { 206 /* We have enough data to begin transmission */ 207 int length; 208 209 dev_dbg(dev, "%s - transmitting data (frame 1)\n", __func__); 210 length = (wrexpected > port->bulk_out_size) ? 211 port->bulk_out_size : wrexpected; 212 213 memcpy(port->write_urb->transfer_buffer, priv->wrbuf, length); 214 priv->wrsent = length; 215 216 /* set up our urb */ 217 port->write_urb->transfer_buffer_length = length; 218 219 /* send the data out the bulk port */ 220 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 221 if (result) { 222 dev_err(&port->dev, 223 "%s - failed submitting write urb, error %d\n", 224 __func__, result); 225 /* Throw away data. No better idea what to do with it. */ 226 priv->wrfilled = 0; 227 priv->wrsent = 0; 228 spin_unlock_irqrestore(&priv->lock, flags); 229 set_bit(0, &port->write_urbs_free); 230 return 0; 231 } 232 233 dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent); 234 dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled); 235 236 if (priv->wrsent >= priv->wrfilled) { 237 dev_dbg(dev, "%s - buffer cleaned\n", __func__); 238 memset(priv->wrbuf, 0, sizeof(priv->wrbuf)); 239 priv->wrfilled = 0; 240 priv->wrsent = 0; 241 } 242 } 243 244 spin_unlock_irqrestore(&priv->lock, flags); 245 246 return count; 247 } 248 249 static int cyberjack_write_room(struct tty_struct *tty) 250 { 251 /* FIXME: .... */ 252 return CYBERJACK_LOCAL_BUF_SIZE; 253 } 254 255 static void cyberjack_read_int_callback(struct urb *urb) 256 { 257 struct usb_serial_port *port = urb->context; 258 struct cyberjack_private *priv = usb_get_serial_port_data(port); 259 struct device *dev = &port->dev; 260 unsigned char *data = urb->transfer_buffer; 261 int status = urb->status; 262 int result; 263 264 /* the urb might have been killed. */ 265 if (status) 266 return; 267 268 usb_serial_debug_data(dev, __func__, urb->actual_length, data); 269 270 /* React only to interrupts signaling a bulk_in transfer */ 271 if (urb->actual_length == 4 && data[0] == 0x01) { 272 short old_rdtodo; 273 274 /* This is a announcement of coming bulk_ins. */ 275 unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3; 276 277 spin_lock(&priv->lock); 278 279 old_rdtodo = priv->rdtodo; 280 281 if (old_rdtodo > SHRT_MAX - size) { 282 dev_dbg(dev, "To many bulk_in urbs to do.\n"); 283 spin_unlock(&priv->lock); 284 goto resubmit; 285 } 286 287 /* "+=" is probably more fault tolerant than "=" */ 288 priv->rdtodo += size; 289 290 dev_dbg(dev, "%s - rdtodo: %d\n", __func__, priv->rdtodo); 291 292 spin_unlock(&priv->lock); 293 294 if (!old_rdtodo) { 295 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 296 if (result) 297 dev_err(dev, "%s - failed resubmitting read urb, error %d\n", 298 __func__, result); 299 dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__); 300 } 301 } 302 303 resubmit: 304 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 305 if (result) 306 dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); 307 dev_dbg(dev, "%s - usb_submit_urb(int urb)\n", __func__); 308 } 309 310 static void cyberjack_read_bulk_callback(struct urb *urb) 311 { 312 struct usb_serial_port *port = urb->context; 313 struct cyberjack_private *priv = usb_get_serial_port_data(port); 314 struct device *dev = &port->dev; 315 unsigned char *data = urb->transfer_buffer; 316 short todo; 317 int result; 318 int status = urb->status; 319 320 usb_serial_debug_data(dev, __func__, urb->actual_length, data); 321 if (status) { 322 dev_dbg(dev, "%s - nonzero read bulk status received: %d\n", 323 __func__, status); 324 return; 325 } 326 327 if (urb->actual_length) { 328 tty_insert_flip_string(&port->port, data, urb->actual_length); 329 tty_flip_buffer_push(&port->port); 330 } 331 332 spin_lock(&priv->lock); 333 334 /* Reduce urbs to do by one. */ 335 priv->rdtodo -= urb->actual_length; 336 /* Just to be sure */ 337 if (priv->rdtodo < 0) 338 priv->rdtodo = 0; 339 todo = priv->rdtodo; 340 341 spin_unlock(&priv->lock); 342 343 dev_dbg(dev, "%s - rdtodo: %d\n", __func__, todo); 344 345 /* Continue to read if we have still urbs to do. */ 346 if (todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/) { 347 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 348 if (result) 349 dev_err(dev, "%s - failed resubmitting read urb, error %d\n", 350 __func__, result); 351 dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__); 352 } 353 } 354 355 static void cyberjack_write_bulk_callback(struct urb *urb) 356 { 357 struct usb_serial_port *port = urb->context; 358 struct cyberjack_private *priv = usb_get_serial_port_data(port); 359 struct device *dev = &port->dev; 360 int status = urb->status; 361 362 set_bit(0, &port->write_urbs_free); 363 if (status) { 364 dev_dbg(dev, "%s - nonzero write bulk status received: %d\n", 365 __func__, status); 366 return; 367 } 368 369 spin_lock(&priv->lock); 370 371 /* only do something if we have more data to send */ 372 if (priv->wrfilled) { 373 int length, blksize, result; 374 375 dev_dbg(dev, "%s - transmitting data (frame n)\n", __func__); 376 377 length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ? 378 port->bulk_out_size : (priv->wrfilled - priv->wrsent); 379 380 memcpy(port->write_urb->transfer_buffer, 381 priv->wrbuf + priv->wrsent, length); 382 priv->wrsent += length; 383 384 /* set up our urb */ 385 port->write_urb->transfer_buffer_length = length; 386 387 /* send the data out the bulk port */ 388 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 389 if (result) { 390 dev_err(dev, "%s - failed submitting write urb, error %d\n", 391 __func__, result); 392 /* Throw away data. No better idea what to do with it. */ 393 priv->wrfilled = 0; 394 priv->wrsent = 0; 395 goto exit; 396 } 397 398 dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent); 399 dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled); 400 401 blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3; 402 403 if (priv->wrsent >= priv->wrfilled || 404 priv->wrsent >= blksize) { 405 dev_dbg(dev, "%s - buffer cleaned\n", __func__); 406 memset(priv->wrbuf, 0, sizeof(priv->wrbuf)); 407 priv->wrfilled = 0; 408 priv->wrsent = 0; 409 } 410 } 411 412 exit: 413 spin_unlock(&priv->lock); 414 usb_serial_port_softint(port); 415 } 416 417 module_usb_serial_driver(serial_drivers, id_table); 418 419 MODULE_AUTHOR(DRIVER_AUTHOR); 420 MODULE_DESCRIPTION(DRIVER_DESC); 421 MODULE_LICENSE("GPL"); 422