1 /* 2 * KOBIL USB Smart Card Terminal Driver 3 * 4 * Copyright (C) 2002 KOBIL Systems GmbH 5 * Author: Thomas Wahrenbruch 6 * 7 * Contact: linuxusb@kobil.de 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 * Supported readers: USB TWIN, KAAN Standard Plus and SecOVID Reader Plus 22 * (Adapter K), B1 Professional and KAAN Professional (Adapter B) 23 */ 24 25 26 #include <linux/kernel.h> 27 #include <linux/errno.h> 28 #include <linux/init.h> 29 #include <linux/slab.h> 30 #include <linux/tty.h> 31 #include <linux/tty_driver.h> 32 #include <linux/tty_flip.h> 33 #include <linux/module.h> 34 #include <linux/spinlock.h> 35 #include <linux/uaccess.h> 36 #include <linux/usb.h> 37 #include <linux/usb/serial.h> 38 #include <linux/ioctl.h> 39 #include "kobil_sct.h" 40 41 #define DRIVER_AUTHOR "KOBIL Systems GmbH - http://www.kobil.com" 42 #define DRIVER_DESC "KOBIL USB Smart Card Terminal Driver (experimental)" 43 44 #define KOBIL_VENDOR_ID 0x0D46 45 #define KOBIL_ADAPTER_B_PRODUCT_ID 0x2011 46 #define KOBIL_ADAPTER_K_PRODUCT_ID 0x2012 47 #define KOBIL_USBTWIN_PRODUCT_ID 0x0078 48 #define KOBIL_KAAN_SIM_PRODUCT_ID 0x0081 49 50 #define KOBIL_TIMEOUT 500 51 #define KOBIL_BUF_LENGTH 300 52 53 54 /* Function prototypes */ 55 static int kobil_port_probe(struct usb_serial_port *probe); 56 static int kobil_port_remove(struct usb_serial_port *probe); 57 static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port); 58 static void kobil_close(struct usb_serial_port *port); 59 static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port, 60 const unsigned char *buf, int count); 61 static int kobil_write_room(struct tty_struct *tty); 62 static int kobil_ioctl(struct tty_struct *tty, 63 unsigned int cmd, unsigned long arg); 64 static int kobil_tiocmget(struct tty_struct *tty); 65 static int kobil_tiocmset(struct tty_struct *tty, 66 unsigned int set, unsigned int clear); 67 static void kobil_read_int_callback(struct urb *urb); 68 static void kobil_write_int_callback(struct urb *urb); 69 static void kobil_set_termios(struct tty_struct *tty, 70 struct usb_serial_port *port, struct ktermios *old); 71 static void kobil_init_termios(struct tty_struct *tty); 72 73 static const struct usb_device_id id_table[] = { 74 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_B_PRODUCT_ID) }, 75 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_K_PRODUCT_ID) }, 76 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_USBTWIN_PRODUCT_ID) }, 77 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_KAAN_SIM_PRODUCT_ID) }, 78 { } /* Terminating entry */ 79 }; 80 MODULE_DEVICE_TABLE(usb, id_table); 81 82 static struct usb_serial_driver kobil_device = { 83 .driver = { 84 .owner = THIS_MODULE, 85 .name = "kobil", 86 }, 87 .description = "KOBIL USB smart card terminal", 88 .id_table = id_table, 89 .num_ports = 1, 90 .port_probe = kobil_port_probe, 91 .port_remove = kobil_port_remove, 92 .ioctl = kobil_ioctl, 93 .set_termios = kobil_set_termios, 94 .init_termios = kobil_init_termios, 95 .tiocmget = kobil_tiocmget, 96 .tiocmset = kobil_tiocmset, 97 .open = kobil_open, 98 .close = kobil_close, 99 .write = kobil_write, 100 .write_room = kobil_write_room, 101 .read_int_callback = kobil_read_int_callback, 102 .write_int_callback = kobil_write_int_callback, 103 }; 104 105 static struct usb_serial_driver * const serial_drivers[] = { 106 &kobil_device, NULL 107 }; 108 109 struct kobil_private { 110 unsigned char buf[KOBIL_BUF_LENGTH]; /* buffer for the APDU to send */ 111 int filled; /* index of the last char in buf */ 112 int cur_pos; /* index of the next char to send in buf */ 113 __u16 device_type; 114 }; 115 116 117 static int kobil_port_probe(struct usb_serial_port *port) 118 { 119 struct usb_serial *serial = port->serial; 120 struct kobil_private *priv; 121 122 priv = kmalloc(sizeof(struct kobil_private), GFP_KERNEL); 123 if (!priv) 124 return -ENOMEM; 125 126 priv->filled = 0; 127 priv->cur_pos = 0; 128 priv->device_type = le16_to_cpu(serial->dev->descriptor.idProduct); 129 130 switch (priv->device_type) { 131 case KOBIL_ADAPTER_B_PRODUCT_ID: 132 dev_dbg(&serial->dev->dev, "KOBIL B1 PRO / KAAN PRO detected\n"); 133 break; 134 case KOBIL_ADAPTER_K_PRODUCT_ID: 135 dev_dbg(&serial->dev->dev, "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n"); 136 break; 137 case KOBIL_USBTWIN_PRODUCT_ID: 138 dev_dbg(&serial->dev->dev, "KOBIL USBTWIN detected\n"); 139 break; 140 case KOBIL_KAAN_SIM_PRODUCT_ID: 141 dev_dbg(&serial->dev->dev, "KOBIL KAAN SIM detected\n"); 142 break; 143 } 144 usb_set_serial_port_data(port, priv); 145 146 return 0; 147 } 148 149 150 static int kobil_port_remove(struct usb_serial_port *port) 151 { 152 struct kobil_private *priv; 153 154 priv = usb_get_serial_port_data(port); 155 kfree(priv); 156 157 return 0; 158 } 159 160 static void kobil_init_termios(struct tty_struct *tty) 161 { 162 /* Default to echo off and other sane device settings */ 163 tty->termios.c_lflag = 0; 164 tty->termios.c_iflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE); 165 tty->termios.c_iflag |= IGNBRK | IGNPAR | IXOFF; 166 /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */ 167 tty->termios.c_oflag &= ~ONLCR; 168 } 169 170 static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port) 171 { 172 struct device *dev = &port->dev; 173 int result = 0; 174 struct kobil_private *priv; 175 unsigned char *transfer_buffer; 176 int transfer_buffer_length = 8; 177 178 priv = usb_get_serial_port_data(port); 179 180 /* allocate memory for transfer buffer */ 181 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 182 if (!transfer_buffer) 183 return -ENOMEM; 184 185 /* get hardware version */ 186 result = usb_control_msg(port->serial->dev, 187 usb_rcvctrlpipe(port->serial->dev, 0), 188 SUSBCRequest_GetMisc, 189 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN, 190 SUSBCR_MSC_GetHWVersion, 191 0, 192 transfer_buffer, 193 transfer_buffer_length, 194 KOBIL_TIMEOUT 195 ); 196 dev_dbg(dev, "%s - Send get_HW_version URB returns: %i\n", __func__, result); 197 dev_dbg(dev, "Harware version: %i.%i.%i\n", transfer_buffer[0], 198 transfer_buffer[1], transfer_buffer[2]); 199 200 /* get firmware version */ 201 result = usb_control_msg(port->serial->dev, 202 usb_rcvctrlpipe(port->serial->dev, 0), 203 SUSBCRequest_GetMisc, 204 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN, 205 SUSBCR_MSC_GetFWVersion, 206 0, 207 transfer_buffer, 208 transfer_buffer_length, 209 KOBIL_TIMEOUT 210 ); 211 dev_dbg(dev, "%s - Send get_FW_version URB returns: %i\n", __func__, result); 212 dev_dbg(dev, "Firmware version: %i.%i.%i\n", transfer_buffer[0], 213 transfer_buffer[1], transfer_buffer[2]); 214 215 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 216 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) { 217 /* Setting Baudrate, Parity and Stopbits */ 218 result = usb_control_msg(port->serial->dev, 219 usb_rcvctrlpipe(port->serial->dev, 0), 220 SUSBCRequest_SetBaudRateParityAndStopBits, 221 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 222 SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity | 223 SUSBCR_SPASB_1StopBit, 224 0, 225 transfer_buffer, 226 0, 227 KOBIL_TIMEOUT 228 ); 229 dev_dbg(dev, "%s - Send set_baudrate URB returns: %i\n", __func__, result); 230 231 /* reset all queues */ 232 result = usb_control_msg(port->serial->dev, 233 usb_rcvctrlpipe(port->serial->dev, 0), 234 SUSBCRequest_Misc, 235 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 236 SUSBCR_MSC_ResetAllQueues, 237 0, 238 transfer_buffer, 239 0, 240 KOBIL_TIMEOUT 241 ); 242 dev_dbg(dev, "%s - Send reset_all_queues URB returns: %i\n", __func__, result); 243 } 244 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 245 priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 246 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 247 /* start reading (Adapter B 'cause PNP string) */ 248 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 249 dev_dbg(dev, "%s - Send read URB returns: %i\n", __func__, result); 250 } 251 252 kfree(transfer_buffer); 253 return 0; 254 } 255 256 257 static void kobil_close(struct usb_serial_port *port) 258 { 259 /* FIXME: Add rts/dtr methods */ 260 usb_kill_urb(port->interrupt_out_urb); 261 usb_kill_urb(port->interrupt_in_urb); 262 } 263 264 265 static void kobil_read_int_callback(struct urb *urb) 266 { 267 int result; 268 struct usb_serial_port *port = urb->context; 269 unsigned char *data = urb->transfer_buffer; 270 int status = urb->status; 271 272 if (status) { 273 dev_dbg(&port->dev, "%s - Read int status not zero: %d\n", __func__, status); 274 return; 275 } 276 277 if (urb->actual_length) { 278 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, 279 data); 280 tty_insert_flip_string(&port->port, data, urb->actual_length); 281 tty_flip_buffer_push(&port->port); 282 } 283 284 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 285 dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result); 286 } 287 288 289 static void kobil_write_int_callback(struct urb *urb) 290 { 291 } 292 293 294 static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port, 295 const unsigned char *buf, int count) 296 { 297 int length = 0; 298 int result = 0; 299 int todo = 0; 300 struct kobil_private *priv; 301 302 if (count == 0) { 303 dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__); 304 return 0; 305 } 306 307 priv = usb_get_serial_port_data(port); 308 309 if (count > (KOBIL_BUF_LENGTH - priv->filled)) { 310 dev_dbg(&port->dev, "%s - Error: write request bigger than buffer size\n", __func__); 311 return -ENOMEM; 312 } 313 314 /* Copy data to buffer */ 315 memcpy(priv->buf + priv->filled, buf, count); 316 usb_serial_debug_data(&port->dev, __func__, count, priv->buf + priv->filled); 317 priv->filled = priv->filled + count; 318 319 /* only send complete block. TWIN, KAAN SIM and adapter K 320 use the same protocol. */ 321 if (((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) || 322 ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4)))) { 323 /* stop reading (except TWIN and KAAN SIM) */ 324 if ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) 325 || (priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID)) 326 usb_kill_urb(port->interrupt_in_urb); 327 328 todo = priv->filled - priv->cur_pos; 329 330 while (todo > 0) { 331 /* max 8 byte in one urb (endpoint size) */ 332 length = min(todo, port->interrupt_out_size); 333 /* copy data to transfer buffer */ 334 memcpy(port->interrupt_out_buffer, 335 priv->buf + priv->cur_pos, length); 336 port->interrupt_out_urb->transfer_buffer_length = length; 337 338 priv->cur_pos = priv->cur_pos + length; 339 result = usb_submit_urb(port->interrupt_out_urb, GFP_NOIO); 340 dev_dbg(&port->dev, "%s - Send write URB returns: %i\n", __func__, result); 341 todo = priv->filled - priv->cur_pos; 342 343 if (todo > 0) 344 msleep(24); 345 } 346 347 priv->filled = 0; 348 priv->cur_pos = 0; 349 350 /* start reading (except TWIN and KAAN SIM) */ 351 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 352 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) { 353 result = usb_submit_urb(port->interrupt_in_urb, 354 GFP_NOIO); 355 dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result); 356 } 357 } 358 return count; 359 } 360 361 362 static int kobil_write_room(struct tty_struct *tty) 363 { 364 /* FIXME */ 365 return 8; 366 } 367 368 369 static int kobil_tiocmget(struct tty_struct *tty) 370 { 371 struct usb_serial_port *port = tty->driver_data; 372 struct kobil_private *priv; 373 int result; 374 unsigned char *transfer_buffer; 375 int transfer_buffer_length = 8; 376 377 priv = usb_get_serial_port_data(port); 378 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID 379 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 380 /* This device doesn't support ioctl calls */ 381 return -EINVAL; 382 } 383 384 /* allocate memory for transfer buffer */ 385 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 386 if (!transfer_buffer) 387 return -ENOMEM; 388 389 result = usb_control_msg(port->serial->dev, 390 usb_rcvctrlpipe(port->serial->dev, 0), 391 SUSBCRequest_GetStatusLineState, 392 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN, 393 0, 394 0, 395 transfer_buffer, 396 transfer_buffer_length, 397 KOBIL_TIMEOUT); 398 399 dev_dbg(&port->dev, "%s - Send get_status_line_state URB returns: %i. Statusline: %02x\n", 400 __func__, result, transfer_buffer[0]); 401 402 result = 0; 403 if ((transfer_buffer[0] & SUSBCR_GSL_DSR) != 0) 404 result = TIOCM_DSR; 405 kfree(transfer_buffer); 406 return result; 407 } 408 409 static int kobil_tiocmset(struct tty_struct *tty, 410 unsigned int set, unsigned int clear) 411 { 412 struct usb_serial_port *port = tty->driver_data; 413 struct device *dev = &port->dev; 414 struct kobil_private *priv; 415 int result; 416 int dtr = 0; 417 int rts = 0; 418 unsigned char *transfer_buffer; 419 int transfer_buffer_length = 8; 420 421 /* FIXME: locking ? */ 422 priv = usb_get_serial_port_data(port); 423 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID 424 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 425 /* This device doesn't support ioctl calls */ 426 return -EINVAL; 427 } 428 429 /* allocate memory for transfer buffer */ 430 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 431 if (!transfer_buffer) 432 return -ENOMEM; 433 434 if (set & TIOCM_RTS) 435 rts = 1; 436 if (set & TIOCM_DTR) 437 dtr = 1; 438 if (clear & TIOCM_RTS) 439 rts = 0; 440 if (clear & TIOCM_DTR) 441 dtr = 0; 442 443 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) { 444 if (dtr != 0) 445 dev_dbg(dev, "%s - Setting DTR\n", __func__); 446 else 447 dev_dbg(dev, "%s - Clearing DTR\n", __func__); 448 result = usb_control_msg(port->serial->dev, 449 usb_rcvctrlpipe(port->serial->dev, 0), 450 SUSBCRequest_SetStatusLinesOrQueues, 451 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 452 ((dtr != 0) ? SUSBCR_SSL_SETDTR : SUSBCR_SSL_CLRDTR), 453 0, 454 transfer_buffer, 455 0, 456 KOBIL_TIMEOUT); 457 } else { 458 if (rts != 0) 459 dev_dbg(dev, "%s - Setting RTS\n", __func__); 460 else 461 dev_dbg(dev, "%s - Clearing RTS\n", __func__); 462 result = usb_control_msg(port->serial->dev, 463 usb_rcvctrlpipe(port->serial->dev, 0), 464 SUSBCRequest_SetStatusLinesOrQueues, 465 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 466 ((rts != 0) ? SUSBCR_SSL_SETRTS : SUSBCR_SSL_CLRRTS), 467 0, 468 transfer_buffer, 469 0, 470 KOBIL_TIMEOUT); 471 } 472 dev_dbg(dev, "%s - Send set_status_line URB returns: %i\n", __func__, result); 473 kfree(transfer_buffer); 474 return (result < 0) ? result : 0; 475 } 476 477 static void kobil_set_termios(struct tty_struct *tty, 478 struct usb_serial_port *port, struct ktermios *old) 479 { 480 struct kobil_private *priv; 481 int result; 482 unsigned short urb_val = 0; 483 int c_cflag = tty->termios.c_cflag; 484 speed_t speed; 485 486 priv = usb_get_serial_port_data(port); 487 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 488 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 489 /* This device doesn't support ioctl calls */ 490 tty_termios_copy_hw(&tty->termios, old); 491 return; 492 } 493 494 speed = tty_get_baud_rate(tty); 495 switch (speed) { 496 case 1200: 497 urb_val = SUSBCR_SBR_1200; 498 break; 499 default: 500 speed = 9600; 501 case 9600: 502 urb_val = SUSBCR_SBR_9600; 503 break; 504 } 505 urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits : 506 SUSBCR_SPASB_1StopBit; 507 if (c_cflag & PARENB) { 508 if (c_cflag & PARODD) 509 urb_val |= SUSBCR_SPASB_OddParity; 510 else 511 urb_val |= SUSBCR_SPASB_EvenParity; 512 } else 513 urb_val |= SUSBCR_SPASB_NoParity; 514 tty->termios.c_cflag &= ~CMSPAR; 515 tty_encode_baud_rate(tty, speed, speed); 516 517 result = usb_control_msg(port->serial->dev, 518 usb_rcvctrlpipe(port->serial->dev, 0), 519 SUSBCRequest_SetBaudRateParityAndStopBits, 520 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 521 urb_val, 522 0, 523 NULL, 524 0, 525 KOBIL_TIMEOUT 526 ); 527 } 528 529 static int kobil_ioctl(struct tty_struct *tty, 530 unsigned int cmd, unsigned long arg) 531 { 532 struct usb_serial_port *port = tty->driver_data; 533 struct kobil_private *priv = usb_get_serial_port_data(port); 534 unsigned char *transfer_buffer; 535 int transfer_buffer_length = 8; 536 int result; 537 538 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 539 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) 540 /* This device doesn't support ioctl calls */ 541 return -ENOIOCTLCMD; 542 543 switch (cmd) { 544 case TCFLSH: 545 transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL); 546 if (!transfer_buffer) 547 return -ENOBUFS; 548 549 result = usb_control_msg(port->serial->dev, 550 usb_rcvctrlpipe(port->serial->dev, 0), 551 SUSBCRequest_Misc, 552 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 553 SUSBCR_MSC_ResetAllQueues, 554 0, 555 NULL, /* transfer_buffer, */ 556 0, 557 KOBIL_TIMEOUT 558 ); 559 560 dev_dbg(&port->dev, 561 "%s - Send reset_all_queues (FLUSH) URB returns: %i", __func__, result); 562 kfree(transfer_buffer); 563 return (result < 0) ? -EIO: 0; 564 default: 565 return -ENOIOCTLCMD; 566 } 567 } 568 569 module_usb_serial_driver(serial_drivers, id_table); 570 571 MODULE_AUTHOR(DRIVER_AUTHOR); 572 MODULE_DESCRIPTION(DRIVER_DESC); 573 MODULE_LICENSE("GPL"); 574