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