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