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