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