1/* 2 * This code was developed for the Quatech USB line for linux, it used 3 * much of the code developed by Greg Kroah-Hartman for USB serial devices 4 * 5 */ 6 7#include <linux/errno.h> 8#include <linux/init.h> 9#include <linux/slab.h> 10#include <linux/tty.h> 11#include <linux/tty_driver.h> 12#include <linux/tty_flip.h> 13#include <linux/module.h> 14#include <linux/serial.h> 15#include <linux/usb.h> 16#include <linux/usb/serial.h> 17#include <linux/uaccess.h> 18 19static int debug; 20 21/* Version Information */ 22#define DRIVER_VERSION "v2.14" 23#define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc" 24#define DRIVER_DESC "Quatech USB to Serial Driver" 25 26#define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */ 27#define QUATECH_SSU100 0xC020 /* SSU100 */ 28#define QUATECH_SSU200 0xC030 /* SSU200 */ 29#define QUATECH_DSU100 0xC040 /* DSU100 */ 30#define QUATECH_DSU200 0xC050 /* DSU200 */ 31#define QUATECH_QSU100 0xC060 /* QSU100 */ 32#define QUATECH_QSU200 0xC070 /* QSU200 */ 33#define QUATECH_ESU100A 0xC080 /* ESU100A */ 34#define QUATECH_ESU100B 0xC081 /* ESU100B */ 35#define QUATECH_ESU200A 0xC0A0 /* ESU200A */ 36#define QUATECH_ESU200B 0xC0A1 /* ESU200B */ 37#define QUATECH_HSU100A 0xC090 /* HSU100A */ 38#define QUATECH_HSU100B 0xC091 /* HSU100B */ 39#define QUATECH_HSU100C 0xC092 /* HSU100C */ 40#define QUATECH_HSU100D 0xC093 /* HSU100D */ 41#define QUATECH_HSU200A 0xC0B0 /* HSU200A */ 42#define QUATECH_HSU200B 0xC0B1 /* HSU200B */ 43#define QUATECH_HSU200C 0xC0B2 /* HSU200C */ 44#define QUATECH_HSU200D 0xC0B3 /* HSU200D */ 45#define QUATECH_SSU100_2 0xC120 /* SSU100_2 */ 46#define QUATECH_DSU100_2 0xC140 /* DSU100_2 */ 47#define QUATECH_DSU400_2 0xC150 /* DSU400_2 */ 48#define QUATECH_QSU100_2 0xC160 /* QSU100_2 */ 49#define QUATECH_QSU400_2 0xC170 /* QSU400_2 */ 50#define QUATECH_ESU400_2 0xC180 /* ESU400_2 */ 51#define QUATECH_ESU100_2 0xC1A0 /* ESU100_2 */ 52 53#define QT_SET_GET_DEVICE 0xc2 54#define QT_OPEN_CLOSE_CHANNEL 0xca 55#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc 56#define QT_SET_ATF 0xcd 57#define QT_GET_SET_REGISTER 0xc0 58#define QT_GET_SET_UART 0xc1 59#define QT_HW_FLOW_CONTROL_MASK 0xc5 60#define QT_SW_FLOW_CONTROL_MASK 0xc6 61#define QT_SW_FLOW_CONTROL_DISABLE 0xc7 62#define QT_BREAK_CONTROL 0xc8 63 64#define USBD_TRANSFER_DIRECTION_IN 0xc0 65#define USBD_TRANSFER_DIRECTION_OUT 0x40 66 67#define MAX_BAUD_RATE 460800 68#define MAX_BAUD_REMAINDER 4608 69 70#define DIV_LATCH_LS 0x00 71#define XMT_HOLD_REGISTER 0x00 72#define XVR_BUFFER_REGISTER 0x00 73#define DIV_LATCH_MS 0x01 74#define FIFO_CONTROL_REGISTER 0x02 75#define LINE_CONTROL_REGISTER 0x03 76#define MODEM_CONTROL_REGISTER 0x04 77#define LINE_STATUS_REGISTER 0x05 78#define MODEM_STATUS_REGISTER 0x06 79 80#define SERIAL_MCR_DTR 0x01 81#define SERIAL_MCR_RTS 0x02 82#define SERIAL_MCR_LOOP 0x10 83 84#define SERIAL_MSR_CTS 0x10 85#define SERIAL_MSR_CD 0x80 86#define SERIAL_MSR_RI 0x40 87#define SERIAL_MSR_DSR 0x20 88#define SERIAL_MSR_MASK 0xf0 89 90#define SERIAL_8_DATA 0x03 91#define SERIAL_7_DATA 0x02 92#define SERIAL_6_DATA 0x01 93#define SERIAL_5_DATA 0x00 94 95#define SERIAL_ODD_PARITY 0X08 96#define SERIAL_EVEN_PARITY 0X18 97#define SERIAL_TWO_STOPB 0x04 98#define SERIAL_ONE_STOPB 0x00 99 100#define DEFAULT_DIVISOR 0x30 /* gives 9600 baud rate */ 101#define DEFAULT_LCR SERIAL_8_DATA /* 8, none , 1 */ 102 103#define FULLPWRBIT 0x00000080 104#define NEXT_BOARD_POWER_BIT 0x00000004 105 106#define SERIAL_LSR_OE 0x02 107#define SERIAL_LSR_PE 0x04 108#define SERIAL_LSR_FE 0x08 109#define SERIAL_LSR_BI 0x10 110 111#define SERIAL_MSR_CTS 0x10 112#define SERIAL_MSR_CD 0x80 113#define SERIAL_MSR_RI 0x40 114#define SERIAL_MSR_DSR 0x20 115#define SERIAL_MSR_MASK 0xf0 116 117#define PREFUFF_LEVEL_CONSERVATIVE 128 118#define ATC_DISABLED 0x0 119 120#define RR_BITS 0x03 /* for clearing clock bits */ 121#define DUPMODE_BITS 0xc0 122#define CLKS_X4 0x02 123 124#define LOOPMODE_BITS 0x41 /* LOOP1 = b6, LOOP0 = b0 (PORT B) */ 125#define ALL_LOOPBACK 0x01 126#define MODEM_CTRL 0x40 127#define RS232_MODE 0x00 128 129static const struct usb_device_id serqt_id_table[] = { 130 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU100)}, 131 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU200)}, 132 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100)}, 133 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU200)}, 134 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100)}, 135 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU200)}, 136 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100A)}, 137 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100B)}, 138 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200A)}, 139 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200B)}, 140 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100A)}, 141 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100B)}, 142 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100C)}, 143 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100D)}, 144 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200A)}, 145 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200B)}, 146 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200C)}, 147 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200D)}, 148 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU100_2)}, 149 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100_2)}, 150 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU400_2)}, 151 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100_2)}, 152 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU400_2)}, 153 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU400_2)}, 154 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100_2)}, 155 {} /* Terminating entry */ 156}; 157 158MODULE_DEVICE_TABLE(usb, serqt_id_table); 159 160struct qt_get_device_data { 161 __u8 porta; 162 __u8 portb; 163 __u8 portc; 164}; 165 166struct qt_open_channel_data { 167 __u8 line_status; 168 __u8 modem_status; 169}; 170 171struct quatech_port { 172 int port_num; /* number of the port */ 173 struct urb *write_urb; /* write URB for this port */ 174 struct urb *read_urb; /* read URB for this port */ 175 struct urb *int_urb; 176 177 __u8 shadowLCR; /* last LCR value received */ 178 __u8 shadowMCR; /* last MCR value received */ 179 __u8 shadowMSR; /* last MSR value received */ 180 __u8 shadowLSR; /* last LSR value received */ 181 char open_ports; 182 183 /* Used for TIOCMIWAIT */ 184 wait_queue_head_t msr_wait; 185 char prev_status, diff_status; 186 187 wait_queue_head_t wait; 188 189 struct async_icount icount; 190 191 struct usb_serial_port *port; /* owner of this object */ 192 struct qt_get_device_data DeviceData; 193 spinlock_t lock; 194 bool read_urb_busy; 195 int RxHolding; 196 int ReadBulkStopped; 197 char closePending; 198}; 199 200static struct usb_driver serqt_usb_driver = { 201 .name = "quatech-usb-serial", 202 .probe = usb_serial_probe, 203 .disconnect = usb_serial_disconnect, 204 .id_table = serqt_id_table, 205 .no_dynamic_id = 1, 206}; 207 208static int port_paranoia_check(struct usb_serial_port *port, 209 const char *function) 210{ 211 if (!port) { 212 dbg("%s - port == NULL", function); 213 return -1; 214 } 215 if (!port->serial) { 216 dbg("%s - port->serial == NULL\n", function); 217 return -1; 218 } 219 220 return 0; 221} 222 223static int serial_paranoia_check(struct usb_serial *serial, 224 const char *function) 225{ 226 if (!serial) { 227 dbg("%s - serial == NULL\n", function); 228 return -1; 229 } 230 231 if (!serial->type) { 232 dbg("%s - serial->type == NULL!", function); 233 return -1; 234 } 235 236 return 0; 237} 238 239static inline struct quatech_port *qt_get_port_private(struct usb_serial_port 240 *port) 241{ 242 return (struct quatech_port *)usb_get_serial_port_data(port); 243} 244 245static inline void qt_set_port_private(struct usb_serial_port *port, 246 struct quatech_port *data) 247{ 248 usb_set_serial_port_data(port, (void *)data); 249} 250 251static struct usb_serial *get_usb_serial(struct usb_serial_port *port, 252 const char *function) 253{ 254 /* if no port was specified, or it fails a paranoia check */ 255 if (!port || 256 port_paranoia_check(port, function) || 257 serial_paranoia_check(port->serial, function)) { 258 /* 259 * then say that we dont have a valid usb_serial thing, 260 * which will end up genrating -ENODEV return values 261 */ 262 return NULL; 263 } 264 265 return port->serial; 266} 267 268static void ProcessLineStatus(struct quatech_port *qt_port, 269 unsigned char line_status) 270{ 271 272 qt_port->shadowLSR = 273 line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | 274 SERIAL_LSR_BI); 275 return; 276} 277 278static void ProcessModemStatus(struct quatech_port *qt_port, 279 unsigned char modem_status) 280{ 281 282 qt_port->shadowMSR = modem_status; 283 wake_up_interruptible(&qt_port->wait); 284 return; 285} 286 287static void ProcessRxChar(struct tty_struct *tty, struct usb_serial_port *port, 288 unsigned char data) 289{ 290 struct urb *urb = port->read_urb; 291 if (urb->actual_length) 292 tty_insert_flip_char(tty, data, TTY_NORMAL); 293} 294 295static void qt_write_bulk_callback(struct urb *urb) 296{ 297 struct tty_struct *tty; 298 int status; 299 struct quatech_port *quatech_port; 300 301 status = urb->status; 302 303 if (status) { 304 dbg("nonzero write bulk status received:%d\n", status); 305 return; 306 } 307 308 quatech_port = urb->context; 309 310 dbg("%s - port %d\n", __func__, quatech_port->port_num); 311 312 tty = tty_port_tty_get(&quatech_port->port->port); 313 314 if (tty) 315 tty_wakeup(tty); 316 tty_kref_put(tty); 317} 318 319static void qt_interrupt_callback(struct urb *urb) 320{ 321} 322 323static void qt_read_bulk_callback(struct urb *urb) 324{ 325 326 struct usb_serial_port *port = urb->context; 327 struct usb_serial *serial = get_usb_serial(port, __func__); 328 struct quatech_port *qt_port = qt_get_port_private(port); 329 unsigned char *data; 330 struct tty_struct *tty; 331 unsigned int index; 332 unsigned int RxCount; 333 int i, result; 334 int flag, flag_data; 335 336 if (urb->status) { 337 qt_port->ReadBulkStopped = 1; 338 dbg("%s - nonzero write bulk status received: %d\n", 339 __func__, urb->status); 340 return; 341 } 342 343 tty = tty_port_tty_get(&port->port); 344 if (!tty) { 345 dbg("%s - bad tty pointer - exiting", __func__); 346 return; 347 } 348 349 data = urb->transfer_buffer; 350 351 RxCount = urb->actual_length; 352 353 /* index = MINOR(port->tty->device) - serial->minor; */ 354 index = tty->index - serial->minor; 355 356 dbg("%s - port %d\n", __func__, port->number); 357 dbg("%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding); 358 359 if (port_paranoia_check(port, __func__) != 0) { 360 dbg("%s - port_paranoia_check, exiting\n", __func__); 361 qt_port->ReadBulkStopped = 1; 362 goto exit; 363 } 364 365 if (!serial) { 366 dbg("%s - bad serial pointer, exiting\n", __func__); 367 goto exit; 368 } 369 if (qt_port->closePending == 1) { 370 /* Were closing , stop reading */ 371 dbg("%s - (qt_port->closepending == 1\n", __func__); 372 qt_port->ReadBulkStopped = 1; 373 goto exit; 374 } 375 376 /* 377 * RxHolding is asserted by throttle, if we assert it, we're not 378 * receiving any more characters and let the box handle the flow 379 * control 380 */ 381 if (qt_port->RxHolding == 1) { 382 qt_port->ReadBulkStopped = 1; 383 goto exit; 384 } 385 386 if (urb->status) { 387 qt_port->ReadBulkStopped = 1; 388 389 dbg("%s - nonzero read bulk status received: %d\n", 390 __func__, urb->status); 391 goto exit; 392 } 393 394 if (tty && RxCount) { 395 flag_data = 0; 396 for (i = 0; i < RxCount; ++i) { 397 /* Look ahead code here */ 398 if ((i <= (RxCount - 3)) && (data[i] == 0x1b) 399 && (data[i + 1] == 0x1b)) { 400 flag = 0; 401 switch (data[i + 2]) { 402 case 0x00: 403 /* line status change 4th byte must follow */ 404 if (i > (RxCount - 4)) { 405 dbg("Illegal escape seuences in received data\n"); 406 break; 407 } 408 ProcessLineStatus(qt_port, data[i + 3]); 409 i += 3; 410 flag = 1; 411 break; 412 413 case 0x01: 414 /* Modem status status change 4th byte must follow */ 415 dbg("Modem status status.\n"); 416 if (i > (RxCount - 4)) { 417 dbg("Illegal escape sequences in received data\n"); 418 break; 419 } 420 ProcessModemStatus(qt_port, 421 data[i + 3]); 422 i += 3; 423 flag = 1; 424 break; 425 case 0xff: 426 dbg("No status sequence.\n"); 427 428 if (tty) { 429 ProcessRxChar(tty, port, data[i]); 430 ProcessRxChar(tty, port, data[i + 1]); 431 } 432 i += 2; 433 break; 434 } 435 if (flag == 1) 436 continue; 437 } 438 439 if (tty && urb->actual_length) 440 tty_insert_flip_char(tty, data[i], TTY_NORMAL); 441 442 } 443 tty_flip_buffer_push(tty); 444 } 445 446 /* Continue trying to always read */ 447 usb_fill_bulk_urb(port->read_urb, serial->dev, 448 usb_rcvbulkpipe(serial->dev, 449 port->bulk_in_endpointAddress), 450 port->read_urb->transfer_buffer, 451 port->read_urb->transfer_buffer_length, 452 qt_read_bulk_callback, port); 453 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 454 if (result) 455 dbg("%s - failed resubmitting read urb, error %d", 456 __func__, result); 457 else { 458 if (tty && RxCount) { 459 tty_flip_buffer_push(tty); 460 tty_schedule_flip(tty); 461 } 462 } 463 464 schedule_work(&port->work); 465exit: 466 tty_kref_put(tty); 467} 468 469/* 470 * qt_get_device 471 * Issue a GET_DEVICE vendor-specific request on the default control pipe If 472 * successful, fills in the qt_get_device_data structure pointed to by 473 * device_data, otherwise return a negative error number of the problem. 474 */ 475 476static int qt_get_device(struct usb_serial *serial, 477 struct qt_get_device_data *device_data) 478{ 479 int result; 480 unsigned char *transfer_buffer; 481 482 transfer_buffer = 483 kmalloc(sizeof(struct qt_get_device_data), GFP_KERNEL); 484 if (!transfer_buffer) 485 return -ENOMEM; 486 487 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 488 QT_SET_GET_DEVICE, 0xc0, 0, 0, 489 transfer_buffer, 490 sizeof(struct qt_get_device_data), 300); 491 if (result > 0) 492 memcpy(device_data, transfer_buffer, 493 sizeof(struct qt_get_device_data)); 494 kfree(transfer_buffer); 495 496 return result; 497} 498 499/**************************************************************************** 500 * BoxSetPrebufferLevel 501 TELLS BOX WHEN TO ASSERT FLOW CONTROL 502 ****************************************************************************/ 503static int BoxSetPrebufferLevel(struct usb_serial *serial) 504{ 505 int result; 506 __u16 buffer_length; 507 508 buffer_length = PREFUFF_LEVEL_CONSERVATIVE; 509 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 510 QT_GET_SET_PREBUF_TRIG_LVL, 0x40, 511 buffer_length, 0, NULL, 0, 300); 512 return result; 513} 514 515/**************************************************************************** 516 * BoxSetATC 517 TELLS BOX WHEN TO ASSERT automatic transmitter control 518 ****************************************************************************/ 519static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode) 520{ 521 int result; 522 __u16 buffer_length; 523 524 buffer_length = PREFUFF_LEVEL_CONSERVATIVE; 525 526 result = 527 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 528 QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300); 529 530 return result; 531} 532 533/** 534 * qt_set_device 535 * Issue a SET_DEVICE vendor-specific request on the default control pipe If 536 * successful returns the number of bytes written, otherwise it returns a 537 * negative error number of the problem. 538 */ 539static int qt_set_device(struct usb_serial *serial, 540 struct qt_get_device_data *device_data) 541{ 542 int result; 543 __u16 length; 544 __u16 PortSettings; 545 546 PortSettings = ((__u16) (device_data->portb)); 547 PortSettings = (PortSettings << 8); 548 PortSettings += ((__u16) (device_data->porta)); 549 550 length = sizeof(struct qt_get_device_data); 551 dbg("%s - PortSettings = 0x%x\n", __func__, PortSettings); 552 553 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 554 QT_SET_GET_DEVICE, 0x40, PortSettings, 555 0, NULL, 0, 300); 556 return result; 557} 558 559static int qt_open_channel(struct usb_serial *serial, __u16 Uart_Number, 560 struct qt_open_channel_data *pDeviceData) 561{ 562 int result; 563 564 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 565 QT_OPEN_CLOSE_CHANNEL, 566 USBD_TRANSFER_DIRECTION_IN, 1, Uart_Number, 567 pDeviceData, 568 sizeof(struct qt_open_channel_data), 300); 569 570 return result; 571 572} 573 574static int qt_close_channel(struct usb_serial *serial, __u16 Uart_Number) 575{ 576 int result; 577 578 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 579 QT_OPEN_CLOSE_CHANNEL, 580 USBD_TRANSFER_DIRECTION_OUT, 0, Uart_Number, 581 NULL, 0, 300); 582 583 return result; 584 585} 586 587/**************************************************************************** 588* BoxGetRegister 589* issuse a GET_REGISTER vendor-spcific request on the default control pipe 590* If successful, fills in the pValue with the register value asked for 591****************************************************************************/ 592static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number, 593 unsigned short Register_Num, __u8 *pValue) 594{ 595 int result; 596 __u16 current_length; 597 598 current_length = sizeof(struct qt_get_device_data); 599 600 result = 601 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 602 QT_GET_SET_REGISTER, 0xC0, Register_Num, 603 Uart_Number, (void *)pValue, sizeof(*pValue), 300); 604 605 return result; 606} 607 608/**************************************************************************** 609* BoxSetRegister 610* issuse a GET_REGISTER vendor-spcific request on the default control pipe 611* If successful, fills in the pValue with the register value asked for 612****************************************************************************/ 613static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number, 614 unsigned short Register_Num, unsigned short Value) 615{ 616 int result; 617 unsigned short RegAndByte; 618 619 RegAndByte = Value; 620 RegAndByte = RegAndByte << 8; 621 RegAndByte = RegAndByte + Register_Num; 622 623/* 624 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 625 QT_GET_SET_REGISTER, 0xC0, Register_Num, 626 Uart_Number, NULL, 0, 300); 627*/ 628 629 result = 630 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 631 QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number, 632 NULL, 0, 300); 633 634 return result; 635} 636 637/* 638 * qt_setuart 639 * issuse a SET_UART vendor-spcific request on the default control pipe 640 * If successful sets baud rate divisor and LCR value 641 */ 642static int qt_setuart(struct usb_serial *serial, unsigned short Uart_Number, 643 unsigned short default_divisor, unsigned char default_LCR) 644{ 645 int result; 646 unsigned short UartNumandLCR; 647 648 UartNumandLCR = (default_LCR << 8) + Uart_Number; 649 650 result = 651 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 652 QT_GET_SET_UART, 0x40, default_divisor, 653 UartNumandLCR, NULL, 0, 300); 654 655 return result; 656} 657 658static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index, 659 int bSet) 660{ 661 __u8 mcr = 0; 662 __u8 msr = 0, MOUT_Value = 0; 663 unsigned int status; 664 665 if (bSet == 1) { 666 /* flow control, box will clear RTS line to prevent remote */ 667 mcr = SERIAL_MCR_RTS; 668 } /* device from xmitting more chars */ 669 else { 670 /* no flow control to remote device */ 671 mcr = 0; 672 673 } 674 MOUT_Value = mcr << 8; 675 676 if (bSet == 1) { 677 /* flow control, box will inhibit xmit data if CTS line is 678 * asserted */ 679 msr = SERIAL_MSR_CTS; 680 } else { 681 /* Box will not inhimbe xmit data due to CTS line */ 682 msr = 0; 683 } 684 MOUT_Value |= msr; 685 686 status = 687 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 688 QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value, 689 index, NULL, 0, 300); 690 return status; 691 692} 693 694static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 index, 695 unsigned char stop_char, unsigned char start_char) 696{ 697 __u16 nSWflowout; 698 int result; 699 700 nSWflowout = start_char << 8; 701 nSWflowout = (unsigned short)stop_char; 702 703 result = 704 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 705 QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout, 706 index, NULL, 0, 300); 707 return result; 708 709} 710 711static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index) 712{ 713 int result; 714 715 result = 716 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 717 QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index, 718 NULL, 0, 300); 719 return result; 720 721} 722 723static int qt_startup(struct usb_serial *serial) 724{ 725 struct usb_serial_port *port; 726 struct quatech_port *qt_port; 727 struct qt_get_device_data DeviceData; 728 int i; 729 int status; 730 731 dbg("enterting %s", __func__); 732 733 /* Now setup per port private data */ 734 for (i = 0; i < serial->num_ports; i++) { 735 port = serial->port[i]; 736 qt_port = kzalloc(sizeof(*qt_port), GFP_KERNEL); 737 if (!qt_port) { 738 dbg("%s: kmalloc for quatech_port (%d) failed!.", 739 __func__, i); 740 for (--i; i >= 0; i--) { 741 port = serial->port[i]; 742 kfree(usb_get_serial_port_data(port)); 743 usb_set_serial_port_data(port, NULL); 744 } 745 return -ENOMEM; 746 } 747 spin_lock_init(&qt_port->lock); 748 749 usb_set_serial_port_data(port, qt_port); 750 751 } 752 753 status = qt_get_device(serial, &DeviceData); 754 if (status < 0) { 755 dbg(__FILE__ "box_get_device failed"); 756 goto startup_error; 757 } 758 759 dbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb); 760 761 DeviceData.portb &= ~FULLPWRBIT; 762 dbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb); 763 764 status = qt_set_device(serial, &DeviceData); 765 if (status < 0) { 766 dbg(__FILE__ "qt_set_device failed\n"); 767 goto startup_error; 768 } 769 770 status = qt_get_device(serial, &DeviceData); 771 if (status < 0) { 772 dbg(__FILE__ "qt_get_device failed"); 773 goto startup_error; 774 } 775 776 switch (serial->dev->descriptor.idProduct) { 777 case QUATECH_SSU100: 778 case QUATECH_DSU100: 779 case QUATECH_QSU100: 780 case QUATECH_ESU100A: 781 case QUATECH_ESU100B: 782 case QUATECH_HSU100A: 783 case QUATECH_HSU100B: 784 case QUATECH_HSU100C: 785 case QUATECH_HSU100D: 786 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS); 787 DeviceData.porta |= CLKS_X4; 788 DeviceData.portb &= ~(LOOPMODE_BITS); 789 DeviceData.portb |= RS232_MODE; 790 break; 791 792 case QUATECH_SSU200: 793 case QUATECH_DSU200: 794 case QUATECH_QSU200: 795 case QUATECH_ESU200A: 796 case QUATECH_ESU200B: 797 case QUATECH_HSU200A: 798 case QUATECH_HSU200B: 799 case QUATECH_HSU200C: 800 case QUATECH_HSU200D: 801 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS); 802 DeviceData.porta |= CLKS_X4; 803 DeviceData.portb &= ~(LOOPMODE_BITS); 804 DeviceData.portb |= ALL_LOOPBACK; 805 break; 806 default: 807 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS); 808 DeviceData.porta |= CLKS_X4; 809 DeviceData.portb &= ~(LOOPMODE_BITS); 810 DeviceData.portb |= RS232_MODE; 811 break; 812 813 } 814 815 status = BoxSetPrebufferLevel(serial); /* sets to default value */ 816 if (status < 0) { 817 dbg(__FILE__ "BoxSetPrebufferLevel failed\n"); 818 goto startup_error; 819 } 820 821 status = BoxSetATC(serial, ATC_DISABLED); 822 if (status < 0) { 823 dbg(__FILE__ "BoxSetATC failed\n"); 824 goto startup_error; 825 } 826 827 dbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb); 828 829 DeviceData.portb |= NEXT_BOARD_POWER_BIT; 830 dbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb); 831 832 status = qt_set_device(serial, &DeviceData); 833 if (status < 0) { 834 dbg(__FILE__ "qt_set_device failed\n"); 835 goto startup_error; 836 } 837 838 dbg("Exit Success %s\n", __func__); 839 840 return 0; 841 842startup_error: 843 for (i = 0; i < serial->num_ports; i++) { 844 port = serial->port[i]; 845 qt_port = qt_get_port_private(port); 846 kfree(qt_port); 847 usb_set_serial_port_data(port, NULL); 848 } 849 850 dbg("Exit fail %s\n", __func__); 851 852 return -EIO; 853} 854 855static void qt_release(struct usb_serial *serial) 856{ 857 struct usb_serial_port *port; 858 struct quatech_port *qt_port; 859 int i; 860 861 dbg("enterting %s", __func__); 862 863 for (i = 0; i < serial->num_ports; i++) { 864 port = serial->port[i]; 865 if (!port) 866 continue; 867 868 qt_port = usb_get_serial_port_data(port); 869 kfree(qt_port); 870 usb_set_serial_port_data(port, NULL); 871 } 872 873} 874 875static int qt_open(struct tty_struct *tty, 876 struct usb_serial_port *port) 877{ 878 struct usb_serial *serial; 879 struct quatech_port *quatech_port; 880 struct quatech_port *port0; 881 struct qt_open_channel_data ChannelData; 882 883 int result; 884 885 if (port_paranoia_check(port, __func__)) 886 return -ENODEV; 887 888 dbg("%s - port %d\n", __func__, port->number); 889 890 serial = port->serial; 891 892 if (serial_paranoia_check(serial, __func__)) 893 return -ENODEV; 894 895 quatech_port = qt_get_port_private(port); 896 port0 = qt_get_port_private(serial->port[0]); 897 898 if (quatech_port == NULL || port0 == NULL) 899 return -ENODEV; 900 901 usb_clear_halt(serial->dev, port->write_urb->pipe); 902 usb_clear_halt(serial->dev, port->read_urb->pipe); 903 port0->open_ports++; 904 905 result = qt_get_device(serial, &port0->DeviceData); 906 907 /* Port specific setups */ 908 result = qt_open_channel(serial, port->number, &ChannelData); 909 if (result < 0) { 910 dbg(__FILE__ "qt_open_channel failed\n"); 911 return result; 912 } 913 dbg(__FILE__ "qt_open_channel completed.\n"); 914 915 quatech_port->shadowLSR = ChannelData.line_status & 916 (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI); 917 918 quatech_port->shadowMSR = ChannelData.modem_status & 919 (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD); 920 921 /* Set Baud rate to default and turn off (default)flow control here */ 922 result = qt_setuart(serial, port->number, DEFAULT_DIVISOR, DEFAULT_LCR); 923 if (result < 0) { 924 dbg(__FILE__ "qt_setuart failed\n"); 925 return result; 926 } 927 dbg(__FILE__ "qt_setuart completed.\n"); 928 929 /* 930 * Put this here to make it responsive to stty and defaults set by 931 * the tty layer 932 */ 933 /* qt_set_termios(tty, port, NULL); */ 934 935 /* Check to see if we've set up our endpoint info yet */ 936 if (port0->open_ports == 1) { 937 if (serial->port[0]->interrupt_in_buffer == NULL) { 938 /* set up interrupt urb */ 939 usb_fill_int_urb(serial->port[0]->interrupt_in_urb, 940 serial->dev, 941 usb_rcvintpipe(serial->dev, 942 serial->port[0]->interrupt_in_endpointAddress), 943 serial->port[0]->interrupt_in_buffer, 944 serial->port[0]-> 945 interrupt_in_urb->transfer_buffer_length, 946 qt_interrupt_callback, serial, 947 serial->port[0]-> 948 interrupt_in_urb->interval); 949 950 result = 951 usb_submit_urb(serial->port[0]->interrupt_in_urb, 952 GFP_KERNEL); 953 if (result) { 954 dev_err(&port->dev, 955 "%s - Error %d submitting " 956 "interrupt urb\n", __func__, result); 957 } 958 959 } 960 961 } 962 963 dbg("port number is %d\n", port->number); 964 dbg("serial number is %d\n", port->serial->minor); 965 dbg("Bulkin endpoint is %d\n", port->bulk_in_endpointAddress); 966 dbg("BulkOut endpoint is %d\n", port->bulk_out_endpointAddress); 967 dbg("Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress); 968 dbg("port's number in the device is %d\n", quatech_port->port_num); 969 quatech_port->read_urb = port->read_urb; 970 971 /* set up our bulk in urb */ 972 973 usb_fill_bulk_urb(quatech_port->read_urb, 974 serial->dev, 975 usb_rcvbulkpipe(serial->dev, 976 port->bulk_in_endpointAddress), 977 port->bulk_in_buffer, 978 quatech_port->read_urb->transfer_buffer_length, 979 qt_read_bulk_callback, quatech_port); 980 981 dbg("qt_open: bulkin endpoint is %d\n", port->bulk_in_endpointAddress); 982 quatech_port->read_urb_busy = true; 983 result = usb_submit_urb(quatech_port->read_urb, GFP_KERNEL); 984 if (result) { 985 dev_err(&port->dev, 986 "%s - Error %d submitting control urb\n", 987 __func__, result); 988 quatech_port->read_urb_busy = false; 989 } 990 991 /* initialize our wait queues */ 992 init_waitqueue_head(&quatech_port->wait); 993 init_waitqueue_head(&quatech_port->msr_wait); 994 995 /* initialize our icount structure */ 996 memset(&(quatech_port->icount), 0x00, sizeof(quatech_port->icount)); 997 998 return 0; 999 1000} 1001 1002static int qt_chars_in_buffer(struct tty_struct *tty) 1003{ 1004 struct usb_serial_port *port = tty->driver_data; 1005 struct usb_serial *serial; 1006 int chars = 0; 1007 1008 serial = get_usb_serial(port, __func__); 1009 1010 dbg("%s - port %d\n", __func__, port->number); 1011 1012 if (serial->num_bulk_out) { 1013 if (port->write_urb->status == -EINPROGRESS) 1014 chars = port->write_urb->transfer_buffer_length; 1015 } 1016 1017 dbg("%s - returns %d\n", __func__, chars); 1018 1019 return chars; 1020} 1021 1022static void qt_block_until_empty(struct tty_struct *tty, 1023 struct quatech_port *qt_port) 1024{ 1025 int timeout = HZ / 10; 1026 int wait = 30; 1027 int count; 1028 1029 while (1) { 1030 1031 count = qt_chars_in_buffer(tty); 1032 1033 if (count <= 0) 1034 return; 1035 1036 interruptible_sleep_on_timeout(&qt_port->wait, timeout); 1037 1038 wait--; 1039 if (wait == 0) { 1040 dbg("%s - TIMEOUT", __func__); 1041 return; 1042 } else { 1043 wait = 30; 1044 } 1045 } 1046} 1047 1048static void qt_close(struct usb_serial_port *port) 1049{ 1050 struct usb_serial *serial = port->serial; 1051 struct quatech_port *qt_port; 1052 struct quatech_port *port0; 1053 struct tty_struct *tty; 1054 int status; 1055 unsigned int index; 1056 status = 0; 1057 1058 dbg("%s - port %d\n", __func__, port->number); 1059 1060 tty = tty_port_tty_get(&port->port); 1061 index = tty->index - serial->minor; 1062 1063 qt_port = qt_get_port_private(port); 1064 port0 = qt_get_port_private(serial->port[0]); 1065 1066 /* shutdown any bulk reads that might be going on */ 1067 if (serial->num_bulk_out) 1068 usb_unlink_urb(port->write_urb); 1069 if (serial->num_bulk_in) 1070 usb_unlink_urb(port->read_urb); 1071 1072 /* wait up to for transmitter to empty */ 1073 if (serial->dev) 1074 qt_block_until_empty(tty, qt_port); 1075 tty_kref_put(tty); 1076 1077 /* Close uart channel */ 1078 status = qt_close_channel(serial, index); 1079 if (status < 0) 1080 dbg("%s - port %d qt_close_channel failed.\n", 1081 __func__, port->number); 1082 1083 port0->open_ports--; 1084 1085 dbg("qt_num_open_ports in close%d:in port%d\n", 1086 port0->open_ports, port->number); 1087 1088 if (port0->open_ports == 0) { 1089 if (serial->port[0]->interrupt_in_urb) { 1090 dbg("%s", "Shutdown interrupt_in_urb\n"); 1091 usb_kill_urb(serial->port[0]->interrupt_in_urb); 1092 } 1093 1094 } 1095 1096 if (qt_port->write_urb) { 1097 /* if this urb had a transfer buffer already (old tx) free it */ 1098 if (qt_port->write_urb->transfer_buffer != NULL) 1099 kfree(qt_port->write_urb->transfer_buffer); 1100 usb_free_urb(qt_port->write_urb); 1101 } 1102 1103} 1104 1105static int qt_write(struct tty_struct *tty, struct usb_serial_port *port, 1106 const unsigned char *buf, int count) 1107{ 1108 int result; 1109 struct usb_serial *serial = get_usb_serial(port, __func__); 1110 1111 if (serial == NULL) 1112 return -ENODEV; 1113 1114 dbg("%s - port %d\n", __func__, port->number); 1115 1116 if (count == 0) { 1117 dbg("%s - write request of 0 bytes\n", __func__); 1118 return 0; 1119 } 1120 1121 /* only do something if we have a bulk out endpoint */ 1122 if (serial->num_bulk_out) { 1123 if (port->write_urb->status == -EINPROGRESS) { 1124 dbg("%s - already writing\n", __func__); 1125 return 0; 1126 } 1127 1128 count = 1129 (count > port->bulk_out_size) ? port->bulk_out_size : count; 1130 memcpy(port->write_urb->transfer_buffer, buf, count); 1131 1132 /* set up our urb */ 1133 1134 usb_fill_bulk_urb(port->write_urb, serial->dev, 1135 usb_sndbulkpipe(serial->dev, 1136 port-> 1137 bulk_out_endpointAddress), 1138 port->write_urb->transfer_buffer, count, 1139 qt_write_bulk_callback, port); 1140 1141 /* send the data out the bulk port */ 1142 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 1143 if (result) 1144 dbg("%s - failed submitting write urb, error %d\n", 1145 __func__, result); 1146 else 1147 result = count; 1148 1149 return result; 1150 } 1151 1152 /* no bulk out, so return 0 bytes written */ 1153 return 0; 1154} 1155 1156static int qt_write_room(struct tty_struct *tty) 1157{ 1158 struct usb_serial_port *port = tty->driver_data; 1159 struct usb_serial *serial; 1160 struct quatech_port *qt_port; 1161 unsigned long flags; 1162 1163 int retval = -EINVAL; 1164 1165 if (port_paranoia_check(port, __func__)) { 1166 dbg("%s", "Invalid port\n"); 1167 return -1; 1168 } 1169 1170 serial = get_usb_serial(port, __func__); 1171 1172 if (!serial) 1173 return -ENODEV; 1174 1175 qt_port = qt_get_port_private(port); 1176 1177 spin_lock_irqsave(&qt_port->lock, flags); 1178 1179 dbg("%s - port %d\n", __func__, port->number); 1180 1181 if (serial->num_bulk_out) { 1182 if (port->write_urb->status != -EINPROGRESS) 1183 retval = port->bulk_out_size; 1184 } 1185 1186 spin_unlock_irqrestore(&qt_port->lock, flags); 1187 return retval; 1188 1189} 1190 1191static int qt_ioctl(struct tty_struct *tty, struct file *file, 1192 unsigned int cmd, unsigned long arg) 1193{ 1194 struct usb_serial_port *port = tty->driver_data; 1195 struct quatech_port *qt_port = qt_get_port_private(port); 1196 struct usb_serial *serial = get_usb_serial(port, __func__); 1197 unsigned int index; 1198 1199 dbg("%s cmd 0x%04x", __func__, cmd); 1200 1201 index = tty->index - serial->minor; 1202 1203 if (cmd == TIOCMIWAIT) { 1204 while (qt_port != NULL) { 1205 interruptible_sleep_on(&qt_port->msr_wait); 1206 if (signal_pending(current)) 1207 return -ERESTARTSYS; 1208 else { 1209 char diff = qt_port->diff_status; 1210 1211 if (diff == 0) 1212 return -EIO; /* no change => error */ 1213 1214 /* Consume all events */ 1215 qt_port->diff_status = 0; 1216 1217 if (((arg & TIOCM_RNG) 1218 && (diff & SERIAL_MSR_RI)) 1219 || ((arg & TIOCM_DSR) 1220 && (diff & SERIAL_MSR_DSR)) 1221 || ((arg & TIOCM_CD) 1222 && (diff & SERIAL_MSR_CD)) 1223 || ((arg & TIOCM_CTS) 1224 && (diff & SERIAL_MSR_CTS))) { 1225 return 0; 1226 } 1227 } 1228 } 1229 return 0; 1230 } 1231 1232 dbg("%s -No ioctl for that one. port = %d\n", __func__, port->number); 1233 return -ENOIOCTLCMD; 1234} 1235 1236static void qt_set_termios(struct tty_struct *tty, 1237 struct usb_serial_port *port, 1238 struct ktermios *old_termios) 1239{ 1240 struct ktermios *termios = tty->termios; 1241 unsigned char new_LCR = 0; 1242 unsigned int cflag = termios->c_cflag; 1243 unsigned int index; 1244 int baud, divisor, remainder; 1245 int status; 1246 1247 dbg("%s", __func__); 1248 1249 index = tty->index - port->serial->minor; 1250 1251 switch (cflag) { 1252 case CS5: 1253 new_LCR |= SERIAL_5_DATA; 1254 break; 1255 case CS6: 1256 new_LCR |= SERIAL_6_DATA; 1257 break; 1258 case CS7: 1259 new_LCR |= SERIAL_7_DATA; 1260 break; 1261 default: 1262 case CS8: 1263 new_LCR |= SERIAL_8_DATA; 1264 break; 1265 } 1266 1267 /* Parity stuff */ 1268 if (cflag & PARENB) { 1269 if (cflag & PARODD) 1270 new_LCR |= SERIAL_ODD_PARITY; 1271 else 1272 new_LCR |= SERIAL_EVEN_PARITY; 1273 } 1274 if (cflag & CSTOPB) 1275 new_LCR |= SERIAL_TWO_STOPB; 1276 else 1277 new_LCR |= SERIAL_ONE_STOPB; 1278 1279 dbg("%s - 4\n", __func__); 1280 1281 /* Thats the LCR stuff, go ahead and set it */ 1282 baud = tty_get_baud_rate(tty); 1283 if (!baud) 1284 /* pick a default, any default... */ 1285 baud = 9600; 1286 1287 dbg("%s - got baud = %d\n", __func__, baud); 1288 1289 divisor = MAX_BAUD_RATE / baud; 1290 remainder = MAX_BAUD_RATE % baud; 1291 /* Round to nearest divisor */ 1292 if (((remainder * 2) >= baud) && (baud != 110)) 1293 divisor++; 1294 1295 /* 1296 * Set Baud rate to default and turn off (default)flow control here 1297 */ 1298 status = 1299 qt_setuart(port->serial, index, (unsigned short)divisor, new_LCR); 1300 if (status < 0) { 1301 dbg(__FILE__ "qt_setuart failed\n"); 1302 return; 1303 } 1304 1305 /* Now determine flow control */ 1306 if (cflag & CRTSCTS) { 1307 dbg("%s - Enabling HW flow control port %d\n", __func__, 1308 port->number); 1309 1310 /* Enable RTS/CTS flow control */ 1311 status = BoxSetHW_FlowCtrl(port->serial, index, 1); 1312 1313 if (status < 0) { 1314 dbg(__FILE__ "BoxSetHW_FlowCtrl failed\n"); 1315 return; 1316 } 1317 } else { 1318 /* Disable RTS/CTS flow control */ 1319 dbg("%s - disabling HW flow control port %d\n", __func__, 1320 port->number); 1321 1322 status = BoxSetHW_FlowCtrl(port->serial, index, 0); 1323 if (status < 0) { 1324 dbg(__FILE__ "BoxSetHW_FlowCtrl failed\n"); 1325 return; 1326 } 1327 1328 } 1329 1330 /* if we are implementing XON/XOFF, set the start and stop character in 1331 * the device */ 1332 if (I_IXOFF(tty) || I_IXON(tty)) { 1333 unsigned char stop_char = STOP_CHAR(tty); 1334 unsigned char start_char = START_CHAR(tty); 1335 status = 1336 BoxSetSW_FlowCtrl(port->serial, index, stop_char, 1337 start_char); 1338 if (status < 0) 1339 dbg(__FILE__ "BoxSetSW_FlowCtrl (enabled) failed\n"); 1340 1341 } else { 1342 /* disable SW flow control */ 1343 status = BoxDisable_SW_FlowCtrl(port->serial, index); 1344 if (status < 0) 1345 dbg(__FILE__ "BoxSetSW_FlowCtrl (diabling) failed\n"); 1346 1347 } 1348 tty->termios->c_cflag &= ~CMSPAR; 1349} 1350 1351static void qt_break(struct tty_struct *tty, int break_state) 1352{ 1353 struct usb_serial_port *port = tty->driver_data; 1354 struct usb_serial *serial = get_usb_serial(port, __func__); 1355 struct quatech_port *qt_port; 1356 u16 index, onoff; 1357 unsigned int result; 1358 unsigned long flags; 1359 1360 index = tty->index - serial->minor; 1361 1362 qt_port = qt_get_port_private(port); 1363 1364 if (break_state == -1) 1365 onoff = 1; 1366 else 1367 onoff = 0; 1368 1369 spin_lock_irqsave(&qt_port->lock, flags); 1370 1371 dbg("%s - port %d\n", __func__, port->number); 1372 1373 result = 1374 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 1375 QT_BREAK_CONTROL, 0x40, onoff, index, NULL, 0, 300); 1376 1377 spin_unlock_irqrestore(&qt_port->lock, flags); 1378} 1379 1380static inline int qt_real_tiocmget(struct tty_struct *tty, 1381 struct usb_serial_port *port, 1382 struct file *file, struct usb_serial *serial) 1383{ 1384 1385 u8 mcr; 1386 u8 msr; 1387 unsigned int result = 0; 1388 int status; 1389 unsigned int index; 1390 1391 dbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty); 1392 1393 index = tty->index - serial->minor; 1394 status = 1395 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr); 1396 if (status >= 0) { 1397 status = 1398 BoxGetRegister(port->serial, index, 1399 MODEM_STATUS_REGISTER, &msr); 1400 1401 } 1402 1403 if (status >= 0) { 1404 result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0) 1405 /* DTR IS SET */ 1406 | ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0) 1407 /* RTS IS SET */ 1408 | ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0) 1409 /* CTS is set */ 1410 | ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0) 1411 /* Carrier detect is set */ 1412 | ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0) 1413 /* Ring indicator set */ 1414 | ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0); 1415 /* DSR is set */ 1416 return result; 1417 1418 } else 1419 return -ESPIPE; 1420} 1421 1422static inline int qt_real_tiocmset(struct tty_struct *tty, 1423 struct usb_serial_port *port, 1424 struct file *file, 1425 struct usb_serial *serial, 1426 unsigned int value) 1427{ 1428 1429 u8 mcr; 1430 int status; 1431 unsigned int index; 1432 1433 dbg("%s - port %d\n", __func__, port->number); 1434 1435 index = tty->index - serial->minor; 1436 status = 1437 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr); 1438 if (status < 0) 1439 return -ESPIPE; 1440 1441 /* 1442 * Turn off the RTS and DTR and loopbcck and then only turn on what was 1443 * asked for 1444 */ 1445 mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP); 1446 if (value & TIOCM_RTS) 1447 mcr |= SERIAL_MCR_RTS; 1448 if (value & TIOCM_DTR) 1449 mcr |= SERIAL_MCR_DTR; 1450 if (value & TIOCM_LOOP) 1451 mcr |= SERIAL_MCR_LOOP; 1452 1453 status = 1454 BoxSetRegister(port->serial, index, MODEM_CONTROL_REGISTER, mcr); 1455 if (status < 0) 1456 return -ESPIPE; 1457 else 1458 return 0; 1459} 1460 1461static int qt_tiocmget(struct tty_struct *tty, struct file *file) 1462{ 1463 struct usb_serial_port *port = tty->driver_data; 1464 struct usb_serial *serial = get_usb_serial(port, __func__); 1465 struct quatech_port *qt_port = qt_get_port_private(port); 1466 int retval = -ENODEV; 1467 unsigned long flags; 1468 1469 dbg("In %s\n", __func__); 1470 1471 if (!serial) 1472 return -ENODEV; 1473 1474 spin_lock_irqsave(&qt_port->lock, flags); 1475 1476 dbg("%s - port %d\n", __func__, port->number); 1477 dbg("%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding); 1478 1479 retval = qt_real_tiocmget(tty, port, file, serial); 1480 1481 spin_unlock_irqrestore(&qt_port->lock, flags); 1482 return retval; 1483} 1484 1485static int qt_tiocmset(struct tty_struct *tty, struct file *file, 1486 unsigned int set, unsigned int clear) 1487{ 1488 1489 struct usb_serial_port *port = tty->driver_data; 1490 struct usb_serial *serial = get_usb_serial(port, __func__); 1491 struct quatech_port *qt_port = qt_get_port_private(port); 1492 unsigned long flags; 1493 int retval = -ENODEV; 1494 1495 dbg("In %s\n", __func__); 1496 1497 if (!serial) 1498 return -ENODEV; 1499 1500 spin_lock_irqsave(&qt_port->lock, flags); 1501 1502 dbg("%s - port %d\n", __func__, port->number); 1503 dbg("%s - qt_port->RxHolding = %d\n", __func__, qt_port->RxHolding); 1504 1505 retval = qt_real_tiocmset(tty, port, file, serial, set); 1506 1507 spin_unlock_irqrestore(&qt_port->lock, flags); 1508 return retval; 1509} 1510 1511static void qt_throttle(struct tty_struct *tty) 1512{ 1513 struct usb_serial_port *port = tty->driver_data; 1514 struct usb_serial *serial = get_usb_serial(port, __func__); 1515 struct quatech_port *qt_port; 1516 unsigned long flags; 1517 1518 dbg("%s - port %d\n", __func__, port->number); 1519 1520 if (!serial) 1521 return; 1522 1523 qt_port = qt_get_port_private(port); 1524 1525 spin_lock_irqsave(&qt_port->lock, flags); 1526 1527 /* pass on to the driver specific version of this function */ 1528 qt_port->RxHolding = 1; 1529 dbg("%s - port->RxHolding = 1\n", __func__); 1530 1531 spin_unlock_irqrestore(&qt_port->lock, flags); 1532 return; 1533} 1534 1535static void qt_unthrottle(struct tty_struct *tty) 1536{ 1537 struct usb_serial_port *port = tty->driver_data; 1538 struct usb_serial *serial = get_usb_serial(port, __func__); 1539 struct quatech_port *qt_port; 1540 unsigned long flags; 1541 unsigned int result; 1542 1543 if (!serial) 1544 return; 1545 1546 qt_port = qt_get_port_private(port); 1547 1548 spin_lock_irqsave(&qt_port->lock, flags); 1549 1550 dbg("%s - port %d\n", __func__, port->number); 1551 1552 if (qt_port->RxHolding == 1) { 1553 dbg("%s -qt_port->RxHolding == 1\n", __func__); 1554 1555 qt_port->RxHolding = 0; 1556 dbg("%s - qt_port->RxHolding = 0\n", __func__); 1557 1558 /* if we have a bulk endpoint, start it up */ 1559 if ((serial->num_bulk_in) && (qt_port->ReadBulkStopped == 1)) { 1560 /* Start reading from the device */ 1561 usb_fill_bulk_urb(port->read_urb, serial->dev, 1562 usb_rcvbulkpipe(serial->dev, 1563 port->bulk_in_endpointAddress), 1564 port->read_urb->transfer_buffer, 1565 port->read_urb-> 1566 transfer_buffer_length, 1567 qt_read_bulk_callback, port); 1568 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 1569 if (result) 1570 err("%s - failed restarting read urb, error %d", 1571 __func__, result); 1572 } 1573 } 1574 spin_unlock_irqrestore(&qt_port->lock, flags); 1575 return; 1576 1577} 1578 1579static int qt_calc_num_ports(struct usb_serial *serial) 1580{ 1581 int num_ports; 1582 1583 dbg("numberofendpoints: %d\n", 1584 (int)serial->interface->cur_altsetting->desc.bNumEndpoints); 1585 dbg("numberofendpoints: %d\n", 1586 (int)serial->interface->altsetting->desc.bNumEndpoints); 1587 1588 num_ports = 1589 (serial->interface->cur_altsetting->desc.bNumEndpoints - 1) / 2; 1590 1591 return num_ports; 1592} 1593 1594static struct usb_serial_driver quatech_device = { 1595 .driver = { 1596 .owner = THIS_MODULE, 1597 .name = "serqt", 1598 }, 1599 .description = DRIVER_DESC, 1600 .usb_driver = &serqt_usb_driver, 1601 .id_table = serqt_id_table, 1602 .num_ports = 8, 1603 .open = qt_open, 1604 .close = qt_close, 1605 .write = qt_write, 1606 .write_room = qt_write_room, 1607 .chars_in_buffer = qt_chars_in_buffer, 1608 .throttle = qt_throttle, 1609 .unthrottle = qt_unthrottle, 1610 .calc_num_ports = qt_calc_num_ports, 1611 .ioctl = qt_ioctl, 1612 .set_termios = qt_set_termios, 1613 .break_ctl = qt_break, 1614 .tiocmget = qt_tiocmget, 1615 .tiocmset = qt_tiocmset, 1616 .attach = qt_startup, 1617 .release = qt_release, 1618}; 1619 1620static int __init serqt_usb_init(void) 1621{ 1622 int retval; 1623 1624 dbg("%s\n", __func__); 1625 1626 /* register with usb-serial */ 1627 retval = usb_serial_register(&quatech_device); 1628 1629 if (retval) 1630 goto failed_usb_serial_register; 1631 1632 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1633 DRIVER_DESC "\n"); 1634 1635 /* register with usb */ 1636 1637 retval = usb_register(&serqt_usb_driver); 1638 if (retval == 0) 1639 return 0; 1640 1641 /* if we're here, usb_register() failed */ 1642 usb_serial_deregister(&quatech_device); 1643failed_usb_serial_register: 1644 return retval; 1645} 1646 1647static void __exit serqt_usb_exit(void) 1648{ 1649 usb_deregister(&serqt_usb_driver); 1650 usb_serial_deregister(&quatech_device); 1651} 1652 1653module_init(serqt_usb_init); 1654module_exit(serqt_usb_exit); 1655 1656MODULE_AUTHOR(DRIVER_AUTHOR); 1657MODULE_DESCRIPTION(DRIVER_DESC); 1658MODULE_LICENSE("GPL"); 1659 1660module_param(debug, bool, S_IRUGO | S_IWUSR); 1661MODULE_PARM_DESC(debug, "Debug enabled or not"); 1662