1 /* 2 * USB Cypress M8 driver 3 * 4 * Copyright (C) 2004 5 * Lonnie Mendez (dignome@gmail.com) 6 * Copyright (C) 2003,2004 7 * Neil Whelchel (koyama@firstlight.net) 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * See Documentation/usb/usb-serial.txt for more information on using this 15 * driver 16 * 17 * See http://geocities.com/i0xox0i for information on this driver and the 18 * earthmate usb device. 19 */ 20 21 /* Thanks to Neil Whelchel for writing the first cypress m8 implementation 22 for linux. */ 23 /* Thanks to cypress for providing references for the hid reports. */ 24 /* Thanks to Jiang Zhang for providing links and for general help. */ 25 /* Code originates and was built up from ftdi_sio, belkin, pl2303 and others.*/ 26 27 28 #include <linux/kernel.h> 29 #include <linux/errno.h> 30 #include <linux/init.h> 31 #include <linux/slab.h> 32 #include <linux/tty.h> 33 #include <linux/tty_driver.h> 34 #include <linux/tty_flip.h> 35 #include <linux/module.h> 36 #include <linux/moduleparam.h> 37 #include <linux/spinlock.h> 38 #include <linux/usb.h> 39 #include <linux/usb/serial.h> 40 #include <linux/serial.h> 41 #include <linux/kfifo.h> 42 #include <linux/delay.h> 43 #include <linux/uaccess.h> 44 #include <asm/unaligned.h> 45 46 #include "cypress_m8.h" 47 48 49 static bool debug; 50 static bool stats; 51 static int interval; 52 static bool unstable_bauds; 53 54 /* 55 * Version Information 56 */ 57 #define DRIVER_VERSION "v1.10" 58 #define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>" 59 #define DRIVER_DESC "Cypress USB to Serial Driver" 60 61 /* write buffer size defines */ 62 #define CYPRESS_BUF_SIZE 1024 63 64 static const struct usb_device_id id_table_earthmate[] = { 65 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) }, 66 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) }, 67 { } /* Terminating entry */ 68 }; 69 70 static const struct usb_device_id id_table_cyphidcomrs232[] = { 71 { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) }, 72 { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) }, 73 { } /* Terminating entry */ 74 }; 75 76 static const struct usb_device_id id_table_nokiaca42v2[] = { 77 { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) }, 78 { } /* Terminating entry */ 79 }; 80 81 static const struct usb_device_id id_table_combined[] = { 82 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) }, 83 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) }, 84 { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) }, 85 { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) }, 86 { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) }, 87 { } /* Terminating entry */ 88 }; 89 90 MODULE_DEVICE_TABLE(usb, id_table_combined); 91 92 enum packet_format { 93 packet_format_1, /* b0:status, b1:payload count */ 94 packet_format_2 /* b0[7:3]:status, b0[2:0]:payload count */ 95 }; 96 97 struct cypress_private { 98 spinlock_t lock; /* private lock */ 99 int chiptype; /* identifier of device, for quirks/etc */ 100 int bytes_in; /* used for statistics */ 101 int bytes_out; /* used for statistics */ 102 int cmd_count; /* used for statistics */ 103 int cmd_ctrl; /* always set this to 1 before issuing a command */ 104 struct kfifo write_fifo; /* write fifo */ 105 int write_urb_in_use; /* write urb in use indicator */ 106 int write_urb_interval; /* interval to use for write urb */ 107 int read_urb_interval; /* interval to use for read urb */ 108 int comm_is_ok; /* true if communication is (still) ok */ 109 int termios_initialized; 110 __u8 line_control; /* holds dtr / rts value */ 111 __u8 current_status; /* received from last read - info on dsr,cts,cd,ri,etc */ 112 __u8 current_config; /* stores the current configuration byte */ 113 __u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */ 114 enum packet_format pkt_fmt; /* format to use for packet send / receive */ 115 int get_cfg_unsafe; /* If true, the CYPRESS_GET_CONFIG is unsafe */ 116 int baud_rate; /* stores current baud rate in 117 integer form */ 118 int isthrottled; /* if throttled, discard reads */ 119 wait_queue_head_t delta_msr_wait; /* used for TIOCMIWAIT */ 120 char prev_status, diff_status; /* used for TIOCMIWAIT */ 121 /* we pass a pointer to this as the argument sent to 122 cypress_set_termios old_termios */ 123 struct ktermios tmp_termios; /* stores the old termios settings */ 124 }; 125 126 /* function prototypes for the Cypress USB to serial device */ 127 static int cypress_earthmate_startup(struct usb_serial *serial); 128 static int cypress_hidcom_startup(struct usb_serial *serial); 129 static int cypress_ca42v2_startup(struct usb_serial *serial); 130 static void cypress_release(struct usb_serial *serial); 131 static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port); 132 static void cypress_close(struct usb_serial_port *port); 133 static void cypress_dtr_rts(struct usb_serial_port *port, int on); 134 static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port, 135 const unsigned char *buf, int count); 136 static void cypress_send(struct usb_serial_port *port); 137 static int cypress_write_room(struct tty_struct *tty); 138 static int cypress_ioctl(struct tty_struct *tty, 139 unsigned int cmd, unsigned long arg); 140 static void cypress_set_termios(struct tty_struct *tty, 141 struct usb_serial_port *port, struct ktermios *old); 142 static int cypress_tiocmget(struct tty_struct *tty); 143 static int cypress_tiocmset(struct tty_struct *tty, 144 unsigned int set, unsigned int clear); 145 static int cypress_chars_in_buffer(struct tty_struct *tty); 146 static void cypress_throttle(struct tty_struct *tty); 147 static void cypress_unthrottle(struct tty_struct *tty); 148 static void cypress_set_dead(struct usb_serial_port *port); 149 static void cypress_read_int_callback(struct urb *urb); 150 static void cypress_write_int_callback(struct urb *urb); 151 152 static struct usb_serial_driver cypress_earthmate_device = { 153 .driver = { 154 .owner = THIS_MODULE, 155 .name = "earthmate", 156 }, 157 .description = "DeLorme Earthmate USB", 158 .id_table = id_table_earthmate, 159 .num_ports = 1, 160 .attach = cypress_earthmate_startup, 161 .release = cypress_release, 162 .open = cypress_open, 163 .close = cypress_close, 164 .dtr_rts = cypress_dtr_rts, 165 .write = cypress_write, 166 .write_room = cypress_write_room, 167 .ioctl = cypress_ioctl, 168 .set_termios = cypress_set_termios, 169 .tiocmget = cypress_tiocmget, 170 .tiocmset = cypress_tiocmset, 171 .chars_in_buffer = cypress_chars_in_buffer, 172 .throttle = cypress_throttle, 173 .unthrottle = cypress_unthrottle, 174 .read_int_callback = cypress_read_int_callback, 175 .write_int_callback = cypress_write_int_callback, 176 }; 177 178 static struct usb_serial_driver cypress_hidcom_device = { 179 .driver = { 180 .owner = THIS_MODULE, 181 .name = "cyphidcom", 182 }, 183 .description = "HID->COM RS232 Adapter", 184 .id_table = id_table_cyphidcomrs232, 185 .num_ports = 1, 186 .attach = cypress_hidcom_startup, 187 .release = cypress_release, 188 .open = cypress_open, 189 .close = cypress_close, 190 .dtr_rts = cypress_dtr_rts, 191 .write = cypress_write, 192 .write_room = cypress_write_room, 193 .ioctl = cypress_ioctl, 194 .set_termios = cypress_set_termios, 195 .tiocmget = cypress_tiocmget, 196 .tiocmset = cypress_tiocmset, 197 .chars_in_buffer = cypress_chars_in_buffer, 198 .throttle = cypress_throttle, 199 .unthrottle = cypress_unthrottle, 200 .read_int_callback = cypress_read_int_callback, 201 .write_int_callback = cypress_write_int_callback, 202 }; 203 204 static struct usb_serial_driver cypress_ca42v2_device = { 205 .driver = { 206 .owner = THIS_MODULE, 207 .name = "nokiaca42v2", 208 }, 209 .description = "Nokia CA-42 V2 Adapter", 210 .id_table = id_table_nokiaca42v2, 211 .num_ports = 1, 212 .attach = cypress_ca42v2_startup, 213 .release = cypress_release, 214 .open = cypress_open, 215 .close = cypress_close, 216 .dtr_rts = cypress_dtr_rts, 217 .write = cypress_write, 218 .write_room = cypress_write_room, 219 .ioctl = cypress_ioctl, 220 .set_termios = cypress_set_termios, 221 .tiocmget = cypress_tiocmget, 222 .tiocmset = cypress_tiocmset, 223 .chars_in_buffer = cypress_chars_in_buffer, 224 .throttle = cypress_throttle, 225 .unthrottle = cypress_unthrottle, 226 .read_int_callback = cypress_read_int_callback, 227 .write_int_callback = cypress_write_int_callback, 228 }; 229 230 static struct usb_serial_driver * const serial_drivers[] = { 231 &cypress_earthmate_device, &cypress_hidcom_device, 232 &cypress_ca42v2_device, NULL 233 }; 234 235 /***************************************************************************** 236 * Cypress serial helper functions 237 *****************************************************************************/ 238 239 240 static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate) 241 { 242 struct cypress_private *priv; 243 priv = usb_get_serial_port_data(port); 244 245 if (unstable_bauds) 246 return new_rate; 247 248 /* 249 * The general purpose firmware for the Cypress M8 allows for 250 * a maximum speed of 57600bps (I have no idea whether DeLorme 251 * chose to use the general purpose firmware or not), if you 252 * need to modify this speed setting for your own project 253 * please add your own chiptype and modify the code likewise. 254 * The Cypress HID->COM device will work successfully up to 255 * 115200bps (but the actual throughput is around 3kBps). 256 */ 257 if (port->serial->dev->speed == USB_SPEED_LOW) { 258 /* 259 * Mike Isely <isely@pobox.com> 2-Feb-2008: The 260 * Cypress app note that describes this mechanism 261 * states the the low-speed part can't handle more 262 * than 800 bytes/sec, in which case 4800 baud is the 263 * safest speed for a part like that. 264 */ 265 if (new_rate > 4800) { 266 dbg("%s - failed setting baud rate, device incapable " 267 "speed %d", __func__, new_rate); 268 return -1; 269 } 270 } 271 switch (priv->chiptype) { 272 case CT_EARTHMATE: 273 if (new_rate <= 600) { 274 /* 300 and 600 baud rates are supported under 275 * the generic firmware, but are not used with 276 * NMEA and SiRF protocols */ 277 dbg("%s - failed setting baud rate, unsupported speed " 278 "of %d on Earthmate GPS", __func__, new_rate); 279 return -1; 280 } 281 break; 282 default: 283 break; 284 } 285 return new_rate; 286 } 287 288 289 /* This function can either set or retrieve the current serial line settings */ 290 static int cypress_serial_control(struct tty_struct *tty, 291 struct usb_serial_port *port, speed_t baud_rate, int data_bits, 292 int stop_bits, int parity_enable, int parity_type, int reset, 293 int cypress_request_type) 294 { 295 int new_baudrate = 0, retval = 0, tries = 0; 296 struct cypress_private *priv; 297 u8 *feature_buffer; 298 const unsigned int feature_len = 5; 299 unsigned long flags; 300 301 priv = usb_get_serial_port_data(port); 302 303 if (!priv->comm_is_ok) 304 return -ENODEV; 305 306 feature_buffer = kcalloc(feature_len, sizeof(u8), GFP_KERNEL); 307 if (!feature_buffer) 308 return -ENOMEM; 309 310 switch (cypress_request_type) { 311 case CYPRESS_SET_CONFIG: 312 /* 0 means 'Hang up' so doesn't change the true bit rate */ 313 new_baudrate = priv->baud_rate; 314 if (baud_rate && baud_rate != priv->baud_rate) { 315 dbg("%s - baud rate is changing", __func__); 316 retval = analyze_baud_rate(port, baud_rate); 317 if (retval >= 0) { 318 new_baudrate = retval; 319 dbg("%s - New baud rate set to %d", 320 __func__, new_baudrate); 321 } 322 } 323 dbg("%s - baud rate is being sent as %d", 324 __func__, new_baudrate); 325 326 /* fill the feature_buffer with new configuration */ 327 put_unaligned_le32(new_baudrate, feature_buffer); 328 feature_buffer[4] |= data_bits; /* assign data bits in 2 bit space ( max 3 ) */ 329 /* 1 bit gap */ 330 feature_buffer[4] |= (stop_bits << 3); /* assign stop bits in 1 bit space */ 331 feature_buffer[4] |= (parity_enable << 4); /* assign parity flag in 1 bit space */ 332 feature_buffer[4] |= (parity_type << 5); /* assign parity type in 1 bit space */ 333 /* 1 bit gap */ 334 feature_buffer[4] |= (reset << 7); /* assign reset at end of byte, 1 bit space */ 335 336 dbg("%s - device is being sent this feature report:", 337 __func__); 338 dbg("%s - %02X - %02X - %02X - %02X - %02X", __func__, 339 feature_buffer[0], feature_buffer[1], 340 feature_buffer[2], feature_buffer[3], 341 feature_buffer[4]); 342 343 do { 344 retval = usb_control_msg(port->serial->dev, 345 usb_sndctrlpipe(port->serial->dev, 0), 346 HID_REQ_SET_REPORT, 347 USB_DIR_OUT | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 348 0x0300, 0, feature_buffer, 349 feature_len, 500); 350 351 if (tries++ >= 3) 352 break; 353 354 } while (retval != feature_len && 355 retval != -ENODEV); 356 357 if (retval != feature_len) { 358 dev_err(&port->dev, "%s - failed sending serial " 359 "line settings - %d\n", __func__, retval); 360 cypress_set_dead(port); 361 } else { 362 spin_lock_irqsave(&priv->lock, flags); 363 priv->baud_rate = new_baudrate; 364 priv->current_config = feature_buffer[4]; 365 spin_unlock_irqrestore(&priv->lock, flags); 366 /* If we asked for a speed change encode it */ 367 if (baud_rate) 368 tty_encode_baud_rate(tty, 369 new_baudrate, new_baudrate); 370 } 371 break; 372 case CYPRESS_GET_CONFIG: 373 if (priv->get_cfg_unsafe) { 374 /* Not implemented for this device, 375 and if we try to do it we're likely 376 to crash the hardware. */ 377 retval = -ENOTTY; 378 goto out; 379 } 380 dbg("%s - retreiving serial line settings", __func__); 381 do { 382 retval = usb_control_msg(port->serial->dev, 383 usb_rcvctrlpipe(port->serial->dev, 0), 384 HID_REQ_GET_REPORT, 385 USB_DIR_IN | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 386 0x0300, 0, feature_buffer, 387 feature_len, 500); 388 389 if (tries++ >= 3) 390 break; 391 } while (retval != feature_len 392 && retval != -ENODEV); 393 394 if (retval != feature_len) { 395 dev_err(&port->dev, "%s - failed to retrieve serial " 396 "line settings - %d\n", __func__, retval); 397 cypress_set_dead(port); 398 goto out; 399 } else { 400 spin_lock_irqsave(&priv->lock, flags); 401 /* store the config in one byte, and later 402 use bit masks to check values */ 403 priv->current_config = feature_buffer[4]; 404 priv->baud_rate = get_unaligned_le32(feature_buffer); 405 spin_unlock_irqrestore(&priv->lock, flags); 406 } 407 } 408 spin_lock_irqsave(&priv->lock, flags); 409 ++priv->cmd_count; 410 spin_unlock_irqrestore(&priv->lock, flags); 411 out: 412 kfree(feature_buffer); 413 return retval; 414 } /* cypress_serial_control */ 415 416 417 static void cypress_set_dead(struct usb_serial_port *port) 418 { 419 struct cypress_private *priv = usb_get_serial_port_data(port); 420 unsigned long flags; 421 422 spin_lock_irqsave(&priv->lock, flags); 423 if (!priv->comm_is_ok) { 424 spin_unlock_irqrestore(&priv->lock, flags); 425 return; 426 } 427 priv->comm_is_ok = 0; 428 spin_unlock_irqrestore(&priv->lock, flags); 429 430 dev_err(&port->dev, "cypress_m8 suspending failing port %d - " 431 "interval might be too short\n", port->number); 432 } 433 434 435 /***************************************************************************** 436 * Cypress serial driver functions 437 *****************************************************************************/ 438 439 440 static int generic_startup(struct usb_serial *serial) 441 { 442 struct cypress_private *priv; 443 struct usb_serial_port *port = serial->port[0]; 444 445 priv = kzalloc(sizeof(struct cypress_private), GFP_KERNEL); 446 if (!priv) 447 return -ENOMEM; 448 449 priv->comm_is_ok = !0; 450 spin_lock_init(&priv->lock); 451 if (kfifo_alloc(&priv->write_fifo, CYPRESS_BUF_SIZE, GFP_KERNEL)) { 452 kfree(priv); 453 return -ENOMEM; 454 } 455 init_waitqueue_head(&priv->delta_msr_wait); 456 457 usb_reset_configuration(serial->dev); 458 459 priv->cmd_ctrl = 0; 460 priv->line_control = 0; 461 priv->termios_initialized = 0; 462 priv->rx_flags = 0; 463 /* Default packet format setting is determined by packet size. 464 Anything with a size larger then 9 must have a separate 465 count field since the 3 bit count field is otherwise too 466 small. Otherwise we can use the slightly more compact 467 format. This is in accordance with the cypress_m8 serial 468 converter app note. */ 469 if (port->interrupt_out_size > 9) 470 priv->pkt_fmt = packet_format_1; 471 else 472 priv->pkt_fmt = packet_format_2; 473 474 if (interval > 0) { 475 priv->write_urb_interval = interval; 476 priv->read_urb_interval = interval; 477 dbg("%s - port %d read & write intervals forced to %d", 478 __func__, port->number, interval); 479 } else { 480 priv->write_urb_interval = port->interrupt_out_urb->interval; 481 priv->read_urb_interval = port->interrupt_in_urb->interval; 482 dbg("%s - port %d intervals: read=%d write=%d", 483 __func__, port->number, 484 priv->read_urb_interval, priv->write_urb_interval); 485 } 486 usb_set_serial_port_data(port, priv); 487 488 return 0; 489 } 490 491 492 static int cypress_earthmate_startup(struct usb_serial *serial) 493 { 494 struct cypress_private *priv; 495 struct usb_serial_port *port = serial->port[0]; 496 497 if (generic_startup(serial)) { 498 dbg("%s - Failed setting up port %d", __func__, 499 port->number); 500 return 1; 501 } 502 503 priv = usb_get_serial_port_data(port); 504 priv->chiptype = CT_EARTHMATE; 505 /* All Earthmate devices use the separated-count packet 506 format! Idiotic. */ 507 priv->pkt_fmt = packet_format_1; 508 if (serial->dev->descriptor.idProduct != 509 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB)) { 510 /* The old original USB Earthmate seemed able to 511 handle GET_CONFIG requests; everything they've 512 produced since that time crashes if this command is 513 attempted :-( */ 514 dbg("%s - Marking this device as unsafe for GET_CONFIG " 515 "commands", __func__); 516 priv->get_cfg_unsafe = !0; 517 } 518 519 return 0; 520 } /* cypress_earthmate_startup */ 521 522 523 static int cypress_hidcom_startup(struct usb_serial *serial) 524 { 525 struct cypress_private *priv; 526 527 if (generic_startup(serial)) { 528 dbg("%s - Failed setting up port %d", __func__, 529 serial->port[0]->number); 530 return 1; 531 } 532 533 priv = usb_get_serial_port_data(serial->port[0]); 534 priv->chiptype = CT_CYPHIDCOM; 535 536 return 0; 537 } /* cypress_hidcom_startup */ 538 539 540 static int cypress_ca42v2_startup(struct usb_serial *serial) 541 { 542 struct cypress_private *priv; 543 544 if (generic_startup(serial)) { 545 dbg("%s - Failed setting up port %d", __func__, 546 serial->port[0]->number); 547 return 1; 548 } 549 550 priv = usb_get_serial_port_data(serial->port[0]); 551 priv->chiptype = CT_CA42V2; 552 553 return 0; 554 } /* cypress_ca42v2_startup */ 555 556 557 static void cypress_release(struct usb_serial *serial) 558 { 559 struct cypress_private *priv; 560 561 /* all open ports are closed at this point */ 562 priv = usb_get_serial_port_data(serial->port[0]); 563 564 if (priv) { 565 kfifo_free(&priv->write_fifo); 566 kfree(priv); 567 } 568 } 569 570 571 static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port) 572 { 573 struct cypress_private *priv = usb_get_serial_port_data(port); 574 struct usb_serial *serial = port->serial; 575 unsigned long flags; 576 int result = 0; 577 578 if (!priv->comm_is_ok) 579 return -EIO; 580 581 /* clear halts before open */ 582 usb_clear_halt(serial->dev, 0x81); 583 usb_clear_halt(serial->dev, 0x02); 584 585 spin_lock_irqsave(&priv->lock, flags); 586 /* reset read/write statistics */ 587 priv->bytes_in = 0; 588 priv->bytes_out = 0; 589 priv->cmd_count = 0; 590 priv->rx_flags = 0; 591 spin_unlock_irqrestore(&priv->lock, flags); 592 593 /* Set termios */ 594 cypress_send(port); 595 596 if (tty) 597 cypress_set_termios(tty, port, &priv->tmp_termios); 598 599 /* setup the port and start reading from the device */ 600 if (!port->interrupt_in_urb) { 601 dev_err(&port->dev, "%s - interrupt_in_urb is empty!\n", 602 __func__); 603 return -1; 604 } 605 606 usb_fill_int_urb(port->interrupt_in_urb, serial->dev, 607 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress), 608 port->interrupt_in_urb->transfer_buffer, 609 port->interrupt_in_urb->transfer_buffer_length, 610 cypress_read_int_callback, port, priv->read_urb_interval); 611 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 612 613 if (result) { 614 dev_err(&port->dev, 615 "%s - failed submitting read urb, error %d\n", 616 __func__, result); 617 cypress_set_dead(port); 618 } 619 port->port.drain_delay = 256; 620 return result; 621 } /* cypress_open */ 622 623 static void cypress_dtr_rts(struct usb_serial_port *port, int on) 624 { 625 struct cypress_private *priv = usb_get_serial_port_data(port); 626 /* drop dtr and rts */ 627 spin_lock_irq(&priv->lock); 628 if (on == 0) 629 priv->line_control = 0; 630 else 631 priv->line_control = CONTROL_DTR | CONTROL_RTS; 632 priv->cmd_ctrl = 1; 633 spin_unlock_irq(&priv->lock); 634 cypress_write(NULL, port, NULL, 0); 635 } 636 637 static void cypress_close(struct usb_serial_port *port) 638 { 639 struct cypress_private *priv = usb_get_serial_port_data(port); 640 unsigned long flags; 641 642 /* writing is potentially harmful, lock must be taken */ 643 mutex_lock(&port->serial->disc_mutex); 644 if (port->serial->disconnected) { 645 mutex_unlock(&port->serial->disc_mutex); 646 return; 647 } 648 spin_lock_irqsave(&priv->lock, flags); 649 kfifo_reset_out(&priv->write_fifo); 650 spin_unlock_irqrestore(&priv->lock, flags); 651 652 dbg("%s - stopping urbs", __func__); 653 usb_kill_urb(port->interrupt_in_urb); 654 usb_kill_urb(port->interrupt_out_urb); 655 656 if (stats) 657 dev_info(&port->dev, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n", 658 priv->bytes_in, priv->bytes_out, priv->cmd_count); 659 mutex_unlock(&port->serial->disc_mutex); 660 } /* cypress_close */ 661 662 663 static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port, 664 const unsigned char *buf, int count) 665 { 666 struct cypress_private *priv = usb_get_serial_port_data(port); 667 668 dbg("%s - port %d, %d bytes", __func__, port->number, count); 669 670 /* line control commands, which need to be executed immediately, 671 are not put into the buffer for obvious reasons. 672 */ 673 if (priv->cmd_ctrl) { 674 count = 0; 675 goto finish; 676 } 677 678 if (!count) 679 return count; 680 681 count = kfifo_in_locked(&priv->write_fifo, buf, count, &priv->lock); 682 683 finish: 684 cypress_send(port); 685 686 return count; 687 } /* cypress_write */ 688 689 690 static void cypress_send(struct usb_serial_port *port) 691 { 692 int count = 0, result, offset, actual_size; 693 struct cypress_private *priv = usb_get_serial_port_data(port); 694 unsigned long flags; 695 696 if (!priv->comm_is_ok) 697 return; 698 699 dbg("%s - interrupt out size is %d", __func__, 700 port->interrupt_out_size); 701 702 spin_lock_irqsave(&priv->lock, flags); 703 if (priv->write_urb_in_use) { 704 dbg("%s - can't write, urb in use", __func__); 705 spin_unlock_irqrestore(&priv->lock, flags); 706 return; 707 } 708 spin_unlock_irqrestore(&priv->lock, flags); 709 710 /* clear buffer */ 711 memset(port->interrupt_out_urb->transfer_buffer, 0, 712 port->interrupt_out_size); 713 714 spin_lock_irqsave(&priv->lock, flags); 715 switch (priv->pkt_fmt) { 716 default: 717 case packet_format_1: 718 /* this is for the CY7C64013... */ 719 offset = 2; 720 port->interrupt_out_buffer[0] = priv->line_control; 721 break; 722 case packet_format_2: 723 /* this is for the CY7C63743... */ 724 offset = 1; 725 port->interrupt_out_buffer[0] = priv->line_control; 726 break; 727 } 728 729 if (priv->line_control & CONTROL_RESET) 730 priv->line_control &= ~CONTROL_RESET; 731 732 if (priv->cmd_ctrl) { 733 priv->cmd_count++; 734 dbg("%s - line control command being issued", __func__); 735 spin_unlock_irqrestore(&priv->lock, flags); 736 goto send; 737 } else 738 spin_unlock_irqrestore(&priv->lock, flags); 739 740 count = kfifo_out_locked(&priv->write_fifo, 741 &port->interrupt_out_buffer[offset], 742 port->interrupt_out_size - offset, 743 &priv->lock); 744 if (count == 0) 745 return; 746 747 switch (priv->pkt_fmt) { 748 default: 749 case packet_format_1: 750 port->interrupt_out_buffer[1] = count; 751 break; 752 case packet_format_2: 753 port->interrupt_out_buffer[0] |= count; 754 } 755 756 dbg("%s - count is %d", __func__, count); 757 758 send: 759 spin_lock_irqsave(&priv->lock, flags); 760 priv->write_urb_in_use = 1; 761 spin_unlock_irqrestore(&priv->lock, flags); 762 763 if (priv->cmd_ctrl) 764 actual_size = 1; 765 else 766 actual_size = count + 767 (priv->pkt_fmt == packet_format_1 ? 2 : 1); 768 769 usb_serial_debug_data(debug, &port->dev, __func__, 770 port->interrupt_out_size, 771 port->interrupt_out_urb->transfer_buffer); 772 773 usb_fill_int_urb(port->interrupt_out_urb, port->serial->dev, 774 usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress), 775 port->interrupt_out_buffer, port->interrupt_out_size, 776 cypress_write_int_callback, port, priv->write_urb_interval); 777 result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC); 778 if (result) { 779 dev_err_console(port, 780 "%s - failed submitting write urb, error %d\n", 781 __func__, result); 782 priv->write_urb_in_use = 0; 783 cypress_set_dead(port); 784 } 785 786 spin_lock_irqsave(&priv->lock, flags); 787 if (priv->cmd_ctrl) 788 priv->cmd_ctrl = 0; 789 790 /* do not count the line control and size bytes */ 791 priv->bytes_out += count; 792 spin_unlock_irqrestore(&priv->lock, flags); 793 794 usb_serial_port_softint(port); 795 } /* cypress_send */ 796 797 798 /* returns how much space is available in the soft buffer */ 799 static int cypress_write_room(struct tty_struct *tty) 800 { 801 struct usb_serial_port *port = tty->driver_data; 802 struct cypress_private *priv = usb_get_serial_port_data(port); 803 int room = 0; 804 unsigned long flags; 805 806 spin_lock_irqsave(&priv->lock, flags); 807 room = kfifo_avail(&priv->write_fifo); 808 spin_unlock_irqrestore(&priv->lock, flags); 809 810 dbg("%s - returns %d", __func__, room); 811 return room; 812 } 813 814 815 static int cypress_tiocmget(struct tty_struct *tty) 816 { 817 struct usb_serial_port *port = tty->driver_data; 818 struct cypress_private *priv = usb_get_serial_port_data(port); 819 __u8 status, control; 820 unsigned int result = 0; 821 unsigned long flags; 822 823 spin_lock_irqsave(&priv->lock, flags); 824 control = priv->line_control; 825 status = priv->current_status; 826 spin_unlock_irqrestore(&priv->lock, flags); 827 828 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0) 829 | ((control & CONTROL_RTS) ? TIOCM_RTS : 0) 830 | ((status & UART_CTS) ? TIOCM_CTS : 0) 831 | ((status & UART_DSR) ? TIOCM_DSR : 0) 832 | ((status & UART_RI) ? TIOCM_RI : 0) 833 | ((status & UART_CD) ? TIOCM_CD : 0); 834 835 dbg("%s - result = %x", __func__, result); 836 837 return result; 838 } 839 840 841 static int cypress_tiocmset(struct tty_struct *tty, 842 unsigned int set, unsigned int clear) 843 { 844 struct usb_serial_port *port = tty->driver_data; 845 struct cypress_private *priv = usb_get_serial_port_data(port); 846 unsigned long flags; 847 848 spin_lock_irqsave(&priv->lock, flags); 849 if (set & TIOCM_RTS) 850 priv->line_control |= CONTROL_RTS; 851 if (set & TIOCM_DTR) 852 priv->line_control |= CONTROL_DTR; 853 if (clear & TIOCM_RTS) 854 priv->line_control &= ~CONTROL_RTS; 855 if (clear & TIOCM_DTR) 856 priv->line_control &= ~CONTROL_DTR; 857 priv->cmd_ctrl = 1; 858 spin_unlock_irqrestore(&priv->lock, flags); 859 860 return cypress_write(tty, port, NULL, 0); 861 } 862 863 864 static int cypress_ioctl(struct tty_struct *tty, 865 unsigned int cmd, unsigned long arg) 866 { 867 struct usb_serial_port *port = tty->driver_data; 868 struct cypress_private *priv = usb_get_serial_port_data(port); 869 870 dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd); 871 872 switch (cmd) { 873 /* This code comes from drivers/char/serial.c and ftdi_sio.c */ 874 case TIOCMIWAIT: 875 while (priv != NULL) { 876 interruptible_sleep_on(&priv->delta_msr_wait); 877 /* see if a signal did it */ 878 if (signal_pending(current)) 879 return -ERESTARTSYS; 880 else { 881 char diff = priv->diff_status; 882 if (diff == 0) 883 return -EIO; /* no change => error */ 884 885 /* consume all events */ 886 priv->diff_status = 0; 887 888 /* return 0 if caller wanted to know about 889 these bits */ 890 if (((arg & TIOCM_RNG) && (diff & UART_RI)) || 891 ((arg & TIOCM_DSR) && (diff & UART_DSR)) || 892 ((arg & TIOCM_CD) && (diff & UART_CD)) || 893 ((arg & TIOCM_CTS) && (diff & UART_CTS))) 894 return 0; 895 /* otherwise caller can't care less about what 896 * happened, and so we continue to wait for 897 * more events. 898 */ 899 } 900 } 901 return 0; 902 default: 903 break; 904 } 905 dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__, cmd); 906 return -ENOIOCTLCMD; 907 } /* cypress_ioctl */ 908 909 910 static void cypress_set_termios(struct tty_struct *tty, 911 struct usb_serial_port *port, struct ktermios *old_termios) 912 { 913 struct cypress_private *priv = usb_get_serial_port_data(port); 914 int data_bits, stop_bits, parity_type, parity_enable; 915 unsigned cflag, iflag; 916 unsigned long flags; 917 __u8 oldlines; 918 int linechange = 0; 919 920 spin_lock_irqsave(&priv->lock, flags); 921 /* We can't clean this one up as we don't know the device type 922 early enough */ 923 if (!priv->termios_initialized) { 924 if (priv->chiptype == CT_EARTHMATE) { 925 *(tty->termios) = tty_std_termios; 926 tty->termios->c_cflag = B4800 | CS8 | CREAD | HUPCL | 927 CLOCAL; 928 tty->termios->c_ispeed = 4800; 929 tty->termios->c_ospeed = 4800; 930 } else if (priv->chiptype == CT_CYPHIDCOM) { 931 *(tty->termios) = tty_std_termios; 932 tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL | 933 CLOCAL; 934 tty->termios->c_ispeed = 9600; 935 tty->termios->c_ospeed = 9600; 936 } else if (priv->chiptype == CT_CA42V2) { 937 *(tty->termios) = tty_std_termios; 938 tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL | 939 CLOCAL; 940 tty->termios->c_ispeed = 9600; 941 tty->termios->c_ospeed = 9600; 942 } 943 priv->termios_initialized = 1; 944 } 945 spin_unlock_irqrestore(&priv->lock, flags); 946 947 /* Unsupported features need clearing */ 948 tty->termios->c_cflag &= ~(CMSPAR|CRTSCTS); 949 950 cflag = tty->termios->c_cflag; 951 iflag = tty->termios->c_iflag; 952 953 /* check if there are new settings */ 954 if (old_termios) { 955 spin_lock_irqsave(&priv->lock, flags); 956 priv->tmp_termios = *(tty->termios); 957 spin_unlock_irqrestore(&priv->lock, flags); 958 } 959 960 /* set number of data bits, parity, stop bits */ 961 /* when parity is disabled the parity type bit is ignored */ 962 963 /* 1 means 2 stop bits, 0 means 1 stop bit */ 964 stop_bits = cflag & CSTOPB ? 1 : 0; 965 966 if (cflag & PARENB) { 967 parity_enable = 1; 968 /* 1 means odd parity, 0 means even parity */ 969 parity_type = cflag & PARODD ? 1 : 0; 970 } else 971 parity_enable = parity_type = 0; 972 973 switch (cflag & CSIZE) { 974 case CS5: 975 data_bits = 0; 976 break; 977 case CS6: 978 data_bits = 1; 979 break; 980 case CS7: 981 data_bits = 2; 982 break; 983 case CS8: 984 data_bits = 3; 985 break; 986 default: 987 dev_err(&port->dev, "%s - CSIZE was set, but not CS5-CS8\n", 988 __func__); 989 data_bits = 3; 990 } 991 spin_lock_irqsave(&priv->lock, flags); 992 oldlines = priv->line_control; 993 if ((cflag & CBAUD) == B0) { 994 /* drop dtr and rts */ 995 dbg("%s - dropping the lines, baud rate 0bps", __func__); 996 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 997 } else 998 priv->line_control = (CONTROL_DTR | CONTROL_RTS); 999 spin_unlock_irqrestore(&priv->lock, flags); 1000 1001 dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, " 1002 "%d data_bits (+5)", __func__, stop_bits, 1003 parity_enable, parity_type, data_bits); 1004 1005 cypress_serial_control(tty, port, tty_get_baud_rate(tty), 1006 data_bits, stop_bits, 1007 parity_enable, parity_type, 1008 0, CYPRESS_SET_CONFIG); 1009 1010 /* we perform a CYPRESS_GET_CONFIG so that the current settings are 1011 * filled into the private structure this should confirm that all is 1012 * working if it returns what we just set */ 1013 cypress_serial_control(tty, port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG); 1014 1015 /* Here we can define custom tty settings for devices; the main tty 1016 * termios flag base comes from empeg.c */ 1017 1018 spin_lock_irqsave(&priv->lock, flags); 1019 if (priv->chiptype == CT_EARTHMATE && priv->baud_rate == 4800) { 1020 dbg("Using custom termios settings for a baud rate of " 1021 "4800bps."); 1022 /* define custom termios settings for NMEA protocol */ 1023 1024 tty->termios->c_iflag /* input modes - */ 1025 &= ~(IGNBRK /* disable ignore break */ 1026 | BRKINT /* disable break causes interrupt */ 1027 | PARMRK /* disable mark parity errors */ 1028 | ISTRIP /* disable clear high bit of input char */ 1029 | INLCR /* disable translate NL to CR */ 1030 | IGNCR /* disable ignore CR */ 1031 | ICRNL /* disable translate CR to NL */ 1032 | IXON); /* disable enable XON/XOFF flow control */ 1033 1034 tty->termios->c_oflag /* output modes */ 1035 &= ~OPOST; /* disable postprocess output char */ 1036 1037 tty->termios->c_lflag /* line discipline modes */ 1038 &= ~(ECHO /* disable echo input characters */ 1039 | ECHONL /* disable echo new line */ 1040 | ICANON /* disable erase, kill, werase, and rprnt 1041 special characters */ 1042 | ISIG /* disable interrupt, quit, and suspend 1043 special characters */ 1044 | IEXTEN); /* disable non-POSIX special characters */ 1045 } /* CT_CYPHIDCOM: Application should handle this for device */ 1046 1047 linechange = (priv->line_control != oldlines); 1048 spin_unlock_irqrestore(&priv->lock, flags); 1049 1050 /* if necessary, set lines */ 1051 if (linechange) { 1052 priv->cmd_ctrl = 1; 1053 cypress_write(tty, port, NULL, 0); 1054 } 1055 } /* cypress_set_termios */ 1056 1057 1058 /* returns amount of data still left in soft buffer */ 1059 static int cypress_chars_in_buffer(struct tty_struct *tty) 1060 { 1061 struct usb_serial_port *port = tty->driver_data; 1062 struct cypress_private *priv = usb_get_serial_port_data(port); 1063 int chars = 0; 1064 unsigned long flags; 1065 1066 spin_lock_irqsave(&priv->lock, flags); 1067 chars = kfifo_len(&priv->write_fifo); 1068 spin_unlock_irqrestore(&priv->lock, flags); 1069 1070 dbg("%s - returns %d", __func__, chars); 1071 return chars; 1072 } 1073 1074 1075 static void cypress_throttle(struct tty_struct *tty) 1076 { 1077 struct usb_serial_port *port = tty->driver_data; 1078 struct cypress_private *priv = usb_get_serial_port_data(port); 1079 1080 spin_lock_irq(&priv->lock); 1081 priv->rx_flags = THROTTLED; 1082 spin_unlock_irq(&priv->lock); 1083 } 1084 1085 1086 static void cypress_unthrottle(struct tty_struct *tty) 1087 { 1088 struct usb_serial_port *port = tty->driver_data; 1089 struct cypress_private *priv = usb_get_serial_port_data(port); 1090 int actually_throttled, result; 1091 1092 spin_lock_irq(&priv->lock); 1093 actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED; 1094 priv->rx_flags = 0; 1095 spin_unlock_irq(&priv->lock); 1096 1097 if (!priv->comm_is_ok) 1098 return; 1099 1100 if (actually_throttled) { 1101 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 1102 if (result) { 1103 dev_err(&port->dev, "%s - failed submitting read urb, " 1104 "error %d\n", __func__, result); 1105 cypress_set_dead(port); 1106 } 1107 } 1108 } 1109 1110 1111 static void cypress_read_int_callback(struct urb *urb) 1112 { 1113 struct usb_serial_port *port = urb->context; 1114 struct cypress_private *priv = usb_get_serial_port_data(port); 1115 struct tty_struct *tty; 1116 unsigned char *data = urb->transfer_buffer; 1117 unsigned long flags; 1118 char tty_flag = TTY_NORMAL; 1119 int havedata = 0; 1120 int bytes = 0; 1121 int result; 1122 int i = 0; 1123 int status = urb->status; 1124 1125 switch (status) { 1126 case 0: /* success */ 1127 break; 1128 case -ECONNRESET: 1129 case -ENOENT: 1130 case -ESHUTDOWN: 1131 /* precursor to disconnect so just go away */ 1132 return; 1133 case -EPIPE: 1134 /* Can't call usb_clear_halt while in_interrupt */ 1135 /* FALLS THROUGH */ 1136 default: 1137 /* something ugly is going on... */ 1138 dev_err(&urb->dev->dev, 1139 "%s - unexpected nonzero read status received: %d\n", 1140 __func__, status); 1141 cypress_set_dead(port); 1142 return; 1143 } 1144 1145 spin_lock_irqsave(&priv->lock, flags); 1146 if (priv->rx_flags & THROTTLED) { 1147 dbg("%s - now throttling", __func__); 1148 priv->rx_flags |= ACTUALLY_THROTTLED; 1149 spin_unlock_irqrestore(&priv->lock, flags); 1150 return; 1151 } 1152 spin_unlock_irqrestore(&priv->lock, flags); 1153 1154 tty = tty_port_tty_get(&port->port); 1155 if (!tty) { 1156 dbg("%s - bad tty pointer - exiting", __func__); 1157 return; 1158 } 1159 1160 spin_lock_irqsave(&priv->lock, flags); 1161 result = urb->actual_length; 1162 switch (priv->pkt_fmt) { 1163 default: 1164 case packet_format_1: 1165 /* This is for the CY7C64013... */ 1166 priv->current_status = data[0] & 0xF8; 1167 bytes = data[1] + 2; 1168 i = 2; 1169 if (bytes > 2) 1170 havedata = 1; 1171 break; 1172 case packet_format_2: 1173 /* This is for the CY7C63743... */ 1174 priv->current_status = data[0] & 0xF8; 1175 bytes = (data[0] & 0x07) + 1; 1176 i = 1; 1177 if (bytes > 1) 1178 havedata = 1; 1179 break; 1180 } 1181 spin_unlock_irqrestore(&priv->lock, flags); 1182 if (result < bytes) { 1183 dbg("%s - wrong packet size - received %d bytes but packet " 1184 "said %d bytes", __func__, result, bytes); 1185 goto continue_read; 1186 } 1187 1188 usb_serial_debug_data(debug, &port->dev, __func__, 1189 urb->actual_length, data); 1190 1191 spin_lock_irqsave(&priv->lock, flags); 1192 /* check to see if status has changed */ 1193 if (priv->current_status != priv->prev_status) { 1194 priv->diff_status |= priv->current_status ^ 1195 priv->prev_status; 1196 wake_up_interruptible(&priv->delta_msr_wait); 1197 priv->prev_status = priv->current_status; 1198 } 1199 spin_unlock_irqrestore(&priv->lock, flags); 1200 1201 /* hangup, as defined in acm.c... this might be a bad place for it 1202 * though */ 1203 if (tty && !(tty->termios->c_cflag & CLOCAL) && 1204 !(priv->current_status & UART_CD)) { 1205 dbg("%s - calling hangup", __func__); 1206 tty_hangup(tty); 1207 goto continue_read; 1208 } 1209 1210 /* There is one error bit... I'm assuming it is a parity error 1211 * indicator as the generic firmware will set this bit to 1 if a 1212 * parity error occurs. 1213 * I can not find reference to any other error events. */ 1214 spin_lock_irqsave(&priv->lock, flags); 1215 if (priv->current_status & CYP_ERROR) { 1216 spin_unlock_irqrestore(&priv->lock, flags); 1217 tty_flag = TTY_PARITY; 1218 dbg("%s - Parity Error detected", __func__); 1219 } else 1220 spin_unlock_irqrestore(&priv->lock, flags); 1221 1222 /* process read if there is data other than line status */ 1223 if (tty && bytes > i) { 1224 tty_insert_flip_string_fixed_flag(tty, data + i, 1225 tty_flag, bytes - i); 1226 tty_flip_buffer_push(tty); 1227 } 1228 1229 spin_lock_irqsave(&priv->lock, flags); 1230 /* control and status byte(s) are also counted */ 1231 priv->bytes_in += bytes; 1232 spin_unlock_irqrestore(&priv->lock, flags); 1233 1234 continue_read: 1235 tty_kref_put(tty); 1236 1237 /* Continue trying to always read */ 1238 1239 if (priv->comm_is_ok) { 1240 usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev, 1241 usb_rcvintpipe(port->serial->dev, 1242 port->interrupt_in_endpointAddress), 1243 port->interrupt_in_urb->transfer_buffer, 1244 port->interrupt_in_urb->transfer_buffer_length, 1245 cypress_read_int_callback, port, 1246 priv->read_urb_interval); 1247 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 1248 if (result && result != -EPERM) { 1249 dev_err(&urb->dev->dev, "%s - failed resubmitting " 1250 "read urb, error %d\n", __func__, 1251 result); 1252 cypress_set_dead(port); 1253 } 1254 } 1255 } /* cypress_read_int_callback */ 1256 1257 1258 static void cypress_write_int_callback(struct urb *urb) 1259 { 1260 struct usb_serial_port *port = urb->context; 1261 struct cypress_private *priv = usb_get_serial_port_data(port); 1262 int result; 1263 int status = urb->status; 1264 1265 switch (status) { 1266 case 0: 1267 /* success */ 1268 break; 1269 case -ECONNRESET: 1270 case -ENOENT: 1271 case -ESHUTDOWN: 1272 /* this urb is terminated, clean up */ 1273 dbg("%s - urb shutting down with status: %d", 1274 __func__, status); 1275 priv->write_urb_in_use = 0; 1276 return; 1277 case -EPIPE: /* no break needed; clear halt and resubmit */ 1278 if (!priv->comm_is_ok) 1279 break; 1280 usb_clear_halt(port->serial->dev, 0x02); 1281 /* error in the urb, so we have to resubmit it */ 1282 dbg("%s - nonzero write bulk status received: %d", 1283 __func__, status); 1284 port->interrupt_out_urb->transfer_buffer_length = 1; 1285 result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC); 1286 if (!result) 1287 return; 1288 dev_err(&urb->dev->dev, 1289 "%s - failed resubmitting write urb, error %d\n", 1290 __func__, result); 1291 cypress_set_dead(port); 1292 break; 1293 default: 1294 dev_err(&urb->dev->dev, 1295 "%s - unexpected nonzero write status received: %d\n", 1296 __func__, status); 1297 cypress_set_dead(port); 1298 break; 1299 } 1300 priv->write_urb_in_use = 0; 1301 1302 /* send any buffered data */ 1303 cypress_send(port); 1304 } 1305 1306 module_usb_serial_driver(serial_drivers, id_table_combined); 1307 1308 MODULE_AUTHOR(DRIVER_AUTHOR); 1309 MODULE_DESCRIPTION(DRIVER_DESC); 1310 MODULE_VERSION(DRIVER_VERSION); 1311 MODULE_LICENSE("GPL"); 1312 1313 module_param(debug, bool, S_IRUGO | S_IWUSR); 1314 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1315 module_param(stats, bool, S_IRUGO | S_IWUSR); 1316 MODULE_PARM_DESC(stats, "Enable statistics or not"); 1317 module_param(interval, int, S_IRUGO | S_IWUSR); 1318 MODULE_PARM_DESC(interval, "Overrides interrupt interval"); 1319 module_param(unstable_bauds, bool, S_IRUGO | S_IWUSR); 1320 MODULE_PARM_DESC(unstable_bauds, "Allow unstable baud rates"); 1321