1 /* 2 * spcp8x5 USB to serial adaptor driver 3 * 4 * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com) 5 * Copyright (C) 2006 Linxb (xubin.lin@worldplus.com.cn) 6 * Copyright (C) 2006 S1 Corp. 7 * 8 * Original driver for 2.6.10 pl2303 driver by 9 * Greg Kroah-Hartman (greg@kroah.com) 10 * Changes for 2.6.20 by Harald Klein <hari@vt100.at> 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * 18 */ 19 #include <linux/kernel.h> 20 #include <linux/errno.h> 21 #include <linux/init.h> 22 #include <linux/slab.h> 23 #include <linux/tty.h> 24 #include <linux/tty_driver.h> 25 #include <linux/tty_flip.h> 26 #include <linux/module.h> 27 #include <linux/spinlock.h> 28 #include <linux/usb.h> 29 #include <linux/usb/serial.h> 30 31 #define DRIVER_DESC "SPCP8x5 USB to serial adaptor driver" 32 33 #define SPCP8x5_007_VID 0x04FC 34 #define SPCP8x5_007_PID 0x0201 35 #define SPCP8x5_008_VID 0x04fc 36 #define SPCP8x5_008_PID 0x0235 37 #define SPCP8x5_PHILIPS_VID 0x0471 38 #define SPCP8x5_PHILIPS_PID 0x081e 39 #define SPCP8x5_INTERMATIC_VID 0x04FC 40 #define SPCP8x5_INTERMATIC_PID 0x0204 41 #define SPCP8x5_835_VID 0x04fc 42 #define SPCP8x5_835_PID 0x0231 43 44 static const struct usb_device_id id_table[] = { 45 { USB_DEVICE(SPCP8x5_PHILIPS_VID , SPCP8x5_PHILIPS_PID)}, 46 { USB_DEVICE(SPCP8x5_INTERMATIC_VID, SPCP8x5_INTERMATIC_PID)}, 47 { USB_DEVICE(SPCP8x5_835_VID, SPCP8x5_835_PID)}, 48 { USB_DEVICE(SPCP8x5_008_VID, SPCP8x5_008_PID)}, 49 { USB_DEVICE(SPCP8x5_007_VID, SPCP8x5_007_PID)}, 50 { } /* Terminating entry */ 51 }; 52 MODULE_DEVICE_TABLE(usb, id_table); 53 54 struct spcp8x5_usb_ctrl_arg { 55 u8 type; 56 u8 cmd; 57 u8 cmd_type; 58 u16 value; 59 u16 index; 60 u16 length; 61 }; 62 63 64 /* spcp8x5 spec register define */ 65 #define MCR_CONTROL_LINE_RTS 0x02 66 #define MCR_CONTROL_LINE_DTR 0x01 67 #define MCR_DTR 0x01 68 #define MCR_RTS 0x02 69 70 #define MSR_STATUS_LINE_DCD 0x80 71 #define MSR_STATUS_LINE_RI 0x40 72 #define MSR_STATUS_LINE_DSR 0x20 73 #define MSR_STATUS_LINE_CTS 0x10 74 75 /* verdor command here , we should define myself */ 76 #define SET_DEFAULT 0x40 77 #define SET_DEFAULT_TYPE 0x20 78 79 #define SET_UART_FORMAT 0x40 80 #define SET_UART_FORMAT_TYPE 0x21 81 #define SET_UART_FORMAT_SIZE_5 0x00 82 #define SET_UART_FORMAT_SIZE_6 0x01 83 #define SET_UART_FORMAT_SIZE_7 0x02 84 #define SET_UART_FORMAT_SIZE_8 0x03 85 #define SET_UART_FORMAT_STOP_1 0x00 86 #define SET_UART_FORMAT_STOP_2 0x04 87 #define SET_UART_FORMAT_PAR_NONE 0x00 88 #define SET_UART_FORMAT_PAR_ODD 0x10 89 #define SET_UART_FORMAT_PAR_EVEN 0x30 90 #define SET_UART_FORMAT_PAR_MASK 0xD0 91 #define SET_UART_FORMAT_PAR_SPACE 0x90 92 93 #define GET_UART_STATUS_TYPE 0xc0 94 #define GET_UART_STATUS 0x22 95 #define GET_UART_STATUS_MSR 0x06 96 97 #define SET_UART_STATUS 0x40 98 #define SET_UART_STATUS_TYPE 0x23 99 #define SET_UART_STATUS_MCR 0x0004 100 #define SET_UART_STATUS_MCR_DTR 0x01 101 #define SET_UART_STATUS_MCR_RTS 0x02 102 #define SET_UART_STATUS_MCR_LOOP 0x10 103 104 #define SET_WORKING_MODE 0x40 105 #define SET_WORKING_MODE_TYPE 0x24 106 #define SET_WORKING_MODE_U2C 0x00 107 #define SET_WORKING_MODE_RS485 0x01 108 #define SET_WORKING_MODE_PDMA 0x02 109 #define SET_WORKING_MODE_SPP 0x03 110 111 #define SET_FLOWCTL_CHAR 0x40 112 #define SET_FLOWCTL_CHAR_TYPE 0x25 113 114 #define GET_VERSION 0xc0 115 #define GET_VERSION_TYPE 0x26 116 117 #define SET_REGISTER 0x40 118 #define SET_REGISTER_TYPE 0x27 119 120 #define GET_REGISTER 0xc0 121 #define GET_REGISTER_TYPE 0x28 122 123 #define SET_RAM 0x40 124 #define SET_RAM_TYPE 0x31 125 126 #define GET_RAM 0xc0 127 #define GET_RAM_TYPE 0x32 128 129 /* how come ??? */ 130 #define UART_STATE 0x08 131 #define UART_STATE_TRANSIENT_MASK 0x75 132 #define UART_DCD 0x01 133 #define UART_DSR 0x02 134 #define UART_BREAK_ERROR 0x04 135 #define UART_RING 0x08 136 #define UART_FRAME_ERROR 0x10 137 #define UART_PARITY_ERROR 0x20 138 #define UART_OVERRUN_ERROR 0x40 139 #define UART_CTS 0x80 140 141 enum spcp8x5_type { 142 SPCP825_007_TYPE, 143 SPCP825_008_TYPE, 144 SPCP825_PHILIP_TYPE, 145 SPCP825_INTERMATIC_TYPE, 146 SPCP835_TYPE, 147 }; 148 149 struct spcp8x5_private { 150 spinlock_t lock; 151 enum spcp8x5_type type; 152 u8 line_control; 153 u8 line_status; 154 }; 155 156 static int spcp8x5_port_probe(struct usb_serial_port *port) 157 { 158 struct usb_serial *serial = port->serial; 159 struct spcp8x5_private *priv; 160 enum spcp8x5_type type = SPCP825_007_TYPE; 161 u16 product = le16_to_cpu(serial->dev->descriptor.idProduct); 162 163 if (product == 0x0201) 164 type = SPCP825_007_TYPE; 165 else if (product == 0x0231) 166 type = SPCP835_TYPE; 167 else if (product == 0x0235) 168 type = SPCP825_008_TYPE; 169 else if (product == 0x0204) 170 type = SPCP825_INTERMATIC_TYPE; 171 else if (product == 0x0471 && 172 serial->dev->descriptor.idVendor == cpu_to_le16(0x081e)) 173 type = SPCP825_PHILIP_TYPE; 174 dev_dbg(&serial->dev->dev, "device type = %d\n", (int)type); 175 176 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 177 if (!priv) 178 return -ENOMEM; 179 180 spin_lock_init(&priv->lock); 181 priv->type = type; 182 183 usb_set_serial_port_data(port , priv); 184 185 return 0; 186 } 187 188 static int spcp8x5_port_remove(struct usb_serial_port *port) 189 { 190 struct spcp8x5_private *priv; 191 192 priv = usb_get_serial_port_data(port); 193 kfree(priv); 194 195 return 0; 196 } 197 198 /* set the modem control line of the device. 199 * NOTE spcp825-007 not supported this */ 200 static int spcp8x5_set_ctrlLine(struct usb_device *dev, u8 value, 201 enum spcp8x5_type type) 202 { 203 int retval; 204 u8 mcr = 0 ; 205 206 if (type == SPCP825_007_TYPE) 207 return -EPERM; 208 209 mcr = (unsigned short)value; 210 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 211 SET_UART_STATUS_TYPE, SET_UART_STATUS, 212 mcr, 0x04, NULL, 0, 100); 213 if (retval != 0) 214 dev_dbg(&dev->dev, "usb_control_msg return %#x\n", retval); 215 return retval; 216 } 217 218 /* get the modem status register of the device 219 * NOTE spcp825-007 not supported this */ 220 static int spcp8x5_get_msr(struct usb_device *dev, u8 *status, 221 enum spcp8x5_type type) 222 { 223 u8 *status_buffer; 224 int ret; 225 226 /* I return Permited not support here but seem inval device 227 * is more fix */ 228 if (type == SPCP825_007_TYPE) 229 return -EPERM; 230 if (status == NULL) 231 return -EINVAL; 232 233 status_buffer = kmalloc(1, GFP_KERNEL); 234 if (!status_buffer) 235 return -ENOMEM; 236 status_buffer[0] = status[0]; 237 238 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 239 GET_UART_STATUS, GET_UART_STATUS_TYPE, 240 0, GET_UART_STATUS_MSR, status_buffer, 1, 100); 241 if (ret < 0) 242 dev_dbg(&dev->dev, "Get MSR = 0x%p failed (error = %d)", 243 status_buffer, ret); 244 245 dev_dbg(&dev->dev, "0xc0:0x22:0:6 %d - 0x%p ", ret, status_buffer); 246 status[0] = status_buffer[0]; 247 kfree(status_buffer); 248 249 return ret; 250 } 251 252 /* select the work mode. 253 * NOTE this function not supported by spcp825-007 */ 254 static void spcp8x5_set_workMode(struct usb_device *dev, u16 value, 255 u16 index, enum spcp8x5_type type) 256 { 257 int ret; 258 259 /* I return Permited not support here but seem inval device 260 * is more fix */ 261 if (type == SPCP825_007_TYPE) 262 return; 263 264 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 265 SET_WORKING_MODE_TYPE, SET_WORKING_MODE, 266 value, index, NULL, 0, 100); 267 dev_dbg(&dev->dev, "value = %#x , index = %#x\n", value, index); 268 if (ret < 0) 269 dev_dbg(&dev->dev, 270 "RTSCTS usb_control_msg(enable flowctrl) = %d\n", ret); 271 } 272 273 static int spcp8x5_carrier_raised(struct usb_serial_port *port) 274 { 275 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 276 if (priv->line_status & MSR_STATUS_LINE_DCD) 277 return 1; 278 return 0; 279 } 280 281 static void spcp8x5_dtr_rts(struct usb_serial_port *port, int on) 282 { 283 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 284 unsigned long flags; 285 u8 control; 286 287 spin_lock_irqsave(&priv->lock, flags); 288 if (on) 289 priv->line_control = MCR_CONTROL_LINE_DTR 290 | MCR_CONTROL_LINE_RTS; 291 else 292 priv->line_control &= ~ (MCR_CONTROL_LINE_DTR 293 | MCR_CONTROL_LINE_RTS); 294 control = priv->line_control; 295 spin_unlock_irqrestore(&priv->lock, flags); 296 spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type); 297 } 298 299 static void spcp8x5_init_termios(struct tty_struct *tty) 300 { 301 /* for the 1st time call this function */ 302 tty->termios = tty_std_termios; 303 tty->termios.c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL; 304 tty->termios.c_ispeed = 115200; 305 tty->termios.c_ospeed = 115200; 306 } 307 308 /* set the serial param for transfer. we should check if we really need to 309 * transfer. if we set flow control we should do this too. */ 310 static void spcp8x5_set_termios(struct tty_struct *tty, 311 struct usb_serial_port *port, struct ktermios *old_termios) 312 { 313 struct usb_serial *serial = port->serial; 314 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 315 unsigned long flags; 316 unsigned int cflag = tty->termios.c_cflag; 317 unsigned int old_cflag = old_termios->c_cflag; 318 unsigned short uartdata; 319 unsigned char buf[2] = {0, 0}; 320 int baud; 321 int i; 322 u8 control; 323 324 325 /* check that they really want us to change something */ 326 if (!tty_termios_hw_change(&tty->termios, old_termios)) 327 return; 328 329 /* set DTR/RTS active */ 330 spin_lock_irqsave(&priv->lock, flags); 331 control = priv->line_control; 332 if ((old_cflag & CBAUD) == B0) { 333 priv->line_control |= MCR_DTR; 334 if (!(old_cflag & CRTSCTS)) 335 priv->line_control |= MCR_RTS; 336 } 337 if (control != priv->line_control) { 338 control = priv->line_control; 339 spin_unlock_irqrestore(&priv->lock, flags); 340 spcp8x5_set_ctrlLine(serial->dev, control , priv->type); 341 } else { 342 spin_unlock_irqrestore(&priv->lock, flags); 343 } 344 345 /* Set Baud Rate */ 346 baud = tty_get_baud_rate(tty); 347 switch (baud) { 348 case 300: buf[0] = 0x00; break; 349 case 600: buf[0] = 0x01; break; 350 case 1200: buf[0] = 0x02; break; 351 case 2400: buf[0] = 0x03; break; 352 case 4800: buf[0] = 0x04; break; 353 case 9600: buf[0] = 0x05; break; 354 case 19200: buf[0] = 0x07; break; 355 case 38400: buf[0] = 0x09; break; 356 case 57600: buf[0] = 0x0a; break; 357 case 115200: buf[0] = 0x0b; break; 358 case 230400: buf[0] = 0x0c; break; 359 case 460800: buf[0] = 0x0d; break; 360 case 921600: buf[0] = 0x0e; break; 361 /* case 1200000: buf[0] = 0x0f; break; */ 362 /* case 2400000: buf[0] = 0x10; break; */ 363 case 3000000: buf[0] = 0x11; break; 364 /* case 6000000: buf[0] = 0x12; break; */ 365 case 0: 366 case 1000000: 367 buf[0] = 0x0b; break; 368 default: 369 dev_err(&port->dev, "spcp825 driver does not support the " 370 "baudrate requested, using default of 9600.\n"); 371 } 372 373 /* Set Data Length : 00:5bit, 01:6bit, 10:7bit, 11:8bit */ 374 if (cflag & CSIZE) { 375 switch (cflag & CSIZE) { 376 case CS5: 377 buf[1] |= SET_UART_FORMAT_SIZE_5; 378 break; 379 case CS6: 380 buf[1] |= SET_UART_FORMAT_SIZE_6; 381 break; 382 case CS7: 383 buf[1] |= SET_UART_FORMAT_SIZE_7; 384 break; 385 default: 386 case CS8: 387 buf[1] |= SET_UART_FORMAT_SIZE_8; 388 break; 389 } 390 } 391 392 /* Set Stop bit2 : 0:1bit 1:2bit */ 393 buf[1] |= (cflag & CSTOPB) ? SET_UART_FORMAT_STOP_2 : 394 SET_UART_FORMAT_STOP_1; 395 396 /* Set Parity bit3-4 01:Odd 11:Even */ 397 if (cflag & PARENB) { 398 buf[1] |= (cflag & PARODD) ? 399 SET_UART_FORMAT_PAR_ODD : SET_UART_FORMAT_PAR_EVEN ; 400 } else 401 buf[1] |= SET_UART_FORMAT_PAR_NONE; 402 403 uartdata = buf[0] | buf[1]<<8; 404 405 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 406 SET_UART_FORMAT_TYPE, SET_UART_FORMAT, 407 uartdata, 0, NULL, 0, 100); 408 if (i < 0) 409 dev_err(&port->dev, "Set UART format %#x failed (error = %d)\n", 410 uartdata, i); 411 dev_dbg(&port->dev, "0x21:0x40:0:0 %d\n", i); 412 413 if (cflag & CRTSCTS) { 414 /* enable hardware flow control */ 415 spcp8x5_set_workMode(serial->dev, 0x000a, 416 SET_WORKING_MODE_U2C, priv->type); 417 } 418 } 419 420 /* open the serial port. do some usb system call. set termios and get the line 421 * status of the device. */ 422 static int spcp8x5_open(struct tty_struct *tty, struct usb_serial_port *port) 423 { 424 struct ktermios tmp_termios; 425 struct usb_serial *serial = port->serial; 426 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 427 int ret; 428 unsigned long flags; 429 u8 status = 0x30; 430 /* status 0x30 means DSR and CTS = 1 other CDC RI and delta = 0 */ 431 432 usb_clear_halt(serial->dev, port->write_urb->pipe); 433 usb_clear_halt(serial->dev, port->read_urb->pipe); 434 435 ret = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 436 0x09, 0x00, 437 0x01, 0x00, NULL, 0x00, 100); 438 if (ret) 439 return ret; 440 441 spcp8x5_set_ctrlLine(serial->dev, priv->line_control , priv->type); 442 443 /* Setup termios */ 444 if (tty) 445 spcp8x5_set_termios(tty, port, &tmp_termios); 446 447 spcp8x5_get_msr(serial->dev, &status, priv->type); 448 449 /* may be we should update uart status here but now we did not do */ 450 spin_lock_irqsave(&priv->lock, flags); 451 priv->line_status = status & 0xf0 ; 452 spin_unlock_irqrestore(&priv->lock, flags); 453 454 port->port.drain_delay = 256; 455 456 return usb_serial_generic_open(tty, port); 457 } 458 459 static void spcp8x5_process_read_urb(struct urb *urb) 460 { 461 struct usb_serial_port *port = urb->context; 462 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 463 unsigned char *data = urb->transfer_buffer; 464 unsigned long flags; 465 u8 status; 466 char tty_flag; 467 468 /* get tty_flag from status */ 469 tty_flag = TTY_NORMAL; 470 471 spin_lock_irqsave(&priv->lock, flags); 472 status = priv->line_status; 473 priv->line_status &= ~UART_STATE_TRANSIENT_MASK; 474 spin_unlock_irqrestore(&priv->lock, flags); 475 /* wake up the wait for termios */ 476 wake_up_interruptible(&port->delta_msr_wait); 477 478 if (!urb->actual_length) 479 return; 480 481 482 if (status & UART_STATE_TRANSIENT_MASK) { 483 /* break takes precedence over parity, which takes precedence 484 * over framing errors */ 485 if (status & UART_BREAK_ERROR) 486 tty_flag = TTY_BREAK; 487 else if (status & UART_PARITY_ERROR) 488 tty_flag = TTY_PARITY; 489 else if (status & UART_FRAME_ERROR) 490 tty_flag = TTY_FRAME; 491 dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag); 492 493 /* overrun is special, not associated with a char */ 494 if (status & UART_OVERRUN_ERROR) 495 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN); 496 497 if (status & UART_DCD) { 498 struct tty_struct *tty = tty_port_tty_get(&port->port); 499 if (tty) { 500 usb_serial_handle_dcd_change(port, tty, 501 priv->line_status & MSR_STATUS_LINE_DCD); 502 tty_kref_put(tty); 503 } 504 } 505 } 506 507 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag, 508 urb->actual_length); 509 tty_flip_buffer_push(&port->port); 510 } 511 512 static int spcp8x5_wait_modem_info(struct usb_serial_port *port, 513 unsigned int arg) 514 { 515 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 516 unsigned long flags; 517 unsigned int prevstatus; 518 unsigned int status; 519 unsigned int changed; 520 521 spin_lock_irqsave(&priv->lock, flags); 522 prevstatus = priv->line_status; 523 spin_unlock_irqrestore(&priv->lock, flags); 524 525 while (1) { 526 /* wake up in bulk read */ 527 interruptible_sleep_on(&port->delta_msr_wait); 528 529 /* see if a signal did it */ 530 if (signal_pending(current)) 531 return -ERESTARTSYS; 532 533 if (port->serial->disconnected) 534 return -EIO; 535 536 spin_lock_irqsave(&priv->lock, flags); 537 status = priv->line_status; 538 spin_unlock_irqrestore(&priv->lock, flags); 539 540 changed = prevstatus^status; 541 542 if (((arg & TIOCM_RNG) && (changed & MSR_STATUS_LINE_RI)) || 543 ((arg & TIOCM_DSR) && (changed & MSR_STATUS_LINE_DSR)) || 544 ((arg & TIOCM_CD) && (changed & MSR_STATUS_LINE_DCD)) || 545 ((arg & TIOCM_CTS) && (changed & MSR_STATUS_LINE_CTS))) 546 return 0; 547 548 prevstatus = status; 549 } 550 /* NOTREACHED */ 551 return 0; 552 } 553 554 static int spcp8x5_ioctl(struct tty_struct *tty, 555 unsigned int cmd, unsigned long arg) 556 { 557 struct usb_serial_port *port = tty->driver_data; 558 559 dev_dbg(&port->dev, "%s (%d) cmd = 0x%04x\n", __func__, 560 port->number, cmd); 561 562 switch (cmd) { 563 case TIOCMIWAIT: 564 dev_dbg(&port->dev, "%s (%d) TIOCMIWAIT\n", __func__, 565 port->number); 566 return spcp8x5_wait_modem_info(port, arg); 567 568 default: 569 dev_dbg(&port->dev, "%s not supported = 0x%04x", __func__, 570 cmd); 571 break; 572 } 573 574 return -ENOIOCTLCMD; 575 } 576 577 static int spcp8x5_tiocmset(struct tty_struct *tty, 578 unsigned int set, unsigned int clear) 579 { 580 struct usb_serial_port *port = tty->driver_data; 581 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 582 unsigned long flags; 583 u8 control; 584 585 spin_lock_irqsave(&priv->lock, flags); 586 if (set & TIOCM_RTS) 587 priv->line_control |= MCR_RTS; 588 if (set & TIOCM_DTR) 589 priv->line_control |= MCR_DTR; 590 if (clear & TIOCM_RTS) 591 priv->line_control &= ~MCR_RTS; 592 if (clear & TIOCM_DTR) 593 priv->line_control &= ~MCR_DTR; 594 control = priv->line_control; 595 spin_unlock_irqrestore(&priv->lock, flags); 596 597 return spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type); 598 } 599 600 static int spcp8x5_tiocmget(struct tty_struct *tty) 601 { 602 struct usb_serial_port *port = tty->driver_data; 603 struct spcp8x5_private *priv = usb_get_serial_port_data(port); 604 unsigned long flags; 605 unsigned int mcr; 606 unsigned int status; 607 unsigned int result; 608 609 spin_lock_irqsave(&priv->lock, flags); 610 mcr = priv->line_control; 611 status = priv->line_status; 612 spin_unlock_irqrestore(&priv->lock, flags); 613 614 result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) 615 | ((mcr & MCR_RTS) ? TIOCM_RTS : 0) 616 | ((status & MSR_STATUS_LINE_CTS) ? TIOCM_CTS : 0) 617 | ((status & MSR_STATUS_LINE_DSR) ? TIOCM_DSR : 0) 618 | ((status & MSR_STATUS_LINE_RI) ? TIOCM_RI : 0) 619 | ((status & MSR_STATUS_LINE_DCD) ? TIOCM_CD : 0); 620 621 return result; 622 } 623 624 /* All of the device info needed for the spcp8x5 SIO serial converter */ 625 static struct usb_serial_driver spcp8x5_device = { 626 .driver = { 627 .owner = THIS_MODULE, 628 .name = "SPCP8x5", 629 }, 630 .id_table = id_table, 631 .num_ports = 1, 632 .open = spcp8x5_open, 633 .dtr_rts = spcp8x5_dtr_rts, 634 .carrier_raised = spcp8x5_carrier_raised, 635 .set_termios = spcp8x5_set_termios, 636 .init_termios = spcp8x5_init_termios, 637 .ioctl = spcp8x5_ioctl, 638 .tiocmget = spcp8x5_tiocmget, 639 .tiocmset = spcp8x5_tiocmset, 640 .port_probe = spcp8x5_port_probe, 641 .port_remove = spcp8x5_port_remove, 642 .process_read_urb = spcp8x5_process_read_urb, 643 }; 644 645 static struct usb_serial_driver * const serial_drivers[] = { 646 &spcp8x5_device, NULL 647 }; 648 649 module_usb_serial_driver(serial_drivers, id_table); 650 651 MODULE_DESCRIPTION(DRIVER_DESC); 652 MODULE_LICENSE("GPL"); 653