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 driver 15 * 16 * See http://geocities.com/i0xox0i for information on this driver and the 17 * earthmate usb device. 18 * 19 * Lonnie Mendez <dignome@gmail.com> 20 * 4-29-2005 21 * Fixed problem where setting or retreiving the serial config would fail with 22 * EPIPE. Removed CRTS toggling so the driver behaves more like other usbserial 23 * adapters. Issued new interval of 1ms instead of the default 10ms. As a 24 * result, transfer speed has been substantially increased. From avg. 850bps to 25 * avg. 3300bps. initial termios has also been modified. Cleaned up code and 26 * formatting issues so it is more readable. Replaced the C++ style comments. 27 * 28 * Lonnie Mendez <dignome@gmail.com> 29 * 12-15-2004 30 * Incorporated write buffering from pl2303 driver. Fixed bug with line 31 * handling so both lines are raised in cypress_open. (was dropping rts) 32 * Various code cleanups made as well along with other misc bug fixes. 33 * 34 * Lonnie Mendez <dignome@gmail.com> 35 * 04-10-2004 36 * Driver modified to support dynamic line settings. Various improvments 37 * and features. 38 * 39 * Neil Whelchel 40 * 10-2003 41 * Driver first released. 42 * 43 */ 44 45 /* Thanks to Neil Whelchel for writing the first cypress m8 implementation for linux. */ 46 /* Thanks to cypress for providing references for the hid reports. */ 47 /* Thanks to Jiang Zhang for providing links and for general help. */ 48 /* Code originates and was built up from ftdi_sio, belkin, pl2303 and others. */ 49 50 51 #include <linux/config.h> 52 #include <linux/kernel.h> 53 #include <linux/errno.h> 54 #include <linux/init.h> 55 #include <linux/slab.h> 56 #include <linux/tty.h> 57 #include <linux/tty_driver.h> 58 #include <linux/tty_flip.h> 59 #include <linux/module.h> 60 #include <linux/moduleparam.h> 61 #include <linux/spinlock.h> 62 #include <linux/usb.h> 63 #include <linux/serial.h> 64 #include <linux/delay.h> 65 #include <asm/uaccess.h> 66 67 #include "usb-serial.h" 68 #include "cypress_m8.h" 69 70 71 #ifdef CONFIG_USB_SERIAL_DEBUG 72 static int debug = 1; 73 #else 74 static int debug; 75 #endif 76 static int stats; 77 static int interval; 78 79 /* 80 * Version Information 81 */ 82 #define DRIVER_VERSION "v1.09" 83 #define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>" 84 #define DRIVER_DESC "Cypress USB to Serial Driver" 85 86 /* write buffer size defines */ 87 #define CYPRESS_BUF_SIZE 1024 88 #define CYPRESS_CLOSING_WAIT (30*HZ) 89 90 static struct usb_device_id id_table_earthmate [] = { 91 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) }, 92 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) }, 93 { } /* Terminating entry */ 94 }; 95 96 static struct usb_device_id id_table_cyphidcomrs232 [] = { 97 { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) }, 98 { } /* Terminating entry */ 99 }; 100 101 static struct usb_device_id id_table_combined [] = { 102 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) }, 103 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) }, 104 { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) }, 105 { } /* Terminating entry */ 106 }; 107 108 MODULE_DEVICE_TABLE (usb, id_table_combined); 109 110 static struct usb_driver cypress_driver = { 111 .name = "cypress", 112 .probe = usb_serial_probe, 113 .disconnect = usb_serial_disconnect, 114 .id_table = id_table_combined, 115 }; 116 117 struct cypress_private { 118 spinlock_t lock; /* private lock */ 119 int chiptype; /* identifier of device, for quirks/etc */ 120 int bytes_in; /* used for statistics */ 121 int bytes_out; /* used for statistics */ 122 int cmd_count; /* used for statistics */ 123 int cmd_ctrl; /* always set this to 1 before issuing a command */ 124 struct cypress_buf *buf; /* write buffer */ 125 int write_urb_in_use; /* write urb in use indicator */ 126 int termios_initialized; 127 __u8 line_control; /* holds dtr / rts value */ 128 __u8 current_status; /* received from last read - info on dsr,cts,cd,ri,etc */ 129 __u8 current_config; /* stores the current configuration byte */ 130 __u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */ 131 int baud_rate; /* stores current baud rate in integer form */ 132 int cbr_mask; /* stores current baud rate in masked form */ 133 int isthrottled; /* if throttled, discard reads */ 134 wait_queue_head_t delta_msr_wait; /* used for TIOCMIWAIT */ 135 char prev_status, diff_status; /* used for TIOCMIWAIT */ 136 /* we pass a pointer to this as the arguement sent to cypress_set_termios old_termios */ 137 struct termios tmp_termios; /* stores the old termios settings */ 138 }; 139 140 /* write buffer structure */ 141 struct cypress_buf { 142 unsigned int buf_size; 143 char *buf_buf; 144 char *buf_get; 145 char *buf_put; 146 }; 147 148 /* function prototypes for the Cypress USB to serial device */ 149 static int cypress_earthmate_startup (struct usb_serial *serial); 150 static int cypress_hidcom_startup (struct usb_serial *serial); 151 static void cypress_shutdown (struct usb_serial *serial); 152 static int cypress_open (struct usb_serial_port *port, struct file *filp); 153 static void cypress_close (struct usb_serial_port *port, struct file *filp); 154 static int cypress_write (struct usb_serial_port *port, const unsigned char *buf, int count); 155 static void cypress_send (struct usb_serial_port *port); 156 static int cypress_write_room (struct usb_serial_port *port); 157 static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg); 158 static void cypress_set_termios (struct usb_serial_port *port, struct termios * old); 159 static int cypress_tiocmget (struct usb_serial_port *port, struct file *file); 160 static int cypress_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear); 161 static int cypress_chars_in_buffer (struct usb_serial_port *port); 162 static void cypress_throttle (struct usb_serial_port *port); 163 static void cypress_unthrottle (struct usb_serial_port *port); 164 static void cypress_read_int_callback (struct urb *urb, struct pt_regs *regs); 165 static void cypress_write_int_callback (struct urb *urb, struct pt_regs *regs); 166 /* baud helper functions */ 167 static int mask_to_rate (unsigned mask); 168 static unsigned rate_to_mask (int rate); 169 /* write buffer functions */ 170 static struct cypress_buf *cypress_buf_alloc(unsigned int size); 171 static void cypress_buf_free(struct cypress_buf *cb); 172 static void cypress_buf_clear(struct cypress_buf *cb); 173 static unsigned int cypress_buf_data_avail(struct cypress_buf *cb); 174 static unsigned int cypress_buf_space_avail(struct cypress_buf *cb); 175 static unsigned int cypress_buf_put(struct cypress_buf *cb, const char *buf, unsigned int count); 176 static unsigned int cypress_buf_get(struct cypress_buf *cb, char *buf, unsigned int count); 177 178 179 static struct usb_serial_device_type cypress_earthmate_device = { 180 .owner = THIS_MODULE, 181 .name = "DeLorme Earthmate USB", 182 .short_name = "earthmate", 183 .id_table = id_table_earthmate, 184 .num_interrupt_in = 1, 185 .num_interrupt_out = 1, 186 .num_bulk_in = NUM_DONT_CARE, 187 .num_bulk_out = NUM_DONT_CARE, 188 .num_ports = 1, 189 .attach = cypress_earthmate_startup, 190 .shutdown = cypress_shutdown, 191 .open = cypress_open, 192 .close = cypress_close, 193 .write = cypress_write, 194 .write_room = cypress_write_room, 195 .ioctl = cypress_ioctl, 196 .set_termios = cypress_set_termios, 197 .tiocmget = cypress_tiocmget, 198 .tiocmset = cypress_tiocmset, 199 .chars_in_buffer = cypress_chars_in_buffer, 200 .throttle = cypress_throttle, 201 .unthrottle = cypress_unthrottle, 202 .read_int_callback = cypress_read_int_callback, 203 .write_int_callback = cypress_write_int_callback, 204 }; 205 206 static struct usb_serial_device_type cypress_hidcom_device = { 207 .owner = THIS_MODULE, 208 .name = "HID->COM RS232 Adapter", 209 .short_name = "cyphidcom", 210 .id_table = id_table_cyphidcomrs232, 211 .num_interrupt_in = 1, 212 .num_interrupt_out = 1, 213 .num_bulk_in = NUM_DONT_CARE, 214 .num_bulk_out = NUM_DONT_CARE, 215 .num_ports = 1, 216 .attach = cypress_hidcom_startup, 217 .shutdown = cypress_shutdown, 218 .open = cypress_open, 219 .close = cypress_close, 220 .write = cypress_write, 221 .write_room = cypress_write_room, 222 .ioctl = cypress_ioctl, 223 .set_termios = cypress_set_termios, 224 .tiocmget = cypress_tiocmget, 225 .tiocmset = cypress_tiocmset, 226 .chars_in_buffer = cypress_chars_in_buffer, 227 .throttle = cypress_throttle, 228 .unthrottle = cypress_unthrottle, 229 .read_int_callback = cypress_read_int_callback, 230 .write_int_callback = cypress_write_int_callback, 231 }; 232 233 234 /***************************************************************************** 235 * Cypress serial helper functions 236 *****************************************************************************/ 237 238 239 /* This function can either set or retrieve the current serial line settings */ 240 static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_mask, int data_bits, int stop_bits, 241 int parity_enable, int parity_type, int reset, int cypress_request_type) 242 { 243 int new_baudrate = 0, retval = 0, tries = 0; 244 struct cypress_private *priv; 245 __u8 feature_buffer[8]; 246 unsigned long flags; 247 248 dbg("%s", __FUNCTION__); 249 250 priv = usb_get_serial_port_data(port); 251 252 switch(cypress_request_type) { 253 case CYPRESS_SET_CONFIG: 254 255 /* 256 * The general purpose firmware for the Cypress M8 allows for a maximum speed 257 * of 57600bps (I have no idea whether DeLorme chose to use the general purpose 258 * firmware or not), if you need to modify this speed setting for your own 259 * project please add your own chiptype and modify the code likewise. The 260 * Cypress HID->COM device will work successfully up to 115200bps (but the 261 * actual throughput is around 3kBps). 262 */ 263 if (baud_mask != priv->cbr_mask) { 264 dbg("%s - baud rate is changing", __FUNCTION__); 265 if ( priv->chiptype == CT_EARTHMATE ) { 266 /* 300 and 600 baud rates are supported under the generic firmware, 267 * but are not used with NMEA and SiRF protocols */ 268 269 if ( (baud_mask == B300) || (baud_mask == B600) ) { 270 err("%s - failed setting baud rate, unsupported speed", 271 __FUNCTION__); 272 new_baudrate = priv->baud_rate; 273 } else if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) { 274 err("%s - failed setting baud rate, unsupported speed", 275 __FUNCTION__); 276 new_baudrate = priv->baud_rate; 277 } 278 } else if (priv->chiptype == CT_CYPHIDCOM) { 279 if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) { 280 err("%s - failed setting baud rate, unsupported speed", 281 __FUNCTION__); 282 new_baudrate = priv->baud_rate; 283 } 284 } else if (priv->chiptype == CT_GENERIC) { 285 if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) { 286 err("%s - failed setting baud rate, unsupported speed", 287 __FUNCTION__); 288 new_baudrate = priv->baud_rate; 289 } 290 } else { 291 info("%s - please define your chiptype", __FUNCTION__); 292 new_baudrate = priv->baud_rate; 293 } 294 } else { /* baud rate not changing, keep the old */ 295 new_baudrate = priv->baud_rate; 296 } 297 dbg("%s - baud rate is being sent as %d", __FUNCTION__, new_baudrate); 298 299 memset(feature_buffer, 0, 8); 300 /* fill the feature_buffer with new configuration */ 301 *((u_int32_t *)feature_buffer) = new_baudrate; 302 303 feature_buffer[4] |= data_bits; /* assign data bits in 2 bit space ( max 3 ) */ 304 /* 1 bit gap */ 305 feature_buffer[4] |= (stop_bits << 3); /* assign stop bits in 1 bit space */ 306 feature_buffer[4] |= (parity_enable << 4); /* assign parity flag in 1 bit space */ 307 feature_buffer[4] |= (parity_type << 5); /* assign parity type in 1 bit space */ 308 /* 1 bit gap */ 309 feature_buffer[4] |= (reset << 7); /* assign reset at end of byte, 1 bit space */ 310 311 dbg("%s - device is being sent this feature report:", __FUNCTION__); 312 dbg("%s - %02X - %02X - %02X - %02X - %02X", __FUNCTION__, feature_buffer[0], feature_buffer[1], 313 feature_buffer[2], feature_buffer[3], feature_buffer[4]); 314 315 do { 316 retval = usb_control_msg (port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0), 317 HID_REQ_SET_REPORT, USB_DIR_OUT | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 318 0x0300, 0, feature_buffer, 8, 500); 319 320 if (tries++ >= 3) 321 break; 322 323 if (retval == EPIPE) 324 usb_clear_halt(port->serial->dev, 0x00); 325 } while (retval != 8 && retval != ENODEV); 326 327 if (retval != 8) 328 err("%s - failed sending serial line settings - %d", __FUNCTION__, retval); 329 else { 330 spin_lock_irqsave(&priv->lock, flags); 331 priv->baud_rate = new_baudrate; 332 priv->cbr_mask = baud_mask; 333 priv->current_config = feature_buffer[4]; 334 spin_unlock_irqrestore(&priv->lock, flags); 335 } 336 break; 337 case CYPRESS_GET_CONFIG: 338 dbg("%s - retreiving serial line settings", __FUNCTION__); 339 /* set initial values in feature buffer */ 340 memset(feature_buffer, 0, 8); 341 342 do { 343 retval = usb_control_msg (port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0), 344 HID_REQ_GET_REPORT, USB_DIR_IN | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 345 0x0300, 0, feature_buffer, 8, 500); 346 347 if (tries++ >= 3) 348 break; 349 350 if (retval == EPIPE) 351 usb_clear_halt(port->serial->dev, 0x00); 352 } while (retval != 5 && retval != ENODEV); 353 354 if (retval != 5) { 355 err("%s - failed to retreive serial line settings - %d", __FUNCTION__, retval); 356 return retval; 357 } else { 358 spin_lock_irqsave(&priv->lock, flags); 359 360 /* store the config in one byte, and later use bit masks to check values */ 361 priv->current_config = feature_buffer[4]; 362 priv->baud_rate = *((u_int32_t *)feature_buffer); 363 364 if ( (priv->cbr_mask = rate_to_mask(priv->baud_rate)) == 0x40) 365 dbg("%s - failed setting the baud mask (not defined)", __FUNCTION__); 366 spin_unlock_irqrestore(&priv->lock, flags); 367 } 368 } 369 spin_lock_irqsave(&priv->lock, flags); 370 ++priv->cmd_count; 371 spin_unlock_irqrestore(&priv->lock, flags); 372 373 return retval; 374 } /* cypress_serial_control */ 375 376 377 /* given a baud mask, it will return integer baud on success */ 378 static int mask_to_rate (unsigned mask) 379 { 380 int rate; 381 382 switch (mask) { 383 case B0: rate = 0; break; 384 case B300: rate = 300; break; 385 case B600: rate = 600; break; 386 case B1200: rate = 1200; break; 387 case B2400: rate = 2400; break; 388 case B4800: rate = 4800; break; 389 case B9600: rate = 9600; break; 390 case B19200: rate = 19200; break; 391 case B38400: rate = 38400; break; 392 case B57600: rate = 57600; break; 393 case B115200: rate = 115200; break; 394 default: rate = -1; 395 } 396 397 return rate; 398 } 399 400 401 static unsigned rate_to_mask (int rate) 402 { 403 unsigned mask; 404 405 switch (rate) { 406 case 0: mask = B0; break; 407 case 300: mask = B300; break; 408 case 600: mask = B600; break; 409 case 1200: mask = B1200; break; 410 case 2400: mask = B2400; break; 411 case 4800: mask = B4800; break; 412 case 9600: mask = B9600; break; 413 case 19200: mask = B19200; break; 414 case 38400: mask = B38400; break; 415 case 57600: mask = B57600; break; 416 case 115200: mask = B115200; break; 417 default: mask = 0x40; 418 } 419 420 return mask; 421 } 422 /***************************************************************************** 423 * Cypress serial driver functions 424 *****************************************************************************/ 425 426 427 static int generic_startup (struct usb_serial *serial) 428 { 429 struct cypress_private *priv; 430 431 dbg("%s - port %d", __FUNCTION__, serial->port[0]->number); 432 433 priv = kmalloc(sizeof (struct cypress_private), GFP_KERNEL); 434 if (!priv) 435 return -ENOMEM; 436 437 memset(priv, 0x00, sizeof (struct cypress_private)); 438 spin_lock_init(&priv->lock); 439 priv->buf = cypress_buf_alloc(CYPRESS_BUF_SIZE); 440 if (priv->buf == NULL) { 441 kfree(priv); 442 return -ENOMEM; 443 } 444 init_waitqueue_head(&priv->delta_msr_wait); 445 446 usb_reset_configuration (serial->dev); 447 448 interval = 1; 449 priv->cmd_ctrl = 0; 450 priv->line_control = 0; 451 priv->termios_initialized = 0; 452 priv->rx_flags = 0; 453 priv->cbr_mask = B300; 454 usb_set_serial_port_data(serial->port[0], priv); 455 456 return 0; 457 } 458 459 460 static int cypress_earthmate_startup (struct usb_serial *serial) 461 { 462 struct cypress_private *priv; 463 464 dbg("%s", __FUNCTION__); 465 466 if (generic_startup(serial)) { 467 dbg("%s - Failed setting up port %d", __FUNCTION__, 468 serial->port[0]->number); 469 return 1; 470 } 471 472 priv = usb_get_serial_port_data(serial->port[0]); 473 priv->chiptype = CT_EARTHMATE; 474 475 return 0; 476 } /* cypress_earthmate_startup */ 477 478 479 static int cypress_hidcom_startup (struct usb_serial *serial) 480 { 481 struct cypress_private *priv; 482 483 dbg("%s", __FUNCTION__); 484 485 if (generic_startup(serial)) { 486 dbg("%s - Failed setting up port %d", __FUNCTION__, 487 serial->port[0]->number); 488 return 1; 489 } 490 491 priv = usb_get_serial_port_data(serial->port[0]); 492 priv->chiptype = CT_CYPHIDCOM; 493 494 return 0; 495 } /* cypress_hidcom_startup */ 496 497 498 static void cypress_shutdown (struct usb_serial *serial) 499 { 500 struct cypress_private *priv; 501 502 dbg ("%s - port %d", __FUNCTION__, serial->port[0]->number); 503 504 /* all open ports are closed at this point */ 505 506 priv = usb_get_serial_port_data(serial->port[0]); 507 508 if (priv) { 509 cypress_buf_free(priv->buf); 510 kfree(priv); 511 usb_set_serial_port_data(serial->port[0], NULL); 512 } 513 } 514 515 516 static int cypress_open (struct usb_serial_port *port, struct file *filp) 517 { 518 struct cypress_private *priv = usb_get_serial_port_data(port); 519 struct usb_serial *serial = port->serial; 520 unsigned long flags; 521 int result = 0; 522 523 dbg("%s - port %d", __FUNCTION__, port->number); 524 525 /* clear halts before open */ 526 usb_clear_halt(serial->dev, 0x81); 527 usb_clear_halt(serial->dev, 0x02); 528 529 spin_lock_irqsave(&priv->lock, flags); 530 /* reset read/write statistics */ 531 priv->bytes_in = 0; 532 priv->bytes_out = 0; 533 priv->cmd_count = 0; 534 priv->rx_flags = 0; 535 spin_unlock_irqrestore(&priv->lock, flags); 536 537 /* setting to zero could cause data loss */ 538 port->tty->low_latency = 1; 539 540 /* raise both lines and set termios */ 541 spin_lock_irqsave(&priv->lock, flags); 542 priv->line_control = CONTROL_DTR | CONTROL_RTS; 543 priv->cmd_ctrl = 1; 544 spin_unlock_irqrestore(&priv->lock, flags); 545 result = cypress_write(port, NULL, 0); 546 547 if (result) { 548 dev_err(&port->dev, "%s - failed setting the control lines - error %d\n", __FUNCTION__, result); 549 return result; 550 } else 551 dbg("%s - success setting the control lines", __FUNCTION__); 552 553 cypress_set_termios(port, &priv->tmp_termios); 554 555 /* setup the port and start reading from the device */ 556 if(!port->interrupt_in_urb){ 557 err("%s - interrupt_in_urb is empty!", __FUNCTION__); 558 return(-1); 559 } 560 561 usb_fill_int_urb(port->interrupt_in_urb, serial->dev, 562 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress), 563 port->interrupt_in_urb->transfer_buffer, port->interrupt_in_urb->transfer_buffer_length, 564 cypress_read_int_callback, port, interval); 565 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 566 567 if (result){ 568 dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __FUNCTION__, result); 569 } 570 571 return result; 572 } /* cypress_open */ 573 574 575 static void cypress_close(struct usb_serial_port *port, struct file * filp) 576 { 577 struct cypress_private *priv = usb_get_serial_port_data(port); 578 unsigned int c_cflag; 579 unsigned long flags; 580 int bps; 581 long timeout; 582 wait_queue_t wait; 583 584 dbg("%s - port %d", __FUNCTION__, port->number); 585 586 /* wait for data to drain from buffer */ 587 spin_lock_irqsave(&priv->lock, flags); 588 timeout = CYPRESS_CLOSING_WAIT; 589 init_waitqueue_entry(&wait, current); 590 add_wait_queue(&port->tty->write_wait, &wait); 591 for (;;) { 592 set_current_state(TASK_INTERRUPTIBLE); 593 if (cypress_buf_data_avail(priv->buf) == 0 594 || timeout == 0 || signal_pending(current) 595 || !usb_get_intfdata(port->serial->interface)) 596 break; 597 spin_unlock_irqrestore(&priv->lock, flags); 598 timeout = schedule_timeout(timeout); 599 spin_lock_irqsave(&priv->lock, flags); 600 } 601 set_current_state(TASK_RUNNING); 602 remove_wait_queue(&port->tty->write_wait, &wait); 603 /* clear out any remaining data in the buffer */ 604 cypress_buf_clear(priv->buf); 605 spin_unlock_irqrestore(&priv->lock, flags); 606 607 /* wait for characters to drain from device */ 608 bps = tty_get_baud_rate(port->tty); 609 if (bps > 1200) 610 timeout = max((HZ*2560)/bps,HZ/10); 611 else 612 timeout = 2*HZ; 613 set_current_state(TASK_INTERRUPTIBLE); 614 schedule_timeout(timeout); 615 616 dbg("%s - stopping urbs", __FUNCTION__); 617 usb_kill_urb (port->interrupt_in_urb); 618 usb_kill_urb (port->interrupt_out_urb); 619 620 if (port->tty) { 621 c_cflag = port->tty->termios->c_cflag; 622 if (c_cflag & HUPCL) { 623 /* drop dtr and rts */ 624 priv = usb_get_serial_port_data(port); 625 spin_lock_irqsave(&priv->lock, flags); 626 priv->line_control = 0; 627 priv->cmd_ctrl = 1; 628 spin_unlock_irqrestore(&priv->lock, flags); 629 cypress_write(port, NULL, 0); 630 } 631 } 632 633 if (stats) 634 dev_info (&port->dev, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n", 635 priv->bytes_in, priv->bytes_out, priv->cmd_count); 636 } /* cypress_close */ 637 638 639 static int cypress_write(struct usb_serial_port *port, const unsigned char *buf, int count) 640 { 641 struct cypress_private *priv = usb_get_serial_port_data(port); 642 unsigned long flags; 643 644 dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count); 645 646 /* line control commands, which need to be executed immediately, 647 are not put into the buffer for obvious reasons. 648 */ 649 if (priv->cmd_ctrl) { 650 count = 0; 651 goto finish; 652 } 653 654 if (!count) 655 return count; 656 657 spin_lock_irqsave(&priv->lock, flags); 658 count = cypress_buf_put(priv->buf, buf, count); 659 spin_unlock_irqrestore(&priv->lock, flags); 660 661 finish: 662 cypress_send(port); 663 664 return count; 665 } /* cypress_write */ 666 667 668 static void cypress_send(struct usb_serial_port *port) 669 { 670 int count = 0, result, offset, actual_size; 671 struct cypress_private *priv = usb_get_serial_port_data(port); 672 unsigned long flags; 673 674 dbg("%s - port %d", __FUNCTION__, port->number); 675 dbg("%s - interrupt out size is %d", __FUNCTION__, port->interrupt_out_size); 676 677 spin_lock_irqsave(&priv->lock, flags); 678 if (priv->write_urb_in_use) { 679 dbg("%s - can't write, urb in use", __FUNCTION__); 680 spin_unlock_irqrestore(&priv->lock, flags); 681 return; 682 } 683 spin_unlock_irqrestore(&priv->lock, flags); 684 685 /* clear buffer */ 686 memset(port->interrupt_out_urb->transfer_buffer, 0, port->interrupt_out_size); 687 688 spin_lock_irqsave(&priv->lock, flags); 689 switch (port->interrupt_out_size) { 690 case 32: 691 /* this is for the CY7C64013... */ 692 offset = 2; 693 port->interrupt_out_buffer[0] = priv->line_control; 694 break; 695 case 8: 696 /* this is for the CY7C63743... */ 697 offset = 1; 698 port->interrupt_out_buffer[0] = priv->line_control; 699 break; 700 default: 701 dbg("%s - wrong packet size", __FUNCTION__); 702 spin_unlock_irqrestore(&priv->lock, flags); 703 return; 704 } 705 706 if (priv->line_control & CONTROL_RESET) 707 priv->line_control &= ~CONTROL_RESET; 708 709 if (priv->cmd_ctrl) { 710 priv->cmd_count++; 711 dbg("%s - line control command being issued", __FUNCTION__); 712 spin_unlock_irqrestore(&priv->lock, flags); 713 goto send; 714 } else 715 spin_unlock_irqrestore(&priv->lock, flags); 716 717 count = cypress_buf_get(priv->buf, &port->interrupt_out_buffer[offset], 718 port->interrupt_out_size-offset); 719 720 if (count == 0) { 721 return; 722 } 723 724 switch (port->interrupt_out_size) { 725 case 32: 726 port->interrupt_out_buffer[1] = count; 727 break; 728 case 8: 729 port->interrupt_out_buffer[0] |= count; 730 } 731 732 dbg("%s - count is %d", __FUNCTION__, count); 733 734 send: 735 spin_lock_irqsave(&priv->lock, flags); 736 priv->write_urb_in_use = 1; 737 spin_unlock_irqrestore(&priv->lock, flags); 738 739 if (priv->cmd_ctrl) 740 actual_size = 1; 741 else 742 actual_size = count + (port->interrupt_out_size == 32 ? 2 : 1); 743 744 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, port->interrupt_out_size, 745 port->interrupt_out_urb->transfer_buffer); 746 747 port->interrupt_out_urb->transfer_buffer_length = actual_size; 748 port->interrupt_out_urb->dev = port->serial->dev; 749 port->interrupt_out_urb->interval = interval; 750 result = usb_submit_urb (port->interrupt_out_urb, GFP_ATOMIC); 751 if (result) { 752 dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __FUNCTION__, 753 result); 754 priv->write_urb_in_use = 0; 755 } 756 757 spin_lock_irqsave(&priv->lock, flags); 758 if (priv->cmd_ctrl) { 759 priv->cmd_ctrl = 0; 760 } 761 priv->bytes_out += count; /* do not count the line control and size bytes */ 762 spin_unlock_irqrestore(&priv->lock, flags); 763 764 schedule_work(&port->work); 765 } /* cypress_send */ 766 767 768 /* returns how much space is available in the soft buffer */ 769 static int cypress_write_room(struct usb_serial_port *port) 770 { 771 struct cypress_private *priv = usb_get_serial_port_data(port); 772 int room = 0; 773 unsigned long flags; 774 775 dbg("%s - port %d", __FUNCTION__, port->number); 776 777 spin_lock_irqsave(&priv->lock, flags); 778 room = cypress_buf_space_avail(priv->buf); 779 spin_unlock_irqrestore(&priv->lock, flags); 780 781 dbg("%s - returns %d", __FUNCTION__, room); 782 return room; 783 } 784 785 786 static int cypress_tiocmget (struct usb_serial_port *port, struct file *file) 787 { 788 struct cypress_private *priv = usb_get_serial_port_data(port); 789 __u8 status, control; 790 unsigned int result = 0; 791 unsigned long flags; 792 793 dbg("%s - port %d", __FUNCTION__, port->number); 794 795 spin_lock_irqsave(&priv->lock, flags); 796 control = priv->line_control; 797 status = priv->current_status; 798 spin_unlock_irqrestore(&priv->lock, flags); 799 800 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0) 801 | ((control & CONTROL_RTS) ? TIOCM_RTS : 0) 802 | ((status & UART_CTS) ? TIOCM_CTS : 0) 803 | ((status & UART_DSR) ? TIOCM_DSR : 0) 804 | ((status & UART_RI) ? TIOCM_RI : 0) 805 | ((status & UART_CD) ? TIOCM_CD : 0); 806 807 dbg("%s - result = %x", __FUNCTION__, result); 808 809 return result; 810 } 811 812 813 static int cypress_tiocmset (struct usb_serial_port *port, struct file *file, 814 unsigned int set, unsigned int clear) 815 { 816 struct cypress_private *priv = usb_get_serial_port_data(port); 817 unsigned long flags; 818 819 dbg("%s - port %d", __FUNCTION__, port->number); 820 821 spin_lock_irqsave(&priv->lock, flags); 822 if (set & TIOCM_RTS) 823 priv->line_control |= CONTROL_RTS; 824 if (set & TIOCM_DTR) 825 priv->line_control |= CONTROL_DTR; 826 if (clear & TIOCM_RTS) 827 priv->line_control &= ~CONTROL_RTS; 828 if (clear & TIOCM_DTR) 829 priv->line_control &= ~CONTROL_DTR; 830 spin_unlock_irqrestore(&priv->lock, flags); 831 832 priv->cmd_ctrl = 1; 833 return cypress_write(port, NULL, 0); 834 } 835 836 837 static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg) 838 { 839 struct cypress_private *priv = usb_get_serial_port_data(port); 840 841 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd); 842 843 switch (cmd) { 844 case TIOCGSERIAL: 845 if (copy_to_user((void __user *)arg, port->tty->termios, sizeof(struct termios))) { 846 return -EFAULT; 847 } 848 return (0); 849 break; 850 case TIOCSSERIAL: 851 if (copy_from_user(port->tty->termios, (void __user *)arg, sizeof(struct termios))) { 852 return -EFAULT; 853 } 854 /* here we need to call cypress_set_termios to invoke the new settings */ 855 cypress_set_termios(port, &priv->tmp_termios); 856 return (0); 857 break; 858 /* these are called when setting baud rate from gpsd */ 859 case TCGETS: 860 if (copy_to_user((void __user *)arg, port->tty->termios, sizeof(struct termios))) { 861 return -EFAULT; 862 } 863 return (0); 864 break; 865 case TCSETS: 866 if (copy_from_user(port->tty->termios, (void __user *)arg, sizeof(struct termios))) { 867 return -EFAULT; 868 } 869 /* here we need to call cypress_set_termios to invoke the new settings */ 870 cypress_set_termios(port, &priv->tmp_termios); 871 return (0); 872 break; 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 883 if (diff == 0) { 884 return -EIO; /* no change => error */ 885 } 886 887 /* consume all events */ 888 priv->diff_status = 0; 889 890 /* return 0 if caller wanted to know about these bits */ 891 if ( ((arg & TIOCM_RNG) && (diff & UART_RI)) || 892 ((arg & TIOCM_DSR) && (diff & UART_DSR)) || 893 ((arg & TIOCM_CD) && (diff & UART_CD)) || 894 ((arg & TIOCM_CTS) && (diff & UART_CTS)) ) { 895 return 0; 896 } 897 /* otherwise caller can't care less about what happened, 898 * and so we continue to wait for more events. 899 */ 900 } 901 } 902 return 0; 903 break; 904 default: 905 break; 906 } 907 908 dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __FUNCTION__, cmd); 909 910 return -ENOIOCTLCMD; 911 } /* cypress_ioctl */ 912 913 914 static void cypress_set_termios (struct usb_serial_port *port, 915 struct termios *old_termios) 916 { 917 struct cypress_private *priv = usb_get_serial_port_data(port); 918 struct tty_struct *tty; 919 int data_bits, stop_bits, parity_type, parity_enable; 920 unsigned cflag, iflag, baud_mask; 921 unsigned long flags; 922 __u8 oldlines; 923 int linechange = 0; 924 925 dbg("%s - port %d", __FUNCTION__, port->number); 926 927 tty = port->tty; 928 if ((!tty) || (!tty->termios)) { 929 dbg("%s - no tty structures", __FUNCTION__); 930 return; 931 } 932 933 spin_lock_irqsave(&priv->lock, flags); 934 if (!priv->termios_initialized) { 935 if (priv->chiptype == CT_EARTHMATE) { 936 *(tty->termios) = tty_std_termios; 937 tty->termios->c_cflag = B4800 | CS8 | CREAD | HUPCL | 938 CLOCAL; 939 } else if (priv->chiptype == CT_CYPHIDCOM) { 940 *(tty->termios) = tty_std_termios; 941 tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL | 942 CLOCAL; 943 } 944 priv->termios_initialized = 1; 945 } 946 spin_unlock_irqrestore(&priv->lock, flags); 947 948 cflag = tty->termios->c_cflag; 949 iflag = tty->termios->c_iflag; 950 951 /* check if there are new settings */ 952 if (old_termios) { 953 if ((cflag != old_termios->c_cflag) || 954 (RELEVANT_IFLAG(iflag) != 955 RELEVANT_IFLAG(old_termios->c_iflag))) { 956 dbg("%s - attempting to set new termios settings", 957 __FUNCTION__); 958 /* should make a copy of this in case something goes 959 * wrong in the function, we can restore it */ 960 spin_lock_irqsave(&priv->lock, flags); 961 priv->tmp_termios = *(tty->termios); 962 spin_unlock_irqrestore(&priv->lock, flags); 963 } else { 964 dbg("%s - nothing to do, exiting", __FUNCTION__); 965 return; 966 } 967 } else 968 return; 969 970 /* set number of data bits, parity, stop bits */ 971 /* when parity is disabled the parity type bit is ignored */ 972 973 /* 1 means 2 stop bits, 0 means 1 stop bit */ 974 stop_bits = cflag & CSTOPB ? 1 : 0; 975 976 if (cflag & PARENB) { 977 parity_enable = 1; 978 /* 1 means odd parity, 0 means even parity */ 979 parity_type = cflag & PARODD ? 1 : 0; 980 } else 981 parity_enable = parity_type = 0; 982 983 if (cflag & CSIZE) { 984 switch (cflag & CSIZE) { 985 case CS5: 986 data_bits = 0; 987 break; 988 case CS6: 989 data_bits = 1; 990 break; 991 case CS7: 992 data_bits = 2; 993 break; 994 case CS8: 995 data_bits = 3; 996 break; 997 default: 998 err("%s - CSIZE was set, but not CS5-CS8", 999 __FUNCTION__); 1000 data_bits = 3; 1001 } 1002 } else 1003 data_bits = 3; 1004 1005 spin_lock_irqsave(&priv->lock, flags); 1006 oldlines = priv->line_control; 1007 if ((cflag & CBAUD) == B0) { 1008 /* drop dtr and rts */ 1009 dbg("%s - dropping the lines, baud rate 0bps", __FUNCTION__); 1010 baud_mask = B0; 1011 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 1012 } else { 1013 baud_mask = (cflag & CBAUD); 1014 switch(baud_mask) { 1015 case B300: 1016 dbg("%s - setting baud 300bps", __FUNCTION__); 1017 break; 1018 case B600: 1019 dbg("%s - setting baud 600bps", __FUNCTION__); 1020 break; 1021 case B1200: 1022 dbg("%s - setting baud 1200bps", __FUNCTION__); 1023 break; 1024 case B2400: 1025 dbg("%s - setting baud 2400bps", __FUNCTION__); 1026 break; 1027 case B4800: 1028 dbg("%s - setting baud 4800bps", __FUNCTION__); 1029 break; 1030 case B9600: 1031 dbg("%s - setting baud 9600bps", __FUNCTION__); 1032 break; 1033 case B19200: 1034 dbg("%s - setting baud 19200bps", __FUNCTION__); 1035 break; 1036 case B38400: 1037 dbg("%s - setting baud 38400bps", __FUNCTION__); 1038 break; 1039 case B57600: 1040 dbg("%s - setting baud 57600bps", __FUNCTION__); 1041 break; 1042 case B115200: 1043 dbg("%s - setting baud 115200bps", __FUNCTION__); 1044 break; 1045 default: 1046 dbg("%s - unknown masked baud rate", __FUNCTION__); 1047 } 1048 priv->line_control = (CONTROL_DTR | CONTROL_RTS); 1049 } 1050 spin_unlock_irqrestore(&priv->lock, flags); 1051 1052 dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, " 1053 "%d data_bits (+5)", __FUNCTION__, stop_bits, 1054 parity_enable, parity_type, data_bits); 1055 1056 cypress_serial_control(port, baud_mask, data_bits, stop_bits, 1057 parity_enable, parity_type, 0, CYPRESS_SET_CONFIG); 1058 1059 /* we perform a CYPRESS_GET_CONFIG so that the current settings are 1060 * filled into the private structure this should confirm that all is 1061 * working if it returns what we just set */ 1062 cypress_serial_control(port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG); 1063 1064 /* Here we can define custom tty settings for devices; the main tty 1065 * termios flag base comes from empeg.c */ 1066 1067 spin_lock_irqsave(&priv->lock, flags); 1068 if ( (priv->chiptype == CT_EARTHMATE) && (priv->baud_rate == 4800) ) { 1069 dbg("Using custom termios settings for a baud rate of " 1070 "4800bps."); 1071 /* define custom termios settings for NMEA protocol */ 1072 1073 tty->termios->c_iflag /* input modes - */ 1074 &= ~(IGNBRK /* disable ignore break */ 1075 | BRKINT /* disable break causes interrupt */ 1076 | PARMRK /* disable mark parity errors */ 1077 | ISTRIP /* disable clear high bit of input char */ 1078 | INLCR /* disable translate NL to CR */ 1079 | IGNCR /* disable ignore CR */ 1080 | ICRNL /* disable translate CR to NL */ 1081 | IXON); /* disable enable XON/XOFF flow control */ 1082 1083 tty->termios->c_oflag /* output modes */ 1084 &= ~OPOST; /* disable postprocess output char */ 1085 1086 tty->termios->c_lflag /* line discipline modes */ 1087 &= ~(ECHO /* disable echo input characters */ 1088 | ECHONL /* disable echo new line */ 1089 | ICANON /* disable erase, kill, werase, and rprnt 1090 special characters */ 1091 | ISIG /* disable interrupt, quit, and suspend 1092 special characters */ 1093 | IEXTEN); /* disable non-POSIX special characters */ 1094 } /* CT_CYPHIDCOM: Application should handle this for device */ 1095 1096 linechange = (priv->line_control != oldlines); 1097 spin_unlock_irqrestore(&priv->lock, flags); 1098 1099 /* if necessary, set lines */ 1100 if (linechange) { 1101 priv->cmd_ctrl = 1; 1102 cypress_write(port, NULL, 0); 1103 } 1104 } /* cypress_set_termios */ 1105 1106 1107 /* returns amount of data still left in soft buffer */ 1108 static int cypress_chars_in_buffer(struct usb_serial_port *port) 1109 { 1110 struct cypress_private *priv = usb_get_serial_port_data(port); 1111 int chars = 0; 1112 unsigned long flags; 1113 1114 dbg("%s - port %d", __FUNCTION__, port->number); 1115 1116 spin_lock_irqsave(&priv->lock, flags); 1117 chars = cypress_buf_data_avail(priv->buf); 1118 spin_unlock_irqrestore(&priv->lock, flags); 1119 1120 dbg("%s - returns %d", __FUNCTION__, chars); 1121 return chars; 1122 } 1123 1124 1125 static void cypress_throttle (struct usb_serial_port *port) 1126 { 1127 struct cypress_private *priv = usb_get_serial_port_data(port); 1128 unsigned long flags; 1129 1130 dbg("%s - port %d", __FUNCTION__, port->number); 1131 1132 spin_lock_irqsave(&priv->lock, flags); 1133 priv->rx_flags = THROTTLED; 1134 spin_unlock_irqrestore(&priv->lock, flags); 1135 } 1136 1137 1138 static void cypress_unthrottle (struct usb_serial_port *port) 1139 { 1140 struct cypress_private *priv = usb_get_serial_port_data(port); 1141 int actually_throttled, result; 1142 unsigned long flags; 1143 1144 dbg("%s - port %d", __FUNCTION__, port->number); 1145 1146 spin_lock_irqsave(&priv->lock, flags); 1147 actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED; 1148 priv->rx_flags = 0; 1149 spin_unlock_irqrestore(&priv->lock, flags); 1150 1151 if (actually_throttled) { 1152 port->interrupt_in_urb->dev = port->serial->dev; 1153 1154 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 1155 if (result) 1156 dev_err(&port->dev, "%s - failed submitting read urb, " 1157 "error %d\n", __FUNCTION__, result); 1158 } 1159 } 1160 1161 1162 static void cypress_read_int_callback(struct urb *urb, struct pt_regs *regs) 1163 { 1164 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 1165 struct cypress_private *priv = usb_get_serial_port_data(port); 1166 struct tty_struct *tty; 1167 unsigned char *data = urb->transfer_buffer; 1168 unsigned long flags; 1169 char tty_flag = TTY_NORMAL; 1170 int havedata = 0; 1171 int bytes = 0; 1172 int result; 1173 int i = 0; 1174 1175 dbg("%s - port %d", __FUNCTION__, port->number); 1176 1177 if (urb->status) { 1178 dbg("%s - nonzero read status received: %d", __FUNCTION__, 1179 urb->status); 1180 return; 1181 } 1182 1183 spin_lock_irqsave(&priv->lock, flags); 1184 if (priv->rx_flags & THROTTLED) { 1185 dbg("%s - now throttling", __FUNCTION__); 1186 priv->rx_flags |= ACTUALLY_THROTTLED; 1187 spin_unlock_irqrestore(&priv->lock, flags); 1188 return; 1189 } 1190 spin_unlock_irqrestore(&priv->lock, flags); 1191 1192 tty = port->tty; 1193 if (!tty) { 1194 dbg("%s - bad tty pointer - exiting", __FUNCTION__); 1195 return; 1196 } 1197 1198 spin_lock_irqsave(&priv->lock, flags); 1199 switch(urb->actual_length) { 1200 case 32: 1201 /* This is for the CY7C64013... */ 1202 priv->current_status = data[0] & 0xF8; 1203 bytes = data[1] + 2; 1204 i = 2; 1205 if (bytes > 2) 1206 havedata = 1; 1207 break; 1208 case 8: 1209 /* This is for the CY7C63743... */ 1210 priv->current_status = data[0] & 0xF8; 1211 bytes = (data[0] & 0x07) + 1; 1212 i = 1; 1213 if (bytes > 1) 1214 havedata = 1; 1215 break; 1216 default: 1217 dbg("%s - wrong packet size - received %d bytes", 1218 __FUNCTION__, urb->actual_length); 1219 spin_unlock_irqrestore(&priv->lock, flags); 1220 goto continue_read; 1221 } 1222 spin_unlock_irqrestore(&priv->lock, flags); 1223 1224 usb_serial_debug_data (debug, &port->dev, __FUNCTION__, 1225 urb->actual_length, data); 1226 1227 spin_lock_irqsave(&priv->lock, flags); 1228 /* check to see if status has changed */ 1229 if (priv != NULL) { 1230 if (priv->current_status != priv->prev_status) { 1231 priv->diff_status |= priv->current_status ^ 1232 priv->prev_status; 1233 wake_up_interruptible(&priv->delta_msr_wait); 1234 priv->prev_status = priv->current_status; 1235 } 1236 } 1237 spin_unlock_irqrestore(&priv->lock, flags); 1238 1239 /* hangup, as defined in acm.c... this might be a bad place for it 1240 * though */ 1241 if (tty && !(tty->termios->c_cflag & CLOCAL) && 1242 !(priv->current_status & UART_CD)) { 1243 dbg("%s - calling hangup", __FUNCTION__); 1244 tty_hangup(tty); 1245 goto continue_read; 1246 } 1247 1248 /* There is one error bit... I'm assuming it is a parity error 1249 * indicator as the generic firmware will set this bit to 1 if a 1250 * parity error occurs. 1251 * I can not find reference to any other error events. */ 1252 spin_lock_irqsave(&priv->lock, flags); 1253 if (priv->current_status & CYP_ERROR) { 1254 spin_unlock_irqrestore(&priv->lock, flags); 1255 tty_flag = TTY_PARITY; 1256 dbg("%s - Parity Error detected", __FUNCTION__); 1257 } else 1258 spin_unlock_irqrestore(&priv->lock, flags); 1259 1260 /* process read if there is data other than line status */ 1261 if (tty && (bytes > i)) { 1262 for (; i < bytes ; ++i) { 1263 dbg("pushing byte number %d - %d - %c", i, data[i], 1264 data[i]); 1265 if(tty->flip.count >= TTY_FLIPBUF_SIZE) { 1266 tty_flip_buffer_push(tty); 1267 } 1268 tty_insert_flip_char(tty, data[i], tty_flag); 1269 } 1270 tty_flip_buffer_push(port->tty); 1271 } 1272 1273 spin_lock_irqsave(&priv->lock, flags); 1274 /* control and status byte(s) are also counted */ 1275 priv->bytes_in += bytes; 1276 spin_unlock_irqrestore(&priv->lock, flags); 1277 1278 continue_read: 1279 1280 /* Continue trying to always read... unless the port has closed. */ 1281 1282 if (port->open_count > 0) { 1283 usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev, 1284 usb_rcvintpipe(port->serial->dev, 1285 port->interrupt_in_endpointAddress), 1286 port->interrupt_in_urb->transfer_buffer, 1287 port->interrupt_in_urb->transfer_buffer_length, 1288 cypress_read_int_callback, port, interval); 1289 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 1290 if (result) 1291 dev_err(&urb->dev->dev, "%s - failed resubmitting " 1292 "read urb, error %d\n", __FUNCTION__, 1293 result); 1294 } 1295 1296 return; 1297 } /* cypress_read_int_callback */ 1298 1299 1300 static void cypress_write_int_callback(struct urb *urb, struct pt_regs *regs) 1301 { 1302 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 1303 struct cypress_private *priv = usb_get_serial_port_data(port); 1304 int result; 1305 1306 dbg("%s - port %d", __FUNCTION__, port->number); 1307 1308 switch (urb->status) { 1309 case 0: 1310 /* success */ 1311 break; 1312 case -ECONNRESET: 1313 case -ENOENT: 1314 case -ESHUTDOWN: 1315 /* this urb is terminated, clean up */ 1316 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status); 1317 priv->write_urb_in_use = 0; 1318 return; 1319 case -EPIPE: /* no break needed */ 1320 usb_clear_halt(port->serial->dev, 0x02); 1321 default: 1322 /* error in the urb, so we have to resubmit it */ 1323 dbg("%s - Overflow in write", __FUNCTION__); 1324 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status); 1325 port->interrupt_out_urb->transfer_buffer_length = 1; 1326 port->interrupt_out_urb->dev = port->serial->dev; 1327 result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC); 1328 if (result) 1329 dev_err(&urb->dev->dev, "%s - failed resubmitting write urb, error %d\n", 1330 __FUNCTION__, result); 1331 else 1332 return; 1333 } 1334 1335 priv->write_urb_in_use = 0; 1336 1337 /* send any buffered data */ 1338 cypress_send(port); 1339 } 1340 1341 1342 /***************************************************************************** 1343 * Write buffer functions - buffering code from pl2303 used 1344 *****************************************************************************/ 1345 1346 /* 1347 * cypress_buf_alloc 1348 * 1349 * Allocate a circular buffer and all associated memory. 1350 */ 1351 1352 static struct cypress_buf *cypress_buf_alloc(unsigned int size) 1353 { 1354 1355 struct cypress_buf *cb; 1356 1357 1358 if (size == 0) 1359 return NULL; 1360 1361 cb = (struct cypress_buf *)kmalloc(sizeof(struct cypress_buf), GFP_KERNEL); 1362 if (cb == NULL) 1363 return NULL; 1364 1365 cb->buf_buf = kmalloc(size, GFP_KERNEL); 1366 if (cb->buf_buf == NULL) { 1367 kfree(cb); 1368 return NULL; 1369 } 1370 1371 cb->buf_size = size; 1372 cb->buf_get = cb->buf_put = cb->buf_buf; 1373 1374 return cb; 1375 1376 } 1377 1378 1379 /* 1380 * cypress_buf_free 1381 * 1382 * Free the buffer and all associated memory. 1383 */ 1384 1385 static void cypress_buf_free(struct cypress_buf *cb) 1386 { 1387 if (cb) { 1388 kfree(cb->buf_buf); 1389 kfree(cb); 1390 } 1391 } 1392 1393 1394 /* 1395 * cypress_buf_clear 1396 * 1397 * Clear out all data in the circular buffer. 1398 */ 1399 1400 static void cypress_buf_clear(struct cypress_buf *cb) 1401 { 1402 if (cb != NULL) 1403 cb->buf_get = cb->buf_put; 1404 /* equivalent to a get of all data available */ 1405 } 1406 1407 1408 /* 1409 * cypress_buf_data_avail 1410 * 1411 * Return the number of bytes of data available in the circular 1412 * buffer. 1413 */ 1414 1415 static unsigned int cypress_buf_data_avail(struct cypress_buf *cb) 1416 { 1417 if (cb != NULL) 1418 return ((cb->buf_size + cb->buf_put - cb->buf_get) % cb->buf_size); 1419 else 1420 return 0; 1421 } 1422 1423 1424 /* 1425 * cypress_buf_space_avail 1426 * 1427 * Return the number of bytes of space available in the circular 1428 * buffer. 1429 */ 1430 1431 static unsigned int cypress_buf_space_avail(struct cypress_buf *cb) 1432 { 1433 if (cb != NULL) 1434 return ((cb->buf_size + cb->buf_get - cb->buf_put - 1) % cb->buf_size); 1435 else 1436 return 0; 1437 } 1438 1439 1440 /* 1441 * cypress_buf_put 1442 * 1443 * Copy data data from a user buffer and put it into the circular buffer. 1444 * Restrict to the amount of space available. 1445 * 1446 * Return the number of bytes copied. 1447 */ 1448 1449 static unsigned int cypress_buf_put(struct cypress_buf *cb, const char *buf, 1450 unsigned int count) 1451 { 1452 1453 unsigned int len; 1454 1455 1456 if (cb == NULL) 1457 return 0; 1458 1459 len = cypress_buf_space_avail(cb); 1460 if (count > len) 1461 count = len; 1462 1463 if (count == 0) 1464 return 0; 1465 1466 len = cb->buf_buf + cb->buf_size - cb->buf_put; 1467 if (count > len) { 1468 memcpy(cb->buf_put, buf, len); 1469 memcpy(cb->buf_buf, buf+len, count - len); 1470 cb->buf_put = cb->buf_buf + count - len; 1471 } else { 1472 memcpy(cb->buf_put, buf, count); 1473 if (count < len) 1474 cb->buf_put += count; 1475 else /* count == len */ 1476 cb->buf_put = cb->buf_buf; 1477 } 1478 1479 return count; 1480 1481 } 1482 1483 1484 /* 1485 * cypress_buf_get 1486 * 1487 * Get data from the circular buffer and copy to the given buffer. 1488 * Restrict to the amount of data available. 1489 * 1490 * Return the number of bytes copied. 1491 */ 1492 1493 static unsigned int cypress_buf_get(struct cypress_buf *cb, char *buf, 1494 unsigned int count) 1495 { 1496 1497 unsigned int len; 1498 1499 1500 if (cb == NULL) 1501 return 0; 1502 1503 len = cypress_buf_data_avail(cb); 1504 if (count > len) 1505 count = len; 1506 1507 if (count == 0) 1508 return 0; 1509 1510 len = cb->buf_buf + cb->buf_size - cb->buf_get; 1511 if (count > len) { 1512 memcpy(buf, cb->buf_get, len); 1513 memcpy(buf+len, cb->buf_buf, count - len); 1514 cb->buf_get = cb->buf_buf + count - len; 1515 } else { 1516 memcpy(buf, cb->buf_get, count); 1517 if (count < len) 1518 cb->buf_get += count; 1519 else /* count == len */ 1520 cb->buf_get = cb->buf_buf; 1521 } 1522 1523 return count; 1524 1525 } 1526 1527 /***************************************************************************** 1528 * Module functions 1529 *****************************************************************************/ 1530 1531 static int __init cypress_init(void) 1532 { 1533 int retval; 1534 1535 dbg("%s", __FUNCTION__); 1536 1537 retval = usb_serial_register(&cypress_earthmate_device); 1538 if (retval) 1539 goto failed_em_register; 1540 retval = usb_serial_register(&cypress_hidcom_device); 1541 if (retval) 1542 goto failed_hidcom_register; 1543 retval = usb_register(&cypress_driver); 1544 if (retval) 1545 goto failed_usb_register; 1546 1547 info(DRIVER_DESC " " DRIVER_VERSION); 1548 return 0; 1549 failed_usb_register: 1550 usb_deregister(&cypress_driver); 1551 failed_hidcom_register: 1552 usb_serial_deregister(&cypress_hidcom_device); 1553 failed_em_register: 1554 usb_serial_deregister(&cypress_earthmate_device); 1555 1556 return retval; 1557 } 1558 1559 1560 static void __exit cypress_exit (void) 1561 { 1562 dbg("%s", __FUNCTION__); 1563 1564 usb_deregister (&cypress_driver); 1565 usb_serial_deregister (&cypress_earthmate_device); 1566 usb_serial_deregister (&cypress_hidcom_device); 1567 } 1568 1569 1570 module_init(cypress_init); 1571 module_exit(cypress_exit); 1572 1573 MODULE_AUTHOR( DRIVER_AUTHOR ); 1574 MODULE_DESCRIPTION( DRIVER_DESC ); 1575 MODULE_VERSION( DRIVER_VERSION ); 1576 MODULE_LICENSE("GPL"); 1577 1578 module_param(debug, bool, S_IRUGO | S_IWUSR); 1579 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1580 module_param(stats, bool, S_IRUGO | S_IWUSR); 1581 MODULE_PARM_DESC(stats, "Enable statistics or not"); 1582 module_param(interval, int, S_IRUGO | S_IWUSR); 1583 MODULE_PARM_DESC(interval, "Overrides interrupt interval"); 1584