1 /* 2 * usb-serial driver for Quatech USB 2 devices 3 * 4 * Copyright (C) 2012 Bill Pemberton (wfp5p@virginia.edu) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License version 2 8 * as published by the Free Software Foundation. 9 * 10 * 11 * These devices all have only 1 bulk in and 1 bulk out that is shared 12 * for all serial ports. 13 * 14 */ 15 16 #include <asm/unaligned.h> 17 #include <linux/errno.h> 18 #include <linux/init.h> 19 #include <linux/slab.h> 20 #include <linux/tty.h> 21 #include <linux/tty_driver.h> 22 #include <linux/tty_flip.h> 23 #include <linux/module.h> 24 #include <linux/serial.h> 25 #include <linux/usb.h> 26 #include <linux/usb/serial.h> 27 #include <linux/serial_reg.h> 28 #include <linux/uaccess.h> 29 30 /* default urb timeout for usb operations */ 31 #define QT2_USB_TIMEOUT USB_CTRL_SET_TIMEOUT 32 33 #define QT_OPEN_CLOSE_CHANNEL 0xca 34 #define QT_SET_GET_DEVICE 0xc2 35 #define QT_SET_GET_REGISTER 0xc0 36 #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc 37 #define QT_SET_ATF 0xcd 38 #define QT_TRANSFER_IN 0xc0 39 #define QT_HW_FLOW_CONTROL_MASK 0xc5 40 #define QT_SW_FLOW_CONTROL_MASK 0xc6 41 #define QT2_BREAK_CONTROL 0xc8 42 #define QT2_GET_SET_UART 0xc1 43 #define QT2_FLUSH_DEVICE 0xc4 44 #define QT2_GET_SET_QMCR 0xe1 45 #define QT2_QMCR_RS232 0x40 46 #define QT2_QMCR_RS422 0x10 47 48 #define SERIAL_CRTSCTS ((UART_MCR_RTS << 8) | UART_MSR_CTS) 49 50 #define SERIAL_EVEN_PARITY (UART_LCR_PARITY | UART_LCR_EPAR) 51 52 /* status bytes for the device */ 53 #define QT2_CONTROL_BYTE 0x1b 54 #define QT2_LINE_STATUS 0x00 /* following 1 byte is line status */ 55 #define QT2_MODEM_STATUS 0x01 /* following 1 byte is modem status */ 56 #define QT2_XMIT_HOLD 0x02 /* following 2 bytes are ?? */ 57 #define QT2_CHANGE_PORT 0x03 /* following 1 byte is port to change to */ 58 #define QT2_REC_FLUSH 0x04 /* no following info */ 59 #define QT2_XMIT_FLUSH 0x05 /* no following info */ 60 #define QT2_CONTROL_ESCAPE 0xff /* pass through previous 2 control bytes */ 61 62 #define MAX_BAUD_RATE 921600 63 #define DEFAULT_BAUD_RATE 9600 64 65 #define QT2_WRITE_BUFFER_SIZE 512 /* size of write buffer */ 66 #define QT2_WRITE_CONTROL_SIZE 5 /* control bytes used for a write */ 67 68 #define DRIVER_DESC "Quatech 2nd gen USB to Serial Driver" 69 70 #define USB_VENDOR_ID_QUATECH 0x061d 71 #define QUATECH_SSU2_100 0xC120 /* RS232 single port */ 72 #define QUATECH_DSU2_100 0xC140 /* RS232 dual port */ 73 #define QUATECH_DSU2_400 0xC150 /* RS232/422/485 dual port */ 74 #define QUATECH_QSU2_100 0xC160 /* RS232 four port */ 75 #define QUATECH_QSU2_400 0xC170 /* RS232/422/485 four port */ 76 #define QUATECH_ESU2_100 0xC1A0 /* RS232 eight port */ 77 #define QUATECH_ESU2_400 0xC180 /* RS232/422/485 eight port */ 78 79 struct qt2_device_detail { 80 int product_id; 81 int num_ports; 82 }; 83 84 #define QT_DETAILS(prod, ports) \ 85 .product_id = (prod), \ 86 .num_ports = (ports) 87 88 static const struct qt2_device_detail qt2_device_details[] = { 89 {QT_DETAILS(QUATECH_SSU2_100, 1)}, 90 {QT_DETAILS(QUATECH_DSU2_400, 2)}, 91 {QT_DETAILS(QUATECH_DSU2_100, 2)}, 92 {QT_DETAILS(QUATECH_QSU2_400, 4)}, 93 {QT_DETAILS(QUATECH_QSU2_100, 4)}, 94 {QT_DETAILS(QUATECH_ESU2_400, 8)}, 95 {QT_DETAILS(QUATECH_ESU2_100, 8)}, 96 {QT_DETAILS(0, 0)} /* Terminating entry */ 97 }; 98 99 static const struct usb_device_id id_table[] = { 100 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)}, 101 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_100)}, 102 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_400)}, 103 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_100)}, 104 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_400)}, 105 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_100)}, 106 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_400)}, 107 {} /* Terminating entry */ 108 }; 109 MODULE_DEVICE_TABLE(usb, id_table); 110 111 struct qt2_serial_private { 112 unsigned char current_port; /* current port for incoming data */ 113 114 struct urb *read_urb; /* shared among all ports */ 115 char read_buffer[512]; 116 }; 117 118 struct qt2_port_private { 119 bool is_open; 120 u8 device_port; 121 122 spinlock_t urb_lock; 123 bool urb_in_use; 124 struct urb *write_urb; 125 char write_buffer[QT2_WRITE_BUFFER_SIZE]; 126 127 spinlock_t lock; 128 u8 shadowLSR; 129 u8 shadowMSR; 130 131 struct async_icount icount; 132 133 struct usb_serial_port *port; 134 }; 135 136 static void qt2_update_lsr(struct usb_serial_port *port, unsigned char *ch); 137 static void qt2_update_msr(struct usb_serial_port *port, unsigned char *ch); 138 static void qt2_write_bulk_callback(struct urb *urb); 139 static void qt2_read_bulk_callback(struct urb *urb); 140 141 static void qt2_release(struct usb_serial *serial) 142 { 143 struct qt2_serial_private *serial_priv; 144 145 serial_priv = usb_get_serial_data(serial); 146 147 usb_free_urb(serial_priv->read_urb); 148 kfree(serial_priv); 149 } 150 151 static inline int calc_baud_divisor(int baudrate) 152 { 153 int divisor, rem; 154 155 divisor = MAX_BAUD_RATE / baudrate; 156 rem = MAX_BAUD_RATE % baudrate; 157 /* Round to nearest divisor */ 158 if (((rem * 2) >= baudrate) && (baudrate != 110)) 159 divisor++; 160 161 return divisor; 162 } 163 164 static inline int qt2_set_port_config(struct usb_device *dev, 165 unsigned char port_number, 166 u16 baudrate, u16 lcr) 167 { 168 int divisor = calc_baud_divisor(baudrate); 169 u16 index = ((u16) (lcr << 8) | (u16) (port_number)); 170 171 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 172 QT2_GET_SET_UART, 0x40, 173 divisor, index, NULL, 0, QT2_USB_TIMEOUT); 174 } 175 176 static inline int qt2_control_msg(struct usb_device *dev, 177 u8 request, u16 data, u16 index) 178 { 179 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 180 request, 0x40, data, index, 181 NULL, 0, QT2_USB_TIMEOUT); 182 } 183 184 static inline int qt2_setdevice(struct usb_device *dev, u8 *data) 185 { 186 u16 x = ((u16) (data[1] << 8) | (u16) (data[0])); 187 188 return qt2_control_msg(dev, QT_SET_GET_DEVICE, x, 0); 189 } 190 191 192 static inline int qt2_getdevice(struct usb_device *dev, u8 *data) 193 { 194 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 195 QT_SET_GET_DEVICE, 0xc0, 0, 0, 196 data, 3, QT2_USB_TIMEOUT); 197 } 198 199 static inline int qt2_getregister(struct usb_device *dev, 200 u8 uart, 201 u8 reg, 202 u8 *data) 203 { 204 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 205 QT_SET_GET_REGISTER, 0xc0, reg, 206 uart, data, sizeof(*data), QT2_USB_TIMEOUT); 207 208 } 209 210 static inline int qt2_setregister(struct usb_device *dev, 211 u8 uart, u8 reg, u16 data) 212 { 213 u16 value = (data << 8) | reg; 214 215 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 216 QT_SET_GET_REGISTER, 0x40, value, uart, 217 NULL, 0, QT2_USB_TIMEOUT); 218 } 219 220 static inline int update_mctrl(struct qt2_port_private *port_priv, 221 unsigned int set, unsigned int clear) 222 { 223 struct usb_serial_port *port = port_priv->port; 224 struct usb_device *dev = port->serial->dev; 225 unsigned urb_value; 226 int status; 227 228 if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) { 229 dev_dbg(&port->dev, 230 "update_mctrl - DTR|RTS not being set|cleared\n"); 231 return 0; /* no change */ 232 } 233 234 clear &= ~set; /* 'set' takes precedence over 'clear' */ 235 urb_value = 0; 236 if (set & TIOCM_DTR) 237 urb_value |= UART_MCR_DTR; 238 if (set & TIOCM_RTS) 239 urb_value |= UART_MCR_RTS; 240 241 status = qt2_setregister(dev, port_priv->device_port, UART_MCR, 242 urb_value); 243 if (status < 0) 244 dev_err(&port->dev, 245 "update_mctrl - Error from MODEM_CTRL urb: %i\n", 246 status); 247 return status; 248 } 249 250 static int qt2_calc_num_ports(struct usb_serial *serial) 251 { 252 struct qt2_device_detail d; 253 int i; 254 255 for (i = 0; d = qt2_device_details[i], d.product_id != 0; i++) { 256 if (d.product_id == le16_to_cpu(serial->dev->descriptor.idProduct)) 257 return d.num_ports; 258 } 259 260 /* we didn't recognize the device */ 261 dev_err(&serial->dev->dev, 262 "don't know the number of ports, assuming 1\n"); 263 264 return 1; 265 } 266 267 static void qt2_set_termios(struct tty_struct *tty, 268 struct usb_serial_port *port, 269 struct ktermios *old_termios) 270 { 271 struct usb_device *dev = port->serial->dev; 272 struct qt2_port_private *port_priv; 273 struct ktermios *termios = &tty->termios; 274 u16 baud; 275 unsigned int cflag = termios->c_cflag; 276 u16 new_lcr = 0; 277 int status; 278 279 port_priv = usb_get_serial_port_data(port); 280 281 if (cflag & PARENB) { 282 if (cflag & PARODD) 283 new_lcr |= UART_LCR_PARITY; 284 else 285 new_lcr |= SERIAL_EVEN_PARITY; 286 } 287 288 switch (cflag & CSIZE) { 289 case CS5: 290 new_lcr |= UART_LCR_WLEN5; 291 break; 292 case CS6: 293 new_lcr |= UART_LCR_WLEN6; 294 break; 295 case CS7: 296 new_lcr |= UART_LCR_WLEN7; 297 break; 298 default: 299 case CS8: 300 new_lcr |= UART_LCR_WLEN8; 301 break; 302 } 303 304 baud = tty_get_baud_rate(tty); 305 if (!baud) 306 baud = 9600; 307 308 status = qt2_set_port_config(dev, port_priv->device_port, baud, 309 new_lcr); 310 if (status < 0) 311 dev_err(&port->dev, "%s - qt2_set_port_config failed: %i\n", 312 __func__, status); 313 314 if (cflag & CRTSCTS) 315 status = qt2_control_msg(dev, QT_HW_FLOW_CONTROL_MASK, 316 SERIAL_CRTSCTS, 317 port_priv->device_port); 318 else 319 status = qt2_control_msg(dev, QT_HW_FLOW_CONTROL_MASK, 320 0, port_priv->device_port); 321 if (status < 0) 322 dev_err(&port->dev, "%s - set HW flow control failed: %i\n", 323 __func__, status); 324 325 if (I_IXOFF(tty) || I_IXON(tty)) { 326 u16 x = ((u16) (START_CHAR(tty) << 8) | (u16) (STOP_CHAR(tty))); 327 328 status = qt2_control_msg(dev, QT_SW_FLOW_CONTROL_MASK, 329 x, port_priv->device_port); 330 } else 331 status = qt2_control_msg(dev, QT_SW_FLOW_CONTROL_MASK, 332 0, port_priv->device_port); 333 334 if (status < 0) 335 dev_err(&port->dev, "%s - set SW flow control failed: %i\n", 336 __func__, status); 337 338 } 339 340 static int qt2_open(struct tty_struct *tty, struct usb_serial_port *port) 341 { 342 struct usb_serial *serial; 343 struct qt2_port_private *port_priv; 344 u8 *data; 345 u16 device_port; 346 int status; 347 unsigned long flags; 348 349 device_port = (u16) (port->number - port->serial->minor); 350 351 serial = port->serial; 352 353 port_priv = usb_get_serial_port_data(port); 354 355 /* set the port to RS232 mode */ 356 status = qt2_control_msg(serial->dev, QT2_GET_SET_QMCR, 357 QT2_QMCR_RS232, device_port); 358 if (status < 0) { 359 dev_err(&port->dev, 360 "%s failed to set RS232 mode for port %i error %i\n", 361 __func__, device_port, status); 362 return status; 363 } 364 365 data = kzalloc(2, GFP_KERNEL); 366 if (!data) 367 return -ENOMEM; 368 369 /* open the port */ 370 status = usb_control_msg(serial->dev, 371 usb_rcvctrlpipe(serial->dev, 0), 372 QT_OPEN_CLOSE_CHANNEL, 373 0xc0, 0, 374 device_port, data, 2, QT2_USB_TIMEOUT); 375 376 if (status < 0) { 377 dev_err(&port->dev, "%s - open port failed %i", __func__, 378 status); 379 kfree(data); 380 return status; 381 } 382 383 spin_lock_irqsave(&port_priv->lock, flags); 384 port_priv->shadowLSR = data[0]; 385 port_priv->shadowMSR = data[1]; 386 spin_unlock_irqrestore(&port_priv->lock, flags); 387 388 kfree(data); 389 390 /* set to default speed and 8bit word size */ 391 status = qt2_set_port_config(serial->dev, device_port, 392 DEFAULT_BAUD_RATE, UART_LCR_WLEN8); 393 if (status < 0) { 394 dev_err(&port->dev, 395 "%s - initial setup failed for port %i (%i)\n", 396 __func__, port->number, device_port); 397 return status; 398 } 399 400 port_priv->is_open = true; 401 port_priv->device_port = (u8) device_port; 402 403 if (tty) 404 qt2_set_termios(tty, port, &tty->termios); 405 406 return 0; 407 408 } 409 410 static void qt2_close(struct usb_serial_port *port) 411 { 412 struct usb_serial *serial; 413 struct qt2_port_private *port_priv; 414 unsigned long flags; 415 int i; 416 417 serial = port->serial; 418 port_priv = usb_get_serial_port_data(port); 419 420 port_priv->is_open = false; 421 422 spin_lock_irqsave(&port_priv->urb_lock, flags); 423 usb_kill_urb(port_priv->write_urb); 424 port_priv->urb_in_use = false; 425 spin_unlock_irqrestore(&port_priv->urb_lock, flags); 426 427 mutex_lock(&port->serial->disc_mutex); 428 if (port->serial->disconnected) { 429 mutex_unlock(&port->serial->disc_mutex); 430 return; 431 } 432 433 /* flush the port transmit buffer */ 434 i = usb_control_msg(serial->dev, 435 usb_rcvctrlpipe(serial->dev, 0), 436 QT2_FLUSH_DEVICE, 0x40, 1, 437 port_priv->device_port, NULL, 0, QT2_USB_TIMEOUT); 438 439 if (i < 0) 440 dev_err(&port->dev, "%s - transmit buffer flush failed: %i\n", 441 __func__, i); 442 443 /* flush the port receive buffer */ 444 i = usb_control_msg(serial->dev, 445 usb_rcvctrlpipe(serial->dev, 0), 446 QT2_FLUSH_DEVICE, 0x40, 0, 447 port_priv->device_port, NULL, 0, QT2_USB_TIMEOUT); 448 449 if (i < 0) 450 dev_err(&port->dev, "%s - receive buffer flush failed: %i\n", 451 __func__, i); 452 453 /* close the port */ 454 i = usb_control_msg(serial->dev, 455 usb_sndctrlpipe(serial->dev, 0), 456 QT_OPEN_CLOSE_CHANNEL, 457 0x40, 0, 458 port_priv->device_port, NULL, 0, QT2_USB_TIMEOUT); 459 460 if (i < 0) 461 dev_err(&port->dev, "%s - close port failed %i\n", 462 __func__, i); 463 464 mutex_unlock(&port->serial->disc_mutex); 465 } 466 467 static void qt2_disconnect(struct usb_serial *serial) 468 { 469 struct qt2_serial_private *serial_priv = usb_get_serial_data(serial); 470 471 usb_kill_urb(serial_priv->read_urb); 472 } 473 474 static int get_serial_info(struct usb_serial_port *port, 475 struct serial_struct __user *retinfo) 476 { 477 struct serial_struct tmp; 478 479 if (!retinfo) 480 return -EFAULT; 481 482 memset(&tmp, 0, sizeof(tmp)); 483 tmp.line = port->serial->minor; 484 tmp.port = 0; 485 tmp.irq = 0; 486 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ; 487 tmp.xmit_fifo_size = port->bulk_out_size; 488 tmp.baud_base = 9600; 489 tmp.close_delay = 5*HZ; 490 tmp.closing_wait = 30*HZ; 491 492 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 493 return -EFAULT; 494 return 0; 495 } 496 497 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 498 { 499 struct qt2_port_private *priv = usb_get_serial_port_data(port); 500 struct async_icount prev, cur; 501 unsigned long flags; 502 503 spin_lock_irqsave(&priv->lock, flags); 504 prev = priv->icount; 505 spin_unlock_irqrestore(&priv->lock, flags); 506 507 while (1) { 508 wait_event_interruptible(port->delta_msr_wait, 509 (port->serial->disconnected || 510 (priv->icount.rng != prev.rng) || 511 (priv->icount.dsr != prev.dsr) || 512 (priv->icount.dcd != prev.dcd) || 513 (priv->icount.cts != prev.cts))); 514 515 if (signal_pending(current)) 516 return -ERESTARTSYS; 517 518 if (port->serial->disconnected) 519 return -EIO; 520 521 spin_lock_irqsave(&priv->lock, flags); 522 cur = priv->icount; 523 spin_unlock_irqrestore(&priv->lock, flags); 524 525 if ((prev.rng == cur.rng) && 526 (prev.dsr == cur.dsr) && 527 (prev.dcd == cur.dcd) && 528 (prev.cts == cur.cts)) 529 return -EIO; 530 531 if ((arg & TIOCM_RNG && (prev.rng != cur.rng)) || 532 (arg & TIOCM_DSR && (prev.dsr != cur.dsr)) || 533 (arg & TIOCM_CD && (prev.dcd != cur.dcd)) || 534 (arg & TIOCM_CTS && (prev.cts != cur.cts))) 535 return 0; 536 } 537 return 0; 538 } 539 540 static int qt2_get_icount(struct tty_struct *tty, 541 struct serial_icounter_struct *icount) 542 { 543 struct usb_serial_port *port = tty->driver_data; 544 struct qt2_port_private *priv = usb_get_serial_port_data(port); 545 struct async_icount cnow = priv->icount; 546 547 icount->cts = cnow.cts; 548 icount->dsr = cnow.dsr; 549 icount->rng = cnow.rng; 550 icount->dcd = cnow.dcd; 551 icount->rx = cnow.rx; 552 icount->tx = cnow.tx; 553 icount->frame = cnow.frame; 554 icount->overrun = cnow.overrun; 555 icount->parity = cnow.parity; 556 icount->brk = cnow.brk; 557 icount->buf_overrun = cnow.buf_overrun; 558 559 return 0; 560 } 561 562 static int qt2_ioctl(struct tty_struct *tty, 563 unsigned int cmd, unsigned long arg) 564 { 565 struct usb_serial_port *port = tty->driver_data; 566 567 switch (cmd) { 568 case TIOCGSERIAL: 569 return get_serial_info(port, 570 (struct serial_struct __user *)arg); 571 572 case TIOCMIWAIT: 573 return wait_modem_info(port, arg); 574 575 default: 576 break; 577 } 578 579 return -ENOIOCTLCMD; 580 } 581 582 static void qt2_process_status(struct usb_serial_port *port, unsigned char *ch) 583 { 584 switch (*ch) { 585 case QT2_LINE_STATUS: 586 qt2_update_lsr(port, ch + 1); 587 break; 588 case QT2_MODEM_STATUS: 589 qt2_update_msr(port, ch + 1); 590 break; 591 } 592 } 593 594 /* not needed, kept to document functionality */ 595 static void qt2_process_xmit_empty(struct usb_serial_port *port, 596 unsigned char *ch) 597 { 598 int bytes_written; 599 600 bytes_written = (int)(*ch) + (int)(*(ch + 1) << 4); 601 } 602 603 /* not needed, kept to document functionality */ 604 static void qt2_process_flush(struct usb_serial_port *port, unsigned char *ch) 605 { 606 return; 607 } 608 609 void qt2_process_read_urb(struct urb *urb) 610 { 611 struct usb_serial *serial; 612 struct qt2_serial_private *serial_priv; 613 struct usb_serial_port *port; 614 struct qt2_port_private *port_priv; 615 bool escapeflag; 616 unsigned char *ch; 617 int i; 618 unsigned char newport; 619 int len = urb->actual_length; 620 621 if (!len) 622 return; 623 624 ch = urb->transfer_buffer; 625 serial = urb->context; 626 serial_priv = usb_get_serial_data(serial); 627 port = serial->port[serial_priv->current_port]; 628 port_priv = usb_get_serial_port_data(port); 629 630 for (i = 0; i < urb->actual_length; i++) { 631 ch = (unsigned char *)urb->transfer_buffer + i; 632 if ((i <= (len - 3)) && 633 (*ch == QT2_CONTROL_BYTE) && 634 (*(ch + 1) == QT2_CONTROL_BYTE)) { 635 escapeflag = false; 636 switch (*(ch + 2)) { 637 case QT2_LINE_STATUS: 638 case QT2_MODEM_STATUS: 639 if (i > (len - 4)) { 640 dev_warn(&port->dev, 641 "%s - status message too short\n", 642 __func__); 643 break; 644 } 645 qt2_process_status(port, ch + 2); 646 i += 3; 647 escapeflag = true; 648 break; 649 case QT2_XMIT_HOLD: 650 if (i > (len - 5)) { 651 dev_warn(&port->dev, 652 "%s - xmit_empty message too short\n", 653 __func__); 654 break; 655 } 656 qt2_process_xmit_empty(port, ch + 3); 657 i += 4; 658 escapeflag = true; 659 break; 660 case QT2_CHANGE_PORT: 661 if (i > (len - 4)) { 662 dev_warn(&port->dev, 663 "%s - change_port message too short\n", 664 __func__); 665 break; 666 } 667 668 if (port_priv->is_open) 669 tty_flip_buffer_push(&port->port); 670 671 newport = *(ch + 3); 672 673 if (newport > serial->num_ports) { 674 dev_err(&port->dev, 675 "%s - port change to invalid port: %i\n", 676 __func__, newport); 677 break; 678 } 679 680 serial_priv->current_port = newport; 681 port = serial->port[serial_priv->current_port]; 682 port_priv = usb_get_serial_port_data(port); 683 i += 3; 684 escapeflag = true; 685 break; 686 case QT2_REC_FLUSH: 687 case QT2_XMIT_FLUSH: 688 qt2_process_flush(port, ch + 2); 689 i += 2; 690 escapeflag = true; 691 break; 692 case QT2_CONTROL_ESCAPE: 693 tty_buffer_request_room(&port->port, 2); 694 tty_insert_flip_string(&port->port, ch, 2); 695 i += 2; 696 escapeflag = true; 697 break; 698 default: 699 dev_warn(&port->dev, 700 "%s - unsupported command %i\n", 701 __func__, *(ch + 2)); 702 break; 703 } 704 if (escapeflag) 705 continue; 706 } 707 708 tty_buffer_request_room(&port->port, 1); 709 tty_insert_flip_string(&port->port, ch, 1); 710 } 711 712 if (port_priv->is_open) 713 tty_flip_buffer_push(&port->port); 714 } 715 716 static void qt2_write_bulk_callback(struct urb *urb) 717 { 718 struct usb_serial_port *port; 719 struct qt2_port_private *port_priv; 720 721 port = urb->context; 722 port_priv = usb_get_serial_port_data(port); 723 724 spin_lock(&port_priv->urb_lock); 725 726 port_priv->urb_in_use = false; 727 usb_serial_port_softint(port); 728 729 spin_unlock(&port_priv->urb_lock); 730 731 } 732 733 static void qt2_read_bulk_callback(struct urb *urb) 734 { 735 struct usb_serial *serial = urb->context; 736 int status; 737 738 if (urb->status) { 739 dev_warn(&serial->dev->dev, 740 "%s - non-zero urb status: %i\n", __func__, 741 urb->status); 742 return; 743 } 744 745 qt2_process_read_urb(urb); 746 747 status = usb_submit_urb(urb, GFP_ATOMIC); 748 if (status != 0) 749 dev_err(&serial->dev->dev, 750 "%s - resubmit read urb failed: %i\n", 751 __func__, status); 752 } 753 754 static int qt2_setup_urbs(struct usb_serial *serial) 755 { 756 struct usb_serial_port *port0; 757 struct qt2_serial_private *serial_priv; 758 int status; 759 760 port0 = serial->port[0]; 761 762 serial_priv = usb_get_serial_data(serial); 763 serial_priv->read_urb = usb_alloc_urb(0, GFP_KERNEL); 764 if (!serial_priv->read_urb) { 765 dev_err(&serial->dev->dev, "No free urbs available\n"); 766 return -ENOMEM; 767 } 768 769 usb_fill_bulk_urb(serial_priv->read_urb, serial->dev, 770 usb_rcvbulkpipe(serial->dev, 771 port0->bulk_in_endpointAddress), 772 serial_priv->read_buffer, 773 sizeof(serial_priv->read_buffer), 774 qt2_read_bulk_callback, serial); 775 776 status = usb_submit_urb(serial_priv->read_urb, GFP_KERNEL); 777 if (status != 0) { 778 dev_err(&serial->dev->dev, 779 "%s - submit read urb failed %i\n", __func__, status); 780 usb_free_urb(serial_priv->read_urb); 781 return status; 782 } 783 784 return 0; 785 } 786 787 static int qt2_attach(struct usb_serial *serial) 788 { 789 struct qt2_serial_private *serial_priv; 790 int status; 791 792 /* power on unit */ 793 status = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 794 0xc2, 0x40, 0x8000, 0, NULL, 0, 795 QT2_USB_TIMEOUT); 796 if (status < 0) { 797 dev_err(&serial->dev->dev, 798 "%s - failed to power on unit: %i\n", __func__, status); 799 return status; 800 } 801 802 serial_priv = kzalloc(sizeof(*serial_priv), GFP_KERNEL); 803 if (!serial_priv) { 804 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__); 805 return -ENOMEM; 806 } 807 808 usb_set_serial_data(serial, serial_priv); 809 810 status = qt2_setup_urbs(serial); 811 if (status != 0) 812 goto attach_failed; 813 814 return 0; 815 816 attach_failed: 817 kfree(serial_priv); 818 return status; 819 } 820 821 static int qt2_port_probe(struct usb_serial_port *port) 822 { 823 struct usb_serial *serial = port->serial; 824 struct qt2_port_private *port_priv; 825 u8 bEndpointAddress; 826 827 port_priv = kzalloc(sizeof(*port_priv), GFP_KERNEL); 828 if (!port_priv) 829 return -ENOMEM; 830 831 spin_lock_init(&port_priv->lock); 832 spin_lock_init(&port_priv->urb_lock); 833 port_priv->port = port; 834 835 port_priv->write_urb = usb_alloc_urb(0, GFP_KERNEL); 836 if (!port_priv->write_urb) { 837 kfree(port_priv); 838 return -ENOMEM; 839 } 840 bEndpointAddress = serial->port[0]->bulk_out_endpointAddress; 841 usb_fill_bulk_urb(port_priv->write_urb, serial->dev, 842 usb_sndbulkpipe(serial->dev, bEndpointAddress), 843 port_priv->write_buffer, 844 sizeof(port_priv->write_buffer), 845 qt2_write_bulk_callback, port); 846 847 usb_set_serial_port_data(port, port_priv); 848 849 return 0; 850 } 851 852 static int qt2_port_remove(struct usb_serial_port *port) 853 { 854 struct qt2_port_private *port_priv; 855 856 port_priv = usb_get_serial_port_data(port); 857 usb_free_urb(port_priv->write_urb); 858 kfree(port_priv); 859 860 return 0; 861 } 862 863 static int qt2_tiocmget(struct tty_struct *tty) 864 { 865 struct usb_serial_port *port = tty->driver_data; 866 struct usb_device *dev = port->serial->dev; 867 struct qt2_port_private *port_priv = usb_get_serial_port_data(port); 868 u8 *d; 869 int r; 870 871 d = kzalloc(2, GFP_KERNEL); 872 if (!d) 873 return -ENOMEM; 874 875 r = qt2_getregister(dev, port_priv->device_port, UART_MCR, d); 876 if (r < 0) 877 goto mget_out; 878 879 r = qt2_getregister(dev, port_priv->device_port, UART_MSR, d + 1); 880 if (r < 0) 881 goto mget_out; 882 883 r = (d[0] & UART_MCR_DTR ? TIOCM_DTR : 0) | 884 (d[0] & UART_MCR_RTS ? TIOCM_RTS : 0) | 885 (d[1] & UART_MSR_CTS ? TIOCM_CTS : 0) | 886 (d[1] & UART_MSR_DCD ? TIOCM_CAR : 0) | 887 (d[1] & UART_MSR_RI ? TIOCM_RI : 0) | 888 (d[1] & UART_MSR_DSR ? TIOCM_DSR : 0); 889 890 mget_out: 891 kfree(d); 892 return r; 893 } 894 895 static int qt2_tiocmset(struct tty_struct *tty, 896 unsigned int set, unsigned int clear) 897 { 898 struct qt2_port_private *port_priv; 899 900 port_priv = usb_get_serial_port_data(tty->driver_data); 901 return update_mctrl(port_priv, set, clear); 902 } 903 904 static void qt2_break_ctl(struct tty_struct *tty, int break_state) 905 { 906 struct usb_serial_port *port = tty->driver_data; 907 struct qt2_port_private *port_priv; 908 int status; 909 u16 val; 910 911 port_priv = usb_get_serial_port_data(port); 912 913 if (!port_priv->is_open) { 914 dev_err(&port->dev, 915 "%s - port is not open\n", __func__); 916 return; 917 } 918 919 val = (break_state == -1) ? 1 : 0; 920 921 status = qt2_control_msg(port->serial->dev, QT2_BREAK_CONTROL, 922 val, port_priv->device_port); 923 if (status < 0) 924 dev_warn(&port->dev, 925 "%s - failed to send control message: %i\n", __func__, 926 status); 927 } 928 929 930 931 static void qt2_dtr_rts(struct usb_serial_port *port, int on) 932 { 933 struct usb_device *dev = port->serial->dev; 934 struct qt2_port_private *port_priv = usb_get_serial_port_data(port); 935 936 /* Disable flow control */ 937 if (!on) { 938 if (qt2_setregister(dev, port_priv->device_port, 939 UART_MCR, 0) < 0) 940 dev_warn(&port->dev, "error from flowcontrol urb\n"); 941 } 942 /* drop RTS and DTR */ 943 if (on) 944 update_mctrl(port_priv, TIOCM_DTR | TIOCM_RTS, 0); 945 else 946 update_mctrl(port_priv, 0, TIOCM_DTR | TIOCM_RTS); 947 } 948 949 static void qt2_update_msr(struct usb_serial_port *port, unsigned char *ch) 950 { 951 struct qt2_port_private *port_priv; 952 u8 newMSR = (u8) *ch; 953 unsigned long flags; 954 955 port_priv = usb_get_serial_port_data(port); 956 957 spin_lock_irqsave(&port_priv->lock, flags); 958 port_priv->shadowMSR = newMSR; 959 spin_unlock_irqrestore(&port_priv->lock, flags); 960 961 if (newMSR & UART_MSR_ANY_DELTA) { 962 /* update input line counters */ 963 if (newMSR & UART_MSR_DCTS) 964 port_priv->icount.cts++; 965 966 if (newMSR & UART_MSR_DDSR) 967 port_priv->icount.dsr++; 968 969 if (newMSR & UART_MSR_DDCD) 970 port_priv->icount.dcd++; 971 972 if (newMSR & UART_MSR_TERI) 973 port_priv->icount.rng++; 974 975 wake_up_interruptible(&port->delta_msr_wait); 976 } 977 } 978 979 static void qt2_update_lsr(struct usb_serial_port *port, unsigned char *ch) 980 { 981 struct qt2_port_private *port_priv; 982 struct async_icount *icount; 983 unsigned long flags; 984 u8 newLSR = (u8) *ch; 985 986 port_priv = usb_get_serial_port_data(port); 987 988 if (newLSR & UART_LSR_BI) 989 newLSR &= (u8) (UART_LSR_OE | UART_LSR_BI); 990 991 spin_lock_irqsave(&port_priv->lock, flags); 992 port_priv->shadowLSR = newLSR; 993 spin_unlock_irqrestore(&port_priv->lock, flags); 994 995 icount = &port_priv->icount; 996 997 if (newLSR & UART_LSR_BRK_ERROR_BITS) { 998 999 if (newLSR & UART_LSR_BI) 1000 icount->brk++; 1001 1002 if (newLSR & UART_LSR_OE) 1003 icount->overrun++; 1004 1005 if (newLSR & UART_LSR_PE) 1006 icount->parity++; 1007 1008 if (newLSR & UART_LSR_FE) 1009 icount->frame++; 1010 } 1011 1012 } 1013 1014 static int qt2_write_room(struct tty_struct *tty) 1015 { 1016 struct usb_serial_port *port = tty->driver_data; 1017 struct qt2_port_private *port_priv; 1018 unsigned long flags = 0; 1019 int r; 1020 1021 port_priv = usb_get_serial_port_data(port); 1022 1023 spin_lock_irqsave(&port_priv->urb_lock, flags); 1024 1025 if (port_priv->urb_in_use) 1026 r = 0; 1027 else 1028 r = QT2_WRITE_BUFFER_SIZE - QT2_WRITE_CONTROL_SIZE; 1029 1030 spin_unlock_irqrestore(&port_priv->urb_lock, flags); 1031 1032 return r; 1033 } 1034 1035 static int qt2_write(struct tty_struct *tty, 1036 struct usb_serial_port *port, 1037 const unsigned char *buf, int count) 1038 { 1039 struct qt2_port_private *port_priv; 1040 struct urb *write_urb; 1041 unsigned char *data; 1042 unsigned long flags; 1043 int status; 1044 int bytes_out = 0; 1045 1046 port_priv = usb_get_serial_port_data(port); 1047 1048 if (port_priv->write_urb == NULL) { 1049 dev_err(&port->dev, "%s - no output urb\n", __func__); 1050 return 0; 1051 } 1052 write_urb = port_priv->write_urb; 1053 1054 count = min(count, QT2_WRITE_BUFFER_SIZE - QT2_WRITE_CONTROL_SIZE); 1055 1056 data = write_urb->transfer_buffer; 1057 spin_lock_irqsave(&port_priv->urb_lock, flags); 1058 if (port_priv->urb_in_use == true) { 1059 dev_err(&port->dev, "qt2_write - urb is in use\n"); 1060 goto write_out; 1061 } 1062 1063 *data++ = QT2_CONTROL_BYTE; 1064 *data++ = QT2_CONTROL_BYTE; 1065 *data++ = port_priv->device_port; 1066 put_unaligned_le16(count, data); 1067 data += 2; 1068 memcpy(data, buf, count); 1069 1070 write_urb->transfer_buffer_length = count + QT2_WRITE_CONTROL_SIZE; 1071 1072 status = usb_submit_urb(write_urb, GFP_ATOMIC); 1073 if (status == 0) { 1074 port_priv->urb_in_use = true; 1075 bytes_out += count; 1076 } 1077 1078 write_out: 1079 spin_unlock_irqrestore(&port_priv->urb_lock, flags); 1080 return bytes_out; 1081 } 1082 1083 1084 static struct usb_serial_driver qt2_device = { 1085 .driver = { 1086 .owner = THIS_MODULE, 1087 .name = "quatech-serial", 1088 }, 1089 .description = DRIVER_DESC, 1090 .id_table = id_table, 1091 .open = qt2_open, 1092 .close = qt2_close, 1093 .write = qt2_write, 1094 .write_room = qt2_write_room, 1095 .calc_num_ports = qt2_calc_num_ports, 1096 .attach = qt2_attach, 1097 .release = qt2_release, 1098 .disconnect = qt2_disconnect, 1099 .port_probe = qt2_port_probe, 1100 .port_remove = qt2_port_remove, 1101 .dtr_rts = qt2_dtr_rts, 1102 .break_ctl = qt2_break_ctl, 1103 .tiocmget = qt2_tiocmget, 1104 .tiocmset = qt2_tiocmset, 1105 .get_icount = qt2_get_icount, 1106 .ioctl = qt2_ioctl, 1107 .set_termios = qt2_set_termios, 1108 }; 1109 1110 static struct usb_serial_driver *const serial_drivers[] = { 1111 &qt2_device, NULL 1112 }; 1113 1114 module_usb_serial_driver(serial_drivers, id_table); 1115 1116 MODULE_DESCRIPTION(DRIVER_DESC); 1117 MODULE_LICENSE("GPL"); 1118