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