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 144 dev_dbg(&port->dev, "%s - usb_clear_halt\n", __func__); 145 usb_clear_halt(port->serial->dev, port->write_urb->pipe); 146 147 priv = usb_get_serial_port_data(port); 148 spin_lock_irqsave(&priv->lock, flags); 149 priv->rdtodo = 0; 150 priv->wrfilled = 0; 151 priv->wrsent = 0; 152 spin_unlock_irqrestore(&priv->lock, flags); 153 154 return 0; 155 } 156 157 static void cyberjack_close(struct usb_serial_port *port) 158 { 159 usb_kill_urb(port->write_urb); 160 usb_kill_urb(port->read_urb); 161 } 162 163 static int cyberjack_write(struct tty_struct *tty, 164 struct usb_serial_port *port, const unsigned char *buf, int count) 165 { 166 struct device *dev = &port->dev; 167 struct cyberjack_private *priv = usb_get_serial_port_data(port); 168 unsigned long flags; 169 int result; 170 int wrexpected; 171 172 if (count == 0) { 173 dev_dbg(dev, "%s - write request of 0 bytes\n", __func__); 174 return 0; 175 } 176 177 if (!test_and_clear_bit(0, &port->write_urbs_free)) { 178 dev_dbg(dev, "%s - already writing\n", __func__); 179 return 0; 180 } 181 182 spin_lock_irqsave(&priv->lock, flags); 183 184 if (count+priv->wrfilled > sizeof(priv->wrbuf)) { 185 /* To much data for buffer. Reset buffer. */ 186 priv->wrfilled = 0; 187 spin_unlock_irqrestore(&priv->lock, flags); 188 set_bit(0, &port->write_urbs_free); 189 return 0; 190 } 191 192 /* Copy data */ 193 memcpy(priv->wrbuf + priv->wrfilled, buf, count); 194 195 usb_serial_debug_data(dev, __func__, count, priv->wrbuf + priv->wrfilled); 196 priv->wrfilled += count; 197 198 if (priv->wrfilled >= 3) { 199 wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3; 200 dev_dbg(dev, "%s - expected data: %d\n", __func__, wrexpected); 201 } else 202 wrexpected = sizeof(priv->wrbuf); 203 204 if (priv->wrfilled >= wrexpected) { 205 /* We have enough data to begin transmission */ 206 int length; 207 208 dev_dbg(dev, "%s - transmitting data (frame 1)\n", __func__); 209 length = (wrexpected > port->bulk_out_size) ? 210 port->bulk_out_size : wrexpected; 211 212 memcpy(port->write_urb->transfer_buffer, priv->wrbuf, length); 213 priv->wrsent = length; 214 215 /* set up our urb */ 216 port->write_urb->transfer_buffer_length = length; 217 218 /* send the data out the bulk port */ 219 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 220 if (result) { 221 dev_err(&port->dev, 222 "%s - failed submitting write urb, error %d\n", 223 __func__, result); 224 /* Throw away data. No better idea what to do with it. */ 225 priv->wrfilled = 0; 226 priv->wrsent = 0; 227 spin_unlock_irqrestore(&priv->lock, flags); 228 set_bit(0, &port->write_urbs_free); 229 return 0; 230 } 231 232 dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent); 233 dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled); 234 235 if (priv->wrsent >= priv->wrfilled) { 236 dev_dbg(dev, "%s - buffer cleaned\n", __func__); 237 memset(priv->wrbuf, 0, sizeof(priv->wrbuf)); 238 priv->wrfilled = 0; 239 priv->wrsent = 0; 240 } 241 } 242 243 spin_unlock_irqrestore(&priv->lock, flags); 244 245 return count; 246 } 247 248 static int cyberjack_write_room(struct tty_struct *tty) 249 { 250 /* FIXME: .... */ 251 return CYBERJACK_LOCAL_BUF_SIZE; 252 } 253 254 static void cyberjack_read_int_callback(struct urb *urb) 255 { 256 struct usb_serial_port *port = urb->context; 257 struct cyberjack_private *priv = usb_get_serial_port_data(port); 258 struct device *dev = &port->dev; 259 unsigned char *data = urb->transfer_buffer; 260 int status = urb->status; 261 int result; 262 263 /* the urb might have been killed. */ 264 if (status) 265 return; 266 267 usb_serial_debug_data(dev, __func__, urb->actual_length, data); 268 269 /* React only to interrupts signaling a bulk_in transfer */ 270 if (urb->actual_length == 4 && data[0] == 0x01) { 271 short old_rdtodo; 272 273 /* This is a announcement of coming bulk_ins. */ 274 unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3; 275 276 spin_lock(&priv->lock); 277 278 old_rdtodo = priv->rdtodo; 279 280 if (old_rdtodo > SHRT_MAX - size) { 281 dev_dbg(dev, "To many bulk_in urbs to do.\n"); 282 spin_unlock(&priv->lock); 283 goto resubmit; 284 } 285 286 /* "+=" is probably more fault tolerant than "=" */ 287 priv->rdtodo += size; 288 289 dev_dbg(dev, "%s - rdtodo: %d\n", __func__, priv->rdtodo); 290 291 spin_unlock(&priv->lock); 292 293 if (!old_rdtodo) { 294 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 295 if (result) 296 dev_err(dev, "%s - failed resubmitting read urb, error %d\n", 297 __func__, result); 298 dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__); 299 } 300 } 301 302 resubmit: 303 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 304 if (result) 305 dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); 306 dev_dbg(dev, "%s - usb_submit_urb(int urb)\n", __func__); 307 } 308 309 static void cyberjack_read_bulk_callback(struct urb *urb) 310 { 311 struct usb_serial_port *port = urb->context; 312 struct cyberjack_private *priv = usb_get_serial_port_data(port); 313 struct device *dev = &port->dev; 314 unsigned char *data = urb->transfer_buffer; 315 short todo; 316 int result; 317 int status = urb->status; 318 319 usb_serial_debug_data(dev, __func__, urb->actual_length, data); 320 if (status) { 321 dev_dbg(dev, "%s - nonzero read bulk status received: %d\n", 322 __func__, status); 323 return; 324 } 325 326 if (urb->actual_length) { 327 tty_insert_flip_string(&port->port, data, urb->actual_length); 328 tty_flip_buffer_push(&port->port); 329 } 330 331 spin_lock(&priv->lock); 332 333 /* Reduce urbs to do by one. */ 334 priv->rdtodo -= urb->actual_length; 335 /* Just to be sure */ 336 if (priv->rdtodo < 0) 337 priv->rdtodo = 0; 338 todo = priv->rdtodo; 339 340 spin_unlock(&priv->lock); 341 342 dev_dbg(dev, "%s - rdtodo: %d\n", __func__, todo); 343 344 /* Continue to read if we have still urbs to do. */ 345 if (todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/) { 346 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 347 if (result) 348 dev_err(dev, "%s - failed resubmitting read urb, error %d\n", 349 __func__, result); 350 dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__); 351 } 352 } 353 354 static void cyberjack_write_bulk_callback(struct urb *urb) 355 { 356 struct usb_serial_port *port = urb->context; 357 struct cyberjack_private *priv = usb_get_serial_port_data(port); 358 struct device *dev = &port->dev; 359 int status = urb->status; 360 361 set_bit(0, &port->write_urbs_free); 362 if (status) { 363 dev_dbg(dev, "%s - nonzero write bulk status received: %d\n", 364 __func__, status); 365 return; 366 } 367 368 spin_lock(&priv->lock); 369 370 /* only do something if we have more data to send */ 371 if (priv->wrfilled) { 372 int length, blksize, result; 373 374 dev_dbg(dev, "%s - transmitting data (frame n)\n", __func__); 375 376 length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ? 377 port->bulk_out_size : (priv->wrfilled - priv->wrsent); 378 379 memcpy(port->write_urb->transfer_buffer, 380 priv->wrbuf + priv->wrsent, length); 381 priv->wrsent += length; 382 383 /* set up our urb */ 384 port->write_urb->transfer_buffer_length = length; 385 386 /* send the data out the bulk port */ 387 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 388 if (result) { 389 dev_err(dev, "%s - failed submitting write urb, error %d\n", 390 __func__, result); 391 /* Throw away data. No better idea what to do with it. */ 392 priv->wrfilled = 0; 393 priv->wrsent = 0; 394 goto exit; 395 } 396 397 dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent); 398 dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled); 399 400 blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3; 401 402 if (priv->wrsent >= priv->wrfilled || 403 priv->wrsent >= blksize) { 404 dev_dbg(dev, "%s - buffer cleaned\n", __func__); 405 memset(priv->wrbuf, 0, sizeof(priv->wrbuf)); 406 priv->wrfilled = 0; 407 priv->wrsent = 0; 408 } 409 } 410 411 exit: 412 spin_unlock(&priv->lock); 413 usb_serial_port_softint(port); 414 } 415 416 module_usb_serial_driver(serial_drivers, id_table); 417 418 MODULE_AUTHOR(DRIVER_AUTHOR); 419 MODULE_DESCRIPTION(DRIVER_DESC); 420 MODULE_LICENSE("GPL"); 421