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 static int kobil_ctrl_send(struct usb_serial_port *port, u8 req, u16 val) 113 { 114 return usb_control_msg(port->serial->dev, 115 usb_sndctrlpipe(port->serial->dev, 0), 116 req, USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, 117 val, 0, NULL, 0, KOBIL_TIMEOUT); 118 } 119 120 static int kobil_ctrl_recv(struct usb_serial_port *port, u8 req, u16 val, void *buf, u16 size) 121 { 122 return usb_control_msg(port->serial->dev, 123 usb_rcvctrlpipe(port->serial->dev, 0), 124 req, USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN, 125 val, 0, buf, size, KOBIL_TIMEOUT); 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 void 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 169 static void kobil_init_termios(struct tty_struct *tty) 170 { 171 /* Default to echo off and other sane device settings */ 172 tty->termios.c_lflag = 0; 173 tty->termios.c_iflag = IGNBRK | IGNPAR | IXOFF; 174 /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */ 175 tty->termios.c_oflag &= ~ONLCR; 176 } 177 178 static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port) 179 { 180 struct device *dev = &port->dev; 181 struct kobil_private *priv; 182 unsigned char *transfer_buffer; 183 int transfer_buffer_length = 8; 184 int result; 185 186 priv = usb_get_serial_port_data(port); 187 188 /* allocate memory for transfer buffer */ 189 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 190 if (!transfer_buffer) 191 return -ENOMEM; 192 193 /* get hardware version */ 194 result = kobil_ctrl_recv(port, SUSBCRequest_GetMisc, SUSBCR_MSC_GetHWVersion, 195 transfer_buffer, transfer_buffer_length); 196 dev_dbg(dev, "%s - Send get_HW_version URB returns: %i\n", __func__, result); 197 if (result >= 3) { 198 dev_dbg(dev, "Hardware version: %i.%i.%i\n", transfer_buffer[0], 199 transfer_buffer[1], transfer_buffer[2]); 200 } 201 202 /* get firmware version */ 203 result = kobil_ctrl_recv(port, SUSBCRequest_GetMisc, SUSBCR_MSC_GetFWVersion, 204 transfer_buffer, transfer_buffer_length); 205 dev_dbg(dev, "%s - Send get_FW_version URB returns: %i\n", __func__, result); 206 if (result >= 3) { 207 dev_dbg(dev, "Firmware version: %i.%i.%i\n", transfer_buffer[0], 208 transfer_buffer[1], transfer_buffer[2]); 209 } 210 211 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 212 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) { 213 /* Setting Baudrate, Parity and Stopbits */ 214 result = kobil_ctrl_send(port, SUSBCRequest_SetBaudRateParityAndStopBits, 215 SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity | SUSBCR_SPASB_1StopBit); 216 dev_dbg(dev, "%s - Send set_baudrate URB returns: %i\n", __func__, result); 217 218 /* reset all queues */ 219 result = kobil_ctrl_send(port, SUSBCRequest_Misc, SUSBCR_MSC_ResetAllQueues); 220 dev_dbg(dev, "%s - Send reset_all_queues URB returns: %i\n", __func__, result); 221 } 222 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 223 priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 224 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 225 /* start reading (Adapter B 'cause PNP string) */ 226 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 227 dev_dbg(dev, "%s - Send read URB returns: %i\n", __func__, result); 228 } 229 230 kfree(transfer_buffer); 231 return 0; 232 } 233 234 235 static void kobil_close(struct usb_serial_port *port) 236 { 237 /* FIXME: Add rts/dtr methods */ 238 usb_kill_urb(port->interrupt_out_urb); 239 usb_kill_urb(port->interrupt_in_urb); 240 } 241 242 243 static void kobil_read_int_callback(struct urb *urb) 244 { 245 int result; 246 struct usb_serial_port *port = urb->context; 247 unsigned char *data = urb->transfer_buffer; 248 int status = urb->status; 249 250 if (status) { 251 dev_dbg(&port->dev, "%s - Read int status not zero: %d\n", __func__, status); 252 return; 253 } 254 255 if (urb->actual_length) { 256 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, 257 data); 258 tty_insert_flip_string(&port->port, data, urb->actual_length); 259 tty_flip_buffer_push(&port->port); 260 } 261 262 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 263 dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result); 264 } 265 266 267 static void kobil_write_int_callback(struct urb *urb) 268 { 269 } 270 271 272 static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port, 273 const unsigned char *buf, int count) 274 { 275 struct kobil_private *priv; 276 int length, todo, result; 277 278 if (count == 0) { 279 dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__); 280 return 0; 281 } 282 283 priv = usb_get_serial_port_data(port); 284 285 if (count > (KOBIL_BUF_LENGTH - priv->filled)) { 286 dev_dbg(&port->dev, "%s - Error: write request bigger than buffer size\n", __func__); 287 return -ENOMEM; 288 } 289 290 /* Copy data to buffer */ 291 memcpy(priv->buf + priv->filled, buf, count); 292 usb_serial_debug_data(&port->dev, __func__, count, priv->buf + priv->filled); 293 priv->filled = priv->filled + count; 294 295 /* only send complete block. TWIN, KAAN SIM and adapter K 296 use the same protocol. */ 297 if (((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) || 298 ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4)))) { 299 /* stop reading (except TWIN and KAAN SIM) */ 300 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 301 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) { 302 usb_kill_urb(port->interrupt_in_urb); 303 } 304 305 todo = priv->filled - priv->cur_pos; 306 307 while (todo > 0) { 308 /* max 8 byte in one urb (endpoint size) */ 309 length = min(todo, port->interrupt_out_size); 310 /* copy data to transfer buffer */ 311 memcpy(port->interrupt_out_buffer, 312 priv->buf + priv->cur_pos, length); 313 port->interrupt_out_urb->transfer_buffer_length = length; 314 315 priv->cur_pos = priv->cur_pos + length; 316 result = usb_submit_urb(port->interrupt_out_urb, 317 GFP_ATOMIC); 318 dev_dbg(&port->dev, "%s - Send write URB returns: %i\n", __func__, result); 319 todo = priv->filled - priv->cur_pos; 320 321 if (todo > 0) 322 msleep(24); 323 } 324 325 priv->filled = 0; 326 priv->cur_pos = 0; 327 328 /* start reading (except TWIN and KAAN SIM) */ 329 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || 330 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) { 331 result = usb_submit_urb(port->interrupt_in_urb, 332 GFP_ATOMIC); 333 dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result); 334 } 335 } 336 return count; 337 } 338 339 340 static unsigned int kobil_write_room(struct tty_struct *tty) 341 { 342 /* FIXME */ 343 return 8; 344 } 345 346 347 static int kobil_tiocmget(struct tty_struct *tty) 348 { 349 struct usb_serial_port *port = tty->driver_data; 350 struct kobil_private *priv; 351 int result; 352 unsigned char *transfer_buffer; 353 int transfer_buffer_length = 8; 354 355 priv = usb_get_serial_port_data(port); 356 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 357 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 358 /* This device doesn't support ioctl calls */ 359 return -EINVAL; 360 } 361 362 /* allocate memory for transfer buffer */ 363 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 364 if (!transfer_buffer) 365 return -ENOMEM; 366 367 result = kobil_ctrl_recv(port, SUSBCRequest_GetStatusLineState, 0, 368 transfer_buffer, transfer_buffer_length); 369 dev_dbg(&port->dev, "Send get_status_line_state URB returns: %i\n", 370 result); 371 if (result < 1) { 372 if (result >= 0) 373 result = -EIO; 374 goto out_free; 375 } 376 377 dev_dbg(&port->dev, "Statusline: %02x\n", transfer_buffer[0]); 378 379 result = 0; 380 if ((transfer_buffer[0] & SUSBCR_GSL_DSR) != 0) 381 result = TIOCM_DSR; 382 out_free: 383 kfree(transfer_buffer); 384 return result; 385 } 386 387 static int kobil_tiocmset(struct tty_struct *tty, 388 unsigned int set, unsigned int clear) 389 { 390 struct usb_serial_port *port = tty->driver_data; 391 struct device *dev = &port->dev; 392 struct kobil_private *priv; 393 int dtr, rts; 394 int result; 395 u16 val = 0; 396 397 priv = usb_get_serial_port_data(port); 398 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 399 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 400 /* This device doesn't support ioctl calls */ 401 return -EINVAL; 402 } 403 404 dtr = (set | clear) & TIOCM_DTR; 405 rts = (set | clear) & TIOCM_RTS; 406 407 if (dtr && priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) { 408 if (set & TIOCM_DTR) 409 val = SUSBCR_SSL_SETDTR; 410 else 411 val = SUSBCR_SSL_CLRDTR; 412 } else if (rts) { 413 if (set & TIOCM_RTS) 414 val = SUSBCR_SSL_SETRTS; 415 else 416 val = SUSBCR_SSL_CLRRTS; 417 } 418 419 if (val) { 420 result = kobil_ctrl_send(port, SUSBCRequest_SetStatusLinesOrQueues, val); 421 if (result < 0) { 422 dev_err(dev, "failed to set status lines: %d\n", result); 423 return result; 424 } 425 } 426 427 return 0; 428 } 429 430 static void kobil_set_termios(struct tty_struct *tty, 431 struct usb_serial_port *port, 432 const struct ktermios *old) 433 { 434 struct kobil_private *priv; 435 int result; 436 int c_cflag = tty->termios.c_cflag; 437 speed_t speed; 438 u16 val; 439 440 priv = usb_get_serial_port_data(port); 441 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 442 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) { 443 /* This device doesn't support ioctl calls */ 444 tty_termios_copy_hw(&tty->termios, old); 445 return; 446 } 447 448 speed = tty_get_baud_rate(tty); 449 switch (speed) { 450 case 1200: 451 val = SUSBCR_SBR_1200; 452 break; 453 default: 454 speed = 9600; 455 fallthrough; 456 case 9600: 457 val = SUSBCR_SBR_9600; 458 break; 459 } 460 461 if (c_cflag & CSTOPB) 462 val |= SUSBCR_SPASB_2StopBits; 463 else 464 val |= SUSBCR_SPASB_1StopBit; 465 466 if (c_cflag & PARENB) { 467 if (c_cflag & PARODD) 468 val |= SUSBCR_SPASB_OddParity; 469 else 470 val |= SUSBCR_SPASB_EvenParity; 471 } else { 472 val |= SUSBCR_SPASB_NoParity; 473 } 474 475 tty->termios.c_cflag &= ~CMSPAR; 476 tty_encode_baud_rate(tty, speed, speed); 477 478 result = kobil_ctrl_send(port, SUSBCRequest_SetBaudRateParityAndStopBits, val); 479 if (result) { 480 dev_err(&port->dev, "failed to update line settings: %d\n", 481 result); 482 } 483 } 484 485 static int kobil_ioctl(struct tty_struct *tty, 486 unsigned int cmd, unsigned long arg) 487 { 488 struct usb_serial_port *port = tty->driver_data; 489 struct kobil_private *priv = usb_get_serial_port_data(port); 490 int result; 491 492 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || 493 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) 494 /* This device doesn't support ioctl calls */ 495 return -ENOIOCTLCMD; 496 497 switch (cmd) { 498 case TCFLSH: 499 result = kobil_ctrl_send(port, SUSBCRequest_Misc, SUSBCR_MSC_ResetAllQueues); 500 dev_dbg(&port->dev, 501 "%s - Send reset_all_queues (FLUSH) URB returns: %i\n", 502 __func__, result); 503 return (result < 0) ? -EIO: 0; 504 default: 505 return -ENOIOCTLCMD; 506 } 507 } 508 509 module_usb_serial_driver(serial_drivers, id_table); 510 511 MODULE_AUTHOR(DRIVER_AUTHOR); 512 MODULE_DESCRIPTION(DRIVER_DESC); 513 MODULE_LICENSE("GPL"); 514