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