1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * KOBIL USB Smart Card Terminal Driver 4 * 5 * Copyright (C) 2002 KOBIL Systems GmbH 6 * Author: Thomas Wahrenbruch 7 * 8 * Contact: linuxusb@kobil.de 9 * 10 * This program is largely derived from work by the linux-usb group 11 * and associated source files. Please see the usb/serial files for 12 * individual credits and copyrights. 13 * 14 * Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and 15 * patience. 16 * 17 * Supported readers: USB TWIN, KAAN Standard Plus and SecOVID Reader Plus 18 * (Adapter K), B1 Professional and KAAN Professional (Adapter B) 19 */ 20 21 22 #include <linux/kernel.h> 23 #include <linux/errno.h> 24 #include <linux/slab.h> 25 #include <linux/tty.h> 26 #include <linux/tty_driver.h> 27 #include <linux/tty_flip.h> 28 #include <linux/module.h> 29 #include <linux/spinlock.h> 30 #include <linux/uaccess.h> 31 #include <linux/usb.h> 32 #include <linux/usb/serial.h> 33 #include <linux/ioctl.h> 34 #include "kobil_sct.h" 35 36 #define DRIVER_AUTHOR "KOBIL Systems GmbH - http://www.kobil.com" 37 #define DRIVER_DESC "KOBIL USB Smart Card Terminal Driver (experimental)" 38 39 #define KOBIL_VENDOR_ID 0x0D46 40 #define KOBIL_ADAPTER_B_PRODUCT_ID 0x2011 41 #define KOBIL_ADAPTER_K_PRODUCT_ID 0x2012 42 #define KOBIL_USBTWIN_PRODUCT_ID 0x0078 43 #define KOBIL_KAAN_SIM_PRODUCT_ID 0x0081 44 45 #define KOBIL_TIMEOUT 500 46 #define KOBIL_BUF_LENGTH 300 47 48 49 /* Function prototypes */ 50 static int kobil_port_probe(struct usb_serial_port *probe); 51 static void kobil_port_remove(struct usb_serial_port *probe); 52 static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port); 53 static void kobil_close(struct usb_serial_port *port); 54 static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port, 55 const unsigned char *buf, int count); 56 static unsigned int kobil_write_room(struct tty_struct *tty); 57 static int kobil_ioctl(struct tty_struct *tty, 58 unsigned int cmd, unsigned long arg); 59 static int kobil_tiocmget(struct tty_struct *tty); 60 static int kobil_tiocmset(struct tty_struct *tty, 61 unsigned int set, unsigned int clear); 62 static void kobil_read_int_callback(struct urb *urb); 63 static void kobil_write_int_callback(struct urb *urb); 64 static void kobil_set_termios(struct tty_struct *tty, 65 struct usb_serial_port *port, 66 const struct ktermios *old); 67 static void kobil_init_termios(struct tty_struct *tty); 68 69 static const struct usb_device_id id_table[] = { 70 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_B_PRODUCT_ID) }, 71 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_K_PRODUCT_ID) }, 72 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_USBTWIN_PRODUCT_ID) }, 73 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_KAAN_SIM_PRODUCT_ID) }, 74 { } /* Terminating entry */ 75 }; 76 MODULE_DEVICE_TABLE(usb, id_table); 77 78 static struct usb_serial_driver kobil_device = { 79 .driver = { 80 .name = "kobil", 81 }, 82 .description = "KOBIL USB smart card terminal", 83 .id_table = id_table, 84 .num_ports = 1, 85 .num_interrupt_out = 1, 86 .port_probe = kobil_port_probe, 87 .port_remove = kobil_port_remove, 88 .ioctl = kobil_ioctl, 89 .set_termios = kobil_set_termios, 90 .init_termios = kobil_init_termios, 91 .tiocmget = kobil_tiocmget, 92 .tiocmset = kobil_tiocmset, 93 .open = kobil_open, 94 .close = kobil_close, 95 .write = kobil_write, 96 .write_room = kobil_write_room, 97 .read_int_callback = kobil_read_int_callback, 98 .write_int_callback = kobil_write_int_callback, 99 }; 100 101 static struct usb_serial_driver * const serial_drivers[] = { 102 &kobil_device, NULL 103 }; 104 105 struct kobil_private { 106 unsigned char buf[KOBIL_BUF_LENGTH]; /* buffer for the APDU to send */ 107 int filled; /* index of the last char in buf */ 108 int cur_pos; /* index of the next char to send in buf */ 109 __u16 device_type; 110 }; 111 112 113 static int kobil_port_probe(struct usb_serial_port *port) 114 { 115 struct usb_serial *serial = port->serial; 116 struct kobil_private *priv; 117 118 priv = kmalloc(sizeof(struct kobil_private), GFP_KERNEL); 119 if (!priv) 120 return -ENOMEM; 121 122 priv->filled = 0; 123 priv->cur_pos = 0; 124 priv->device_type = le16_to_cpu(serial->dev->descriptor.idProduct); 125 126 switch (priv->device_type) { 127 case KOBIL_ADAPTER_B_PRODUCT_ID: 128 dev_dbg(&serial->dev->dev, "KOBIL B1 PRO / KAAN PRO detected\n"); 129 break; 130 case KOBIL_ADAPTER_K_PRODUCT_ID: 131 dev_dbg(&serial->dev->dev, "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n"); 132 break; 133 case KOBIL_USBTWIN_PRODUCT_ID: 134 dev_dbg(&serial->dev->dev, "KOBIL USBTWIN detected\n"); 135 break; 136 case KOBIL_KAAN_SIM_PRODUCT_ID: 137 dev_dbg(&serial->dev->dev, "KOBIL KAAN SIM detected\n"); 138 break; 139 } 140 usb_set_serial_port_data(port, priv); 141 142 return 0; 143 } 144 145 146 static void kobil_port_remove(struct usb_serial_port *port) 147 { 148 struct kobil_private *priv; 149 150 priv = usb_get_serial_port_data(port); 151 kfree(priv); 152 } 153 154 static void kobil_init_termios(struct tty_struct *tty) 155 { 156 /* Default to echo off and other sane device settings */ 157 tty->termios.c_lflag = 0; 158 tty->termios.c_iflag = IGNBRK | IGNPAR | IXOFF; 159 /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */ 160 tty->termios.c_oflag &= ~ONLCR; 161 } 162 163 static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port) 164 { 165 struct device *dev = &port->dev; 166 int result = 0; 167 struct kobil_private *priv; 168 unsigned char *transfer_buffer; 169 int transfer_buffer_length = 8; 170 171 priv = usb_get_serial_port_data(port); 172 173 /* allocate memory for transfer buffer */ 174 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 175 if (!transfer_buffer) 176 return -ENOMEM; 177 178 /* get hardware version */ 179 result = usb_control_msg(port->serial->dev, 180 usb_rcvctrlpipe(port->serial->dev, 0), 181 SUSBCRequest_GetMisc, 182 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN, 183 SUSBCR_MSC_GetHWVersion, 184 0, 185 transfer_buffer, 186 transfer_buffer_length, 187 KOBIL_TIMEOUT 188 ); 189 dev_dbg(dev, "%s - Send get_HW_version URB returns: %i\n", __func__, result); 190 if (result >= 3) { 191 dev_dbg(dev, "Hardware version: %i.%i.%i\n", transfer_buffer[0], 192 transfer_buffer[1], transfer_buffer[2]); 193 } 194 195 /* get firmware version */ 196 result = usb_control_msg(port->serial->dev, 197 usb_rcvctrlpipe(port->serial->dev, 0), 198 SUSBCRequest_GetMisc, 199 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN, 200 SUSBCR_MSC_GetFWVersion, 201 0, 202 transfer_buffer, 203 transfer_buffer_length, 204 KOBIL_TIMEOUT 205 ); 206 dev_dbg(dev, "%s - Send get_FW_version URB returns: %i\n", __func__, result); 207 if (result >= 3) { 208 dev_dbg(dev, "Firmware version: %i.%i.%i\n", transfer_buffer[0], 209 transfer_buffer[1], transfer_buffer[2]); 210 } 211 212 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 213 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) { 214 /* Setting Baudrate, Parity and Stopbits */ 215 result = usb_control_msg(port->serial->dev, 216 usb_sndctrlpipe(port->serial->dev, 0), 217 SUSBCRequest_SetBaudRateParityAndStopBits, 218 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 219 SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity | 220 SUSBCR_SPASB_1StopBit, 221 0, 222 NULL, 223 0, 224 KOBIL_TIMEOUT 225 ); 226 dev_dbg(dev, "%s - Send set_baudrate URB returns: %i\n", __func__, result); 227 228 /* reset all queues */ 229 result = usb_control_msg(port->serial->dev, 230 usb_sndctrlpipe(port->serial->dev, 0), 231 SUSBCRequest_Misc, 232 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 233 SUSBCR_MSC_ResetAllQueues, 234 0, 235 NULL, 236 0, 237 KOBIL_TIMEOUT 238 ); 239 dev_dbg(dev, "%s - Send reset_all_queues URB returns: %i\n", __func__, result); 240 } 241 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 242 priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 243 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 244 /* start reading (Adapter B 'cause PNP string) */ 245 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 246 dev_dbg(dev, "%s - Send read URB returns: %i\n", __func__, result); 247 } 248 249 kfree(transfer_buffer); 250 return 0; 251 } 252 253 254 static void kobil_close(struct usb_serial_port *port) 255 { 256 /* FIXME: Add rts/dtr methods */ 257 usb_kill_urb(port->interrupt_out_urb); 258 usb_kill_urb(port->interrupt_in_urb); 259 } 260 261 262 static void kobil_read_int_callback(struct urb *urb) 263 { 264 int result; 265 struct usb_serial_port *port = urb->context; 266 unsigned char *data = urb->transfer_buffer; 267 int status = urb->status; 268 269 if (status) { 270 dev_dbg(&port->dev, "%s - Read int status not zero: %d\n", __func__, status); 271 return; 272 } 273 274 if (urb->actual_length) { 275 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, 276 data); 277 tty_insert_flip_string(&port->port, data, urb->actual_length); 278 tty_flip_buffer_push(&port->port); 279 } 280 281 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 282 dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result); 283 } 284 285 286 static void kobil_write_int_callback(struct urb *urb) 287 { 288 } 289 290 291 static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port, 292 const unsigned char *buf, int count) 293 { 294 int length = 0; 295 int result = 0; 296 int todo = 0; 297 struct kobil_private *priv; 298 299 if (count == 0) { 300 dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__); 301 return 0; 302 } 303 304 priv = usb_get_serial_port_data(port); 305 306 if (count > (KOBIL_BUF_LENGTH - priv->filled)) { 307 dev_dbg(&port->dev, "%s - Error: write request bigger than buffer size\n", __func__); 308 return -ENOMEM; 309 } 310 311 /* Copy data to buffer */ 312 memcpy(priv->buf + priv->filled, buf, count); 313 usb_serial_debug_data(&port->dev, __func__, count, priv->buf + priv->filled); 314 priv->filled = priv->filled + count; 315 316 /* only send complete block. TWIN, KAAN SIM and adapter K 317 use the same protocol. */ 318 if (((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) || 319 ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4)))) { 320 /* stop reading (except TWIN and KAAN SIM) */ 321 if ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) 322 || (priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID)) 323 usb_kill_urb(port->interrupt_in_urb); 324 325 todo = priv->filled - priv->cur_pos; 326 327 while (todo > 0) { 328 /* max 8 byte in one urb (endpoint size) */ 329 length = min(todo, port->interrupt_out_size); 330 /* copy data to transfer buffer */ 331 memcpy(port->interrupt_out_buffer, 332 priv->buf + priv->cur_pos, length); 333 port->interrupt_out_urb->transfer_buffer_length = length; 334 335 priv->cur_pos = priv->cur_pos + length; 336 result = usb_submit_urb(port->interrupt_out_urb, 337 GFP_ATOMIC); 338 dev_dbg(&port->dev, "%s - Send write URB returns: %i\n", __func__, result); 339 todo = priv->filled - priv->cur_pos; 340 341 if (todo > 0) 342 msleep(24); 343 } 344 345 priv->filled = 0; 346 priv->cur_pos = 0; 347 348 /* start reading (except TWIN and KAAN SIM) */ 349 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 350 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) { 351 result = usb_submit_urb(port->interrupt_in_urb, 352 GFP_ATOMIC); 353 dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result); 354 } 355 } 356 return count; 357 } 358 359 360 static unsigned int kobil_write_room(struct tty_struct *tty) 361 { 362 /* FIXME */ 363 return 8; 364 } 365 366 367 static int kobil_tiocmget(struct tty_struct *tty) 368 { 369 struct usb_serial_port *port = tty->driver_data; 370 struct kobil_private *priv; 371 int result; 372 unsigned char *transfer_buffer; 373 int transfer_buffer_length = 8; 374 375 priv = usb_get_serial_port_data(port); 376 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID 377 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 378 /* This device doesn't support ioctl calls */ 379 return -EINVAL; 380 } 381 382 /* allocate memory for transfer buffer */ 383 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 384 if (!transfer_buffer) 385 return -ENOMEM; 386 387 result = usb_control_msg(port->serial->dev, 388 usb_rcvctrlpipe(port->serial->dev, 0), 389 SUSBCRequest_GetStatusLineState, 390 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN, 391 0, 392 0, 393 transfer_buffer, 394 transfer_buffer_length, 395 KOBIL_TIMEOUT); 396 397 dev_dbg(&port->dev, "Send get_status_line_state URB returns: %i\n", 398 result); 399 if (result < 1) { 400 if (result >= 0) 401 result = -EIO; 402 goto out_free; 403 } 404 405 dev_dbg(&port->dev, "Statusline: %02x\n", transfer_buffer[0]); 406 407 result = 0; 408 if ((transfer_buffer[0] & SUSBCR_GSL_DSR) != 0) 409 result = TIOCM_DSR; 410 out_free: 411 kfree(transfer_buffer); 412 return result; 413 } 414 415 static int kobil_tiocmset(struct tty_struct *tty, 416 unsigned int set, unsigned int clear) 417 { 418 struct usb_serial_port *port = tty->driver_data; 419 struct device *dev = &port->dev; 420 struct kobil_private *priv; 421 int result; 422 int dtr = 0; 423 int rts = 0; 424 425 /* FIXME: locking ? */ 426 priv = usb_get_serial_port_data(port); 427 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID 428 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 429 /* This device doesn't support ioctl calls */ 430 return -EINVAL; 431 } 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_sndctrlpipe(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 NULL, 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_sndctrlpipe(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 NULL, 468 0, 469 KOBIL_TIMEOUT); 470 } 471 dev_dbg(dev, "%s - Send set_status_line URB returns: %i\n", __func__, result); 472 return (result < 0) ? result : 0; 473 } 474 475 static void kobil_set_termios(struct tty_struct *tty, 476 struct usb_serial_port *port, 477 const 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 fallthrough; 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_sndctrlpipe(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 if (result) { 528 dev_err(&port->dev, "failed to update line settings: %d\n", 529 result); 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