2 * USB ConnectTech WhiteHEAT driver
7 * Copyright (C) 1999 - 2001
8 * Greg Kroah-Hartman (greg@kroah.com)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * See Documentation/usb/usb-serial.txt for more information on using this driver
17 * (10/09/2002) Stuart MacDonald (stuartm@connecttech.com)
18 * Upgrade to full working driver
21 * switched from using spinlock to a semaphore, which fixes lots of problems.
24 * Identify version on module load.
27 * Fixed MOD_INC and MOD_DEC logic, the ability to open a port more
28 * than once, and the got the proper usb_device_id table entries so
29 * the driver works again.
31 * (11/01/2000) Adam J. Richter
32 * usb_device_id table support
35 * Fixed bug with urb->dev not being set properly, now that the usb
39 * firmware is improved to guard against crap sent to device
40 * firmware now replies CMD_FAILURE on bad things
41 * read_callback fix you provided for private info struct
42 * command_finished now indicates success or fail
43 * setup_port struct now packed to avoid gcc padding
44 * firmware uses 1 based port numbering, driver now handles that
47 * Removed DEBUG #ifdefs with call to usb_serial_debug_data
50 * Added module_init and module_exit functions to handle the fact that this
51 * driver is a loadable module now.
52 * Fixed bug with port->minor that was found by Al Borchers
55 * Added support for port settings. Baud rate can now be changed. Line signals
56 * are not transferred to and from the tty layer yet, but things seem to be
60 * First cut at open and close commands. Data can flow through the ports at
64 * Split driver up into device specific pieces.
68 #include <linux/config.h>
69 #include <linux/kernel.h>
70 #include <linux/errno.h>
71 #include <linux/init.h>
72 #include <linux/slab.h>
73 #include <linux/tty.h>
74 #include <linux/tty_driver.h>
75 #include <linux/tty_flip.h>
76 #include <linux/module.h>
77 #include <linux/spinlock.h>
78 #include <asm/uaccess.h>
79 #include <asm/termbits.h>
80 #include <linux/usb.h>
81 #include <linux/serial_reg.h>
82 #include <linux/serial.h>
83 #include "usb-serial.h"
84 #include "whiteheat_fw.h" /* firmware for the ConnectTech WhiteHEAT device */
85 #include "whiteheat.h" /* WhiteHEAT specific commands */
96 #define DRIVER_VERSION "v2.0"
97 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Stuart MacDonald <stuartm@connecttech.com>"
98 #define DRIVER_DESC "USB ConnectTech WhiteHEAT driver"
100 #define CONNECT_TECH_VENDOR_ID 0x0710
101 #define CONNECT_TECH_FAKE_WHITE_HEAT_ID 0x0001
102 #define CONNECT_TECH_WHITE_HEAT_ID 0x8001
105 ID tables for whiteheat are unusual, because we want to different
106 things for different versions of the device. Eventually, this
107 will be doable from a single table. But, for now, we define two
108 separate ID tables, and then a third table that combines them
109 just for the purpose of exporting the autoloading information.
111 static struct usb_device_id id_table_std
[] = {
112 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
113 { } /* Terminating entry */
116 static struct usb_device_id id_table_prerenumeration
[] = {
117 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
118 { } /* Terminating entry */
121 static struct usb_device_id id_table_combined
[] = {
122 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
123 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
124 { } /* Terminating entry */
127 MODULE_DEVICE_TABLE (usb
, id_table_combined
);
129 static struct usb_driver whiteheat_driver
= {
131 .probe
= usb_serial_probe
,
132 .disconnect
= usb_serial_disconnect
,
133 .id_table
= id_table_combined
,
137 /* function prototypes for the Connect Tech WhiteHEAT prerenumeration device */
138 static int whiteheat_firmware_download (struct usb_serial
*serial
, const struct usb_device_id
*id
);
139 static int whiteheat_firmware_attach (struct usb_serial
*serial
);
141 /* function prototypes for the Connect Tech WhiteHEAT serial converter */
142 static int whiteheat_attach (struct usb_serial
*serial
);
143 static void whiteheat_shutdown (struct usb_serial
*serial
);
144 static int whiteheat_open (struct usb_serial_port
*port
, struct file
*filp
);
145 static void whiteheat_close (struct usb_serial_port
*port
, struct file
*filp
);
146 static int whiteheat_write (struct usb_serial_port
*port
, const unsigned char *buf
, int count
);
147 static int whiteheat_write_room (struct usb_serial_port
*port
);
148 static int whiteheat_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
);
149 static void whiteheat_set_termios (struct usb_serial_port
*port
, struct termios
* old
);
150 static int whiteheat_tiocmget (struct usb_serial_port
*port
, struct file
*file
);
151 static int whiteheat_tiocmset (struct usb_serial_port
*port
, struct file
*file
, unsigned int set
, unsigned int clear
);
152 static void whiteheat_break_ctl (struct usb_serial_port
*port
, int break_state
);
153 static int whiteheat_chars_in_buffer (struct usb_serial_port
*port
);
154 static void whiteheat_throttle (struct usb_serial_port
*port
);
155 static void whiteheat_unthrottle (struct usb_serial_port
*port
);
156 static void whiteheat_read_callback (struct urb
*urb
, struct pt_regs
*regs
);
157 static void whiteheat_write_callback (struct urb
*urb
, struct pt_regs
*regs
);
159 static struct usb_serial_driver whiteheat_fake_device
= {
161 .owner
= THIS_MODULE
,
162 .name
= "whiteheatnofirm",
164 .description
= "Connect Tech - WhiteHEAT - (prerenumeration)",
165 .id_table
= id_table_prerenumeration
,
166 .num_interrupt_in
= NUM_DONT_CARE
,
167 .num_bulk_in
= NUM_DONT_CARE
,
168 .num_bulk_out
= NUM_DONT_CARE
,
170 .probe
= whiteheat_firmware_download
,
171 .attach
= whiteheat_firmware_attach
,
174 static struct usb_serial_driver whiteheat_device
= {
176 .owner
= THIS_MODULE
,
179 .description
= "Connect Tech - WhiteHEAT",
180 .id_table
= id_table_std
,
181 .num_interrupt_in
= NUM_DONT_CARE
,
182 .num_bulk_in
= NUM_DONT_CARE
,
183 .num_bulk_out
= NUM_DONT_CARE
,
185 .attach
= whiteheat_attach
,
186 .shutdown
= whiteheat_shutdown
,
187 .open
= whiteheat_open
,
188 .close
= whiteheat_close
,
189 .write
= whiteheat_write
,
190 .write_room
= whiteheat_write_room
,
191 .ioctl
= whiteheat_ioctl
,
192 .set_termios
= whiteheat_set_termios
,
193 .break_ctl
= whiteheat_break_ctl
,
194 .tiocmget
= whiteheat_tiocmget
,
195 .tiocmset
= whiteheat_tiocmset
,
196 .chars_in_buffer
= whiteheat_chars_in_buffer
,
197 .throttle
= whiteheat_throttle
,
198 .unthrottle
= whiteheat_unthrottle
,
199 .read_bulk_callback
= whiteheat_read_callback
,
200 .write_bulk_callback
= whiteheat_write_callback
,
204 struct whiteheat_command_private
{
207 __u8 command_finished
;
208 wait_queue_head_t wait_command
; /* for handling sleeping while waiting for a command to finish */
209 __u8 result_buffer
[64];
213 #define THROTTLED 0x01
214 #define ACTUALLY_THROTTLED 0x02
216 static int urb_pool_size
= 8;
218 struct whiteheat_urb_wrap
{
219 struct list_head list
;
223 struct whiteheat_private
{
227 struct list_head rx_urbs_free
;
228 struct list_head rx_urbs_submitted
;
229 struct list_head rx_urb_q
;
230 struct work_struct rx_work
;
231 struct list_head tx_urbs_free
;
232 struct list_head tx_urbs_submitted
;
236 /* local function prototypes */
237 static int start_command_port(struct usb_serial
*serial
);
238 static void stop_command_port(struct usb_serial
*serial
);
239 static void command_port_write_callback(struct urb
*urb
, struct pt_regs
*regs
);
240 static void command_port_read_callback(struct urb
*urb
, struct pt_regs
*regs
);
242 static int start_port_read(struct usb_serial_port
*port
);
243 static struct whiteheat_urb_wrap
*urb_to_wrap(struct urb
*urb
, struct list_head
*head
);
244 static struct list_head
*list_first(struct list_head
*head
);
245 static void rx_data_softint(void *private);
247 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
, __u8
*data
, __u8 datasize
);
248 static int firm_open(struct usb_serial_port
*port
);
249 static int firm_close(struct usb_serial_port
*port
);
250 static int firm_setup_port(struct usb_serial_port
*port
);
251 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
);
252 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
);
253 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
);
254 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
);
255 static int firm_get_dtr_rts(struct usb_serial_port
*port
);
256 static int firm_report_tx_done(struct usb_serial_port
*port
);
259 #define COMMAND_PORT 4
260 #define COMMAND_TIMEOUT (2*HZ) /* 2 second timeout for a command */
261 #define COMMAND_TIMEOUT_MS 2000
262 #define CLOSING_DELAY (30 * HZ)
265 /*****************************************************************************
266 * Connect Tech's White Heat prerenumeration driver functions
267 *****************************************************************************/
269 /* steps to download the firmware to the WhiteHEAT device:
270 - hold the reset (by writing to the reset bit of the CPUCS register)
271 - download the VEND_AX.HEX file to the chip using VENDOR_REQUEST-ANCHOR_LOAD
272 - release the reset (by writing to the CPUCS register)
273 - download the WH.HEX file for all addresses greater than 0x1b3f using
274 VENDOR_REQUEST-ANCHOR_EXTERNAL_RAM_LOAD
276 - download the WH.HEX file for all addresses less than 0x1b40 using
277 VENDOR_REQUEST_ANCHOR_LOAD
279 - device renumerated itself and comes up as new device id with all
280 firmware download completed.
282 static int whiteheat_firmware_download (struct usb_serial
*serial
, const struct usb_device_id
*id
)
285 const struct whiteheat_hex_record
*record
;
287 dbg("%s", __FUNCTION__
);
289 response
= ezusb_set_reset (serial
, 1);
291 record
= &whiteheat_loader
[0];
292 while (record
->address
!= 0xffff) {
293 response
= ezusb_writememory (serial
, record
->address
,
294 (unsigned char *)record
->data
, record
->data_size
, 0xa0);
296 err("%s - ezusb_writememory failed for loader (%d %04X %p %d)",
297 __FUNCTION__
, response
, record
->address
, record
->data
, record
->data_size
);
303 response
= ezusb_set_reset (serial
, 0);
305 record
= &whiteheat_firmware
[0];
306 while (record
->address
< 0x1b40) {
309 while (record
->address
!= 0xffff) {
310 response
= ezusb_writememory (serial
, record
->address
,
311 (unsigned char *)record
->data
, record
->data_size
, 0xa3);
313 err("%s - ezusb_writememory failed for first firmware step (%d %04X %p %d)",
314 __FUNCTION__
, response
, record
->address
, record
->data
, record
->data_size
);
320 response
= ezusb_set_reset (serial
, 1);
322 record
= &whiteheat_firmware
[0];
323 while (record
->address
< 0x1b40) {
324 response
= ezusb_writememory (serial
, record
->address
,
325 (unsigned char *)record
->data
, record
->data_size
, 0xa0);
327 err("%s - ezusb_writememory failed for second firmware step (%d %04X %p %d)",
328 __FUNCTION__
, response
, record
->address
, record
->data
, record
->data_size
);
334 response
= ezusb_set_reset (serial
, 0);
340 static int whiteheat_firmware_attach (struct usb_serial
*serial
)
342 /* We want this device to fail to have a driver assigned to it */
347 /*****************************************************************************
348 * Connect Tech's White Heat serial driver functions
349 *****************************************************************************/
350 static int whiteheat_attach (struct usb_serial
*serial
)
352 struct usb_serial_port
*command_port
;
353 struct whiteheat_command_private
*command_info
;
354 struct usb_serial_port
*port
;
355 struct whiteheat_private
*info
;
356 struct whiteheat_hw_info
*hw_info
;
366 struct whiteheat_urb_wrap
*wrap
;
367 struct list_head
*tmp
;
369 command_port
= serial
->port
[COMMAND_PORT
];
371 pipe
= usb_sndbulkpipe (serial
->dev
, command_port
->bulk_out_endpointAddress
);
372 command
= kmalloc(2, GFP_KERNEL
);
374 goto no_command_buffer
;
375 command
[0] = WHITEHEAT_GET_HW_INFO
;
378 result
= kmalloc(sizeof(*hw_info
) + 1, GFP_KERNEL
);
380 goto no_result_buffer
;
382 * When the module is reloaded the firmware is still there and
383 * the endpoints are still in the usb core unchanged. This is the
384 * unlinking bug in disguise. Same for the call below.
386 usb_clear_halt(serial
->dev
, pipe
);
387 ret
= usb_bulk_msg (serial
->dev
, pipe
, command
, 2, &alen
, COMMAND_TIMEOUT_MS
);
389 err("%s: Couldn't send command [%d]", serial
->type
->description
, ret
);
391 } else if (alen
!= sizeof(command
)) {
392 err("%s: Send command incomplete [%d]", serial
->type
->description
, alen
);
396 pipe
= usb_rcvbulkpipe (serial
->dev
, command_port
->bulk_in_endpointAddress
);
397 /* See the comment on the usb_clear_halt() above */
398 usb_clear_halt(serial
->dev
, pipe
);
399 ret
= usb_bulk_msg (serial
->dev
, pipe
, result
, sizeof(*hw_info
) + 1, &alen
, COMMAND_TIMEOUT_MS
);
401 err("%s: Couldn't get results [%d]", serial
->type
->description
, ret
);
403 } else if (alen
!= sizeof(result
)) {
404 err("%s: Get results incomplete [%d]", serial
->type
->description
, alen
);
406 } else if (result
[0] != command
[0]) {
407 err("%s: Command failed [%d]", serial
->type
->description
, result
[0]);
411 hw_info
= (struct whiteheat_hw_info
*)&result
[1];
413 info("%s: Driver %s: Firmware v%d.%02d", serial
->type
->description
,
414 DRIVER_VERSION
, hw_info
->sw_major_rev
, hw_info
->sw_minor_rev
);
416 for (i
= 0; i
< serial
->num_ports
; i
++) {
417 port
= serial
->port
[i
];
419 info
= (struct whiteheat_private
*)kmalloc(sizeof(struct whiteheat_private
), GFP_KERNEL
);
421 err("%s: Out of memory for port structures\n", serial
->type
->description
);
425 spin_lock_init(&info
->lock
);
428 INIT_WORK(&info
->rx_work
, rx_data_softint
, port
);
430 INIT_LIST_HEAD(&info
->rx_urbs_free
);
431 INIT_LIST_HEAD(&info
->rx_urbs_submitted
);
432 INIT_LIST_HEAD(&info
->rx_urb_q
);
433 INIT_LIST_HEAD(&info
->tx_urbs_free
);
434 INIT_LIST_HEAD(&info
->tx_urbs_submitted
);
436 for (j
= 0; j
< urb_pool_size
; j
++) {
437 urb
= usb_alloc_urb(0, GFP_KERNEL
);
439 err("No free urbs available");
442 buf_size
= port
->read_urb
->transfer_buffer_length
;
443 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
444 if (!urb
->transfer_buffer
) {
445 err("Couldn't allocate urb buffer");
448 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
450 err("Couldn't allocate urb wrapper");
453 usb_fill_bulk_urb(urb
, serial
->dev
,
454 usb_rcvbulkpipe(serial
->dev
,
455 port
->bulk_in_endpointAddress
),
456 urb
->transfer_buffer
, buf_size
,
457 whiteheat_read_callback
, port
);
459 list_add(&wrap
->list
, &info
->rx_urbs_free
);
461 urb
= usb_alloc_urb(0, GFP_KERNEL
);
463 err("No free urbs available");
466 buf_size
= port
->write_urb
->transfer_buffer_length
;
467 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
468 if (!urb
->transfer_buffer
) {
469 err("Couldn't allocate urb buffer");
472 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
474 err("Couldn't allocate urb wrapper");
477 usb_fill_bulk_urb(urb
, serial
->dev
,
478 usb_sndbulkpipe(serial
->dev
,
479 port
->bulk_out_endpointAddress
),
480 urb
->transfer_buffer
, buf_size
,
481 whiteheat_write_callback
, port
);
483 list_add(&wrap
->list
, &info
->tx_urbs_free
);
486 usb_set_serial_port_data(port
, info
);
489 command_info
= (struct whiteheat_command_private
*)kmalloc(sizeof(struct whiteheat_command_private
), GFP_KERNEL
);
490 if (command_info
== NULL
) {
491 err("%s: Out of memory for port structures\n", serial
->type
->description
);
492 goto no_command_private
;
495 spin_lock_init(&command_info
->lock
);
496 command_info
->port_running
= 0;
497 init_waitqueue_head(&command_info
->wait_command
);
498 usb_set_serial_port_data(command_port
, command_info
);
499 command_port
->write_urb
->complete
= command_port_write_callback
;
500 command_port
->read_urb
->complete
= command_port_read_callback
;
507 /* Firmware likely not running */
508 err("%s: Unable to retrieve firmware version, try replugging\n", serial
->type
->description
);
509 err("%s: If the firmware is not running (status led not blinking)\n", serial
->type
->description
);
510 err("%s: please contact support@connecttech.com\n", serial
->type
->description
);
515 for (i
= serial
->num_ports
- 1; i
>= 0; i
--) {
516 port
= serial
->port
[i
];
517 info
= usb_get_serial_port_data(port
);
518 for (j
= urb_pool_size
- 1; j
>= 0; j
--) {
519 tmp
= list_first(&info
->tx_urbs_free
);
521 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
525 kfree(urb
->transfer_buffer
);
529 tmp
= list_first(&info
->rx_urbs_free
);
531 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
535 kfree(urb
->transfer_buffer
);
553 static void whiteheat_shutdown (struct usb_serial
*serial
)
555 struct usb_serial_port
*command_port
;
556 struct usb_serial_port
*port
;
557 struct whiteheat_private
*info
;
558 struct whiteheat_urb_wrap
*wrap
;
560 struct list_head
*tmp
;
561 struct list_head
*tmp2
;
564 dbg("%s", __FUNCTION__
);
566 /* free up our private data for our command port */
567 command_port
= serial
->port
[COMMAND_PORT
];
568 kfree (usb_get_serial_port_data(command_port
));
570 for (i
= 0; i
< serial
->num_ports
; i
++) {
571 port
= serial
->port
[i
];
572 info
= usb_get_serial_port_data(port
);
573 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
575 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
578 kfree(urb
->transfer_buffer
);
581 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_free
) {
583 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
586 kfree(urb
->transfer_buffer
);
596 static int whiteheat_open (struct usb_serial_port
*port
, struct file
*filp
)
599 struct termios old_term
;
601 dbg("%s - port %d", __FUNCTION__
, port
->number
);
603 retval
= start_command_port(port
->serial
);
608 port
->tty
->low_latency
= 1;
610 /* send an open port command */
611 retval
= firm_open(port
);
613 stop_command_port(port
->serial
);
617 retval
= firm_purge(port
, WHITEHEAT_PURGE_RX
| WHITEHEAT_PURGE_TX
);
620 stop_command_port(port
->serial
);
624 old_term
.c_cflag
= ~port
->tty
->termios
->c_cflag
;
625 old_term
.c_iflag
= ~port
->tty
->termios
->c_iflag
;
626 whiteheat_set_termios(port
, &old_term
);
628 /* Work around HCD bugs */
629 usb_clear_halt(port
->serial
->dev
, port
->read_urb
->pipe
);
630 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
632 /* Start reading from the device */
633 retval
= start_port_read(port
);
635 err("%s - failed submitting read urb, error %d", __FUNCTION__
, retval
);
637 stop_command_port(port
->serial
);
642 dbg("%s - exit, retval = %d", __FUNCTION__
, retval
);
647 static void whiteheat_close(struct usb_serial_port
*port
, struct file
* filp
)
649 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
650 struct whiteheat_urb_wrap
*wrap
;
652 struct list_head
*tmp
;
653 struct list_head
*tmp2
;
656 dbg("%s - port %d", __FUNCTION__
, port
->number
);
658 /* filp is NULL when called from usb_serial_disconnect */
659 if (filp
&& (tty_hung_up_p(filp
))) {
663 port
->tty
->closing
= 1;
666 * Not currently in use; tty_wait_until_sent() calls
667 * serial_chars_in_buffer() which deadlocks on the second semaphore
668 * acquisition. This should be fixed at some point. Greg's been
670 if ((filp->f_flags & (O_NDELAY | O_NONBLOCK)) == 0) {
671 tty_wait_until_sent(port->tty, CLOSING_DELAY);
675 if (port
->tty
->driver
->flush_buffer
)
676 port
->tty
->driver
->flush_buffer(port
->tty
);
677 tty_ldisc_flush(port
->tty
);
679 firm_report_tx_done(port
);
683 /* shutdown our bulk reads and writes */
684 spin_lock_irqsave(&info
->lock
, flags
);
685 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
686 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
690 list_add(tmp
, &info
->rx_urbs_free
);
692 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
) {
694 list_add(tmp
, &info
->rx_urbs_free
);
696 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_submitted
) {
697 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
701 list_add(tmp
, &info
->tx_urbs_free
);
703 spin_unlock_irqrestore(&info
->lock
, flags
);
705 stop_command_port(port
->serial
);
707 port
->tty
->closing
= 0;
711 static int whiteheat_write(struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
713 struct usb_serial
*serial
= port
->serial
;
714 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
715 struct whiteheat_urb_wrap
*wrap
;
721 struct list_head
*tmp
;
723 dbg("%s - port %d", __FUNCTION__
, port
->number
);
726 dbg("%s - write request of 0 bytes", __FUNCTION__
);
731 spin_lock_irqsave(&info
->lock
, flags
);
732 if (list_empty(&info
->tx_urbs_free
)) {
733 spin_unlock_irqrestore(&info
->lock
, flags
);
736 tmp
= list_first(&info
->tx_urbs_free
);
738 spin_unlock_irqrestore(&info
->lock
, flags
);
740 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
742 bytes
= (count
> port
->bulk_out_size
) ? port
->bulk_out_size
: count
;
743 memcpy (urb
->transfer_buffer
, buf
+ sent
, bytes
);
745 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, bytes
, urb
->transfer_buffer
);
747 urb
->dev
= serial
->dev
;
748 urb
->transfer_buffer_length
= bytes
;
749 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
751 err("%s - failed submitting write urb, error %d", __FUNCTION__
, result
);
753 spin_lock_irqsave(&info
->lock
, flags
);
754 list_add(tmp
, &info
->tx_urbs_free
);
755 spin_unlock_irqrestore(&info
->lock
, flags
);
760 spin_lock_irqsave(&info
->lock
, flags
);
761 list_add(tmp
, &info
->tx_urbs_submitted
);
762 spin_unlock_irqrestore(&info
->lock
, flags
);
770 static int whiteheat_write_room(struct usb_serial_port
*port
)
772 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
773 struct list_head
*tmp
;
777 dbg("%s - port %d", __FUNCTION__
, port
->number
);
779 spin_lock_irqsave(&info
->lock
, flags
);
780 list_for_each(tmp
, &info
->tx_urbs_free
)
782 spin_unlock_irqrestore(&info
->lock
, flags
);
783 room
*= port
->bulk_out_size
;
785 dbg("%s - returns %d", __FUNCTION__
, room
);
790 static int whiteheat_tiocmget (struct usb_serial_port
*port
, struct file
*file
)
792 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
793 unsigned int modem_signals
= 0;
795 dbg("%s - port %d", __FUNCTION__
, port
->number
);
797 firm_get_dtr_rts(port
);
798 if (info
->mcr
& UART_MCR_DTR
)
799 modem_signals
|= TIOCM_DTR
;
800 if (info
->mcr
& UART_MCR_RTS
)
801 modem_signals
|= TIOCM_RTS
;
803 return modem_signals
;
807 static int whiteheat_tiocmset (struct usb_serial_port
*port
, struct file
*file
,
808 unsigned int set
, unsigned int clear
)
810 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
812 dbg("%s - port %d", __FUNCTION__
, port
->number
);
815 info
->mcr
|= UART_MCR_RTS
;
817 info
->mcr
|= UART_MCR_DTR
;
819 if (clear
& TIOCM_RTS
)
820 info
->mcr
&= ~UART_MCR_RTS
;
821 if (clear
& TIOCM_DTR
)
822 info
->mcr
&= ~UART_MCR_DTR
;
824 firm_set_dtr(port
, info
->mcr
& UART_MCR_DTR
);
825 firm_set_rts(port
, info
->mcr
& UART_MCR_RTS
);
830 static int whiteheat_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
)
832 struct serial_struct serstruct
;
833 void __user
*user_arg
= (void __user
*)arg
;
835 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__
, port
->number
, cmd
);
839 memset(&serstruct
, 0, sizeof(serstruct
));
840 serstruct
.type
= PORT_16654
;
841 serstruct
.line
= port
->serial
->minor
;
842 serstruct
.port
= port
->number
;
843 serstruct
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
844 serstruct
.xmit_fifo_size
= port
->bulk_out_size
;
845 serstruct
.custom_divisor
= 0;
846 serstruct
.baud_base
= 460800;
847 serstruct
.close_delay
= CLOSING_DELAY
;
848 serstruct
.closing_wait
= CLOSING_DELAY
;
850 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
856 if (copy_from_user(&serstruct
, user_arg
, sizeof(serstruct
)))
860 * For now this is ignored. dip sets the ASYNC_[V]HI flags
861 * but this isn't used by us at all. Maybe someone somewhere
862 * will need the custom_divisor setting.
875 static void whiteheat_set_termios (struct usb_serial_port
*port
, struct termios
*old_termios
)
877 dbg("%s -port %d", __FUNCTION__
, port
->number
);
879 if ((!port
->tty
) || (!port
->tty
->termios
)) {
880 dbg("%s - no tty structures", __FUNCTION__
);
884 /* check that they really want us to change something */
886 if ((port
->tty
->termios
->c_cflag
== old_termios
->c_cflag
) &&
887 (port
->tty
->termios
->c_iflag
== old_termios
->c_iflag
)) {
888 dbg("%s - nothing to change...", __FUNCTION__
);
893 firm_setup_port(port
);
900 static void whiteheat_break_ctl(struct usb_serial_port
*port
, int break_state
) {
901 firm_set_break(port
, break_state
);
905 static int whiteheat_chars_in_buffer(struct usb_serial_port
*port
)
907 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
908 struct list_head
*tmp
;
909 struct whiteheat_urb_wrap
*wrap
;
913 dbg("%s - port %d", __FUNCTION__
, port
->number
);
915 spin_lock_irqsave(&info
->lock
, flags
);
916 list_for_each(tmp
, &info
->tx_urbs_submitted
) {
917 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
918 chars
+= wrap
->urb
->transfer_buffer_length
;
920 spin_unlock_irqrestore(&info
->lock
, flags
);
922 dbg ("%s - returns %d", __FUNCTION__
, chars
);
927 static void whiteheat_throttle (struct usb_serial_port
*port
)
929 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
932 dbg("%s - port %d", __FUNCTION__
, port
->number
);
934 spin_lock_irqsave(&info
->lock
, flags
);
935 info
->flags
|= THROTTLED
;
936 spin_unlock_irqrestore(&info
->lock
, flags
);
942 static void whiteheat_unthrottle (struct usb_serial_port
*port
)
944 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
945 int actually_throttled
;
948 dbg("%s - port %d", __FUNCTION__
, port
->number
);
950 spin_lock_irqsave(&info
->lock
, flags
);
951 actually_throttled
= info
->flags
& ACTUALLY_THROTTLED
;
952 info
->flags
&= ~(THROTTLED
| ACTUALLY_THROTTLED
);
953 spin_unlock_irqrestore(&info
->lock
, flags
);
955 if (actually_throttled
)
956 rx_data_softint(port
);
962 /*****************************************************************************
963 * Connect Tech's White Heat callback routines
964 *****************************************************************************/
965 static void command_port_write_callback (struct urb
*urb
, struct pt_regs
*regs
)
967 dbg("%s", __FUNCTION__
);
970 dbg ("nonzero urb status: %d", urb
->status
);
976 static void command_port_read_callback (struct urb
*urb
, struct pt_regs
*regs
)
978 struct usb_serial_port
*command_port
= (struct usb_serial_port
*)urb
->context
;
979 struct whiteheat_command_private
*command_info
;
980 unsigned char *data
= urb
->transfer_buffer
;
984 dbg("%s", __FUNCTION__
);
987 dbg("%s - nonzero urb status: %d", __FUNCTION__
, urb
->status
);
991 usb_serial_debug_data(debug
, &command_port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
993 command_info
= usb_get_serial_port_data(command_port
);
995 dbg ("%s - command_info is NULL, exiting.", __FUNCTION__
);
998 spin_lock_irqsave(&command_info
->lock
, flags
);
1000 if (data
[0] == WHITEHEAT_CMD_COMPLETE
) {
1001 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
1002 wake_up_interruptible(&command_info
->wait_command
);
1003 } else if (data
[0] == WHITEHEAT_CMD_FAILURE
) {
1004 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
1005 wake_up_interruptible(&command_info
->wait_command
);
1006 } else if (data
[0] == WHITEHEAT_EVENT
) {
1007 /* These are unsolicited reports from the firmware, hence no waiting command to wakeup */
1008 dbg("%s - event received", __FUNCTION__
);
1009 } else if (data
[0] == WHITEHEAT_GET_DTR_RTS
) {
1010 memcpy(command_info
->result_buffer
, &data
[1], urb
->actual_length
- 1);
1011 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
1012 wake_up_interruptible(&command_info
->wait_command
);
1014 dbg("%s - bad reply from firmware", __FUNCTION__
);
1017 /* Continue trying to always read */
1018 command_port
->read_urb
->dev
= command_port
->serial
->dev
;
1019 result
= usb_submit_urb(command_port
->read_urb
, GFP_ATOMIC
);
1020 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1022 dbg("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
1026 static void whiteheat_read_callback(struct urb
*urb
, struct pt_regs
*regs
)
1028 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1029 struct whiteheat_urb_wrap
*wrap
;
1030 unsigned char *data
= urb
->transfer_buffer
;
1031 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1033 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1035 spin_lock(&info
->lock
);
1036 wrap
= urb_to_wrap(urb
, &info
->rx_urbs_submitted
);
1038 spin_unlock(&info
->lock
);
1039 err("%s - Not my urb!", __FUNCTION__
);
1042 list_del(&wrap
->list
);
1043 spin_unlock(&info
->lock
);
1046 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__
, urb
->status
);
1047 spin_lock(&info
->lock
);
1048 list_add(&wrap
->list
, &info
->rx_urbs_free
);
1049 spin_unlock(&info
->lock
);
1053 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
1055 spin_lock(&info
->lock
);
1056 list_add_tail(&wrap
->list
, &info
->rx_urb_q
);
1057 if (info
->flags
& THROTTLED
) {
1058 info
->flags
|= ACTUALLY_THROTTLED
;
1059 spin_unlock(&info
->lock
);
1062 spin_unlock(&info
->lock
);
1064 schedule_work(&info
->rx_work
);
1068 static void whiteheat_write_callback(struct urb
*urb
, struct pt_regs
*regs
)
1070 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1071 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1072 struct whiteheat_urb_wrap
*wrap
;
1074 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1076 spin_lock(&info
->lock
);
1077 wrap
= urb_to_wrap(urb
, &info
->tx_urbs_submitted
);
1079 spin_unlock(&info
->lock
);
1080 err("%s - Not my urb!", __FUNCTION__
);
1083 list_del(&wrap
->list
);
1084 list_add(&wrap
->list
, &info
->tx_urbs_free
);
1085 spin_unlock(&info
->lock
);
1088 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__
, urb
->status
);
1092 usb_serial_port_softint((void *)port
);
1094 schedule_work(&port
->work
);
1098 /*****************************************************************************
1099 * Connect Tech's White Heat firmware interface
1100 *****************************************************************************/
1101 static int firm_send_command (struct usb_serial_port
*port
, __u8 command
, __u8
*data
, __u8 datasize
)
1103 struct usb_serial_port
*command_port
;
1104 struct whiteheat_command_private
*command_info
;
1105 struct whiteheat_private
*info
;
1106 __u8
*transfer_buffer
;
1108 unsigned long flags
;
1110 dbg("%s - command %d", __FUNCTION__
, command
);
1112 command_port
= port
->serial
->port
[COMMAND_PORT
];
1113 command_info
= usb_get_serial_port_data(command_port
);
1114 spin_lock_irqsave(&command_info
->lock
, flags
);
1115 command_info
->command_finished
= FALSE
;
1117 transfer_buffer
= (__u8
*)command_port
->write_urb
->transfer_buffer
;
1118 transfer_buffer
[0] = command
;
1119 memcpy (&transfer_buffer
[1], data
, datasize
);
1120 command_port
->write_urb
->transfer_buffer_length
= datasize
+ 1;
1121 command_port
->write_urb
->dev
= port
->serial
->dev
;
1122 retval
= usb_submit_urb (command_port
->write_urb
, GFP_KERNEL
);
1124 dbg("%s - submit urb failed", __FUNCTION__
);
1127 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1129 /* wait for the command to complete */
1130 wait_event_interruptible_timeout(command_info
->wait_command
,
1131 (command_info
->command_finished
!= FALSE
), COMMAND_TIMEOUT
);
1133 spin_lock_irqsave(&command_info
->lock
, flags
);
1135 if (command_info
->command_finished
== FALSE
) {
1136 dbg("%s - command timed out.", __FUNCTION__
);
1137 retval
= -ETIMEDOUT
;
1141 if (command_info
->command_finished
== WHITEHEAT_CMD_FAILURE
) {
1142 dbg("%s - command failed.", __FUNCTION__
);
1147 if (command_info
->command_finished
== WHITEHEAT_CMD_COMPLETE
) {
1148 dbg("%s - command completed.", __FUNCTION__
);
1150 case WHITEHEAT_GET_DTR_RTS
:
1151 info
= usb_get_serial_port_data(port
);
1152 memcpy(&info
->mcr
, command_info
->result_buffer
, sizeof(struct whiteheat_dr_info
));
1158 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1163 static int firm_open(struct usb_serial_port
*port
) {
1164 struct whiteheat_simple open_command
;
1166 open_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1167 return firm_send_command(port
, WHITEHEAT_OPEN
, (__u8
*)&open_command
, sizeof(open_command
));
1171 static int firm_close(struct usb_serial_port
*port
) {
1172 struct whiteheat_simple close_command
;
1174 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1175 return firm_send_command(port
, WHITEHEAT_CLOSE
, (__u8
*)&close_command
, sizeof(close_command
));
1179 static int firm_setup_port(struct usb_serial_port
*port
) {
1180 struct whiteheat_port_settings port_settings
;
1181 unsigned int cflag
= port
->tty
->termios
->c_cflag
;
1183 port_settings
.port
= port
->number
+ 1;
1185 /* get the byte size */
1186 switch (cflag
& CSIZE
) {
1187 case CS5
: port_settings
.bits
= 5; break;
1188 case CS6
: port_settings
.bits
= 6; break;
1189 case CS7
: port_settings
.bits
= 7; break;
1191 case CS8
: port_settings
.bits
= 8; break;
1193 dbg("%s - data bits = %d", __FUNCTION__
, port_settings
.bits
);
1195 /* determine the parity */
1199 port_settings
.parity
= WHITEHEAT_PAR_MARK
;
1201 port_settings
.parity
= WHITEHEAT_PAR_SPACE
;
1204 port_settings
.parity
= WHITEHEAT_PAR_ODD
;
1206 port_settings
.parity
= WHITEHEAT_PAR_EVEN
;
1208 port_settings
.parity
= WHITEHEAT_PAR_NONE
;
1209 dbg("%s - parity = %c", __FUNCTION__
, port_settings
.parity
);
1211 /* figure out the stop bits requested */
1213 port_settings
.stop
= 2;
1215 port_settings
.stop
= 1;
1216 dbg("%s - stop bits = %d", __FUNCTION__
, port_settings
.stop
);
1218 /* figure out the flow control settings */
1219 if (cflag
& CRTSCTS
)
1220 port_settings
.hflow
= (WHITEHEAT_HFLOW_CTS
| WHITEHEAT_HFLOW_RTS
);
1222 port_settings
.hflow
= WHITEHEAT_HFLOW_NONE
;
1223 dbg("%s - hardware flow control = %s %s %s %s", __FUNCTION__
,
1224 (port_settings
.hflow
& WHITEHEAT_HFLOW_CTS
) ? "CTS" : "",
1225 (port_settings
.hflow
& WHITEHEAT_HFLOW_RTS
) ? "RTS" : "",
1226 (port_settings
.hflow
& WHITEHEAT_HFLOW_DSR
) ? "DSR" : "",
1227 (port_settings
.hflow
& WHITEHEAT_HFLOW_DTR
) ? "DTR" : "");
1229 /* determine software flow control */
1230 if (I_IXOFF(port
->tty
))
1231 port_settings
.sflow
= WHITEHEAT_SFLOW_RXTX
;
1233 port_settings
.sflow
= WHITEHEAT_SFLOW_NONE
;
1234 dbg("%s - software flow control = %c", __FUNCTION__
, port_settings
.sflow
);
1236 port_settings
.xon
= START_CHAR(port
->tty
);
1237 port_settings
.xoff
= STOP_CHAR(port
->tty
);
1238 dbg("%s - XON = %2x, XOFF = %2x", __FUNCTION__
, port_settings
.xon
, port_settings
.xoff
);
1240 /* get the baud rate wanted */
1241 port_settings
.baud
= tty_get_baud_rate(port
->tty
);
1242 dbg("%s - baud rate = %d", __FUNCTION__
, port_settings
.baud
);
1244 /* handle any settings that aren't specified in the tty structure */
1245 port_settings
.lloop
= 0;
1247 /* now send the message to the device */
1248 return firm_send_command(port
, WHITEHEAT_SETUP_PORT
, (__u8
*)&port_settings
, sizeof(port_settings
));
1252 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
) {
1253 struct whiteheat_set_rdb rts_command
;
1255 rts_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1256 rts_command
.state
= onoff
;
1257 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&rts_command
, sizeof(rts_command
));
1261 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
) {
1262 struct whiteheat_set_rdb dtr_command
;
1264 dtr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1265 dtr_command
.state
= onoff
;
1266 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&dtr_command
, sizeof(dtr_command
));
1270 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
) {
1271 struct whiteheat_set_rdb break_command
;
1273 break_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1274 break_command
.state
= onoff
;
1275 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&break_command
, sizeof(break_command
));
1279 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
) {
1280 struct whiteheat_purge purge_command
;
1282 purge_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1283 purge_command
.what
= rxtx
;
1284 return firm_send_command(port
, WHITEHEAT_PURGE
, (__u8
*)&purge_command
, sizeof(purge_command
));
1288 static int firm_get_dtr_rts(struct usb_serial_port
*port
) {
1289 struct whiteheat_simple get_dr_command
;
1291 get_dr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1292 return firm_send_command(port
, WHITEHEAT_GET_DTR_RTS
, (__u8
*)&get_dr_command
, sizeof(get_dr_command
));
1296 static int firm_report_tx_done(struct usb_serial_port
*port
) {
1297 struct whiteheat_simple close_command
;
1299 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1300 return firm_send_command(port
, WHITEHEAT_REPORT_TX_DONE
, (__u8
*)&close_command
, sizeof(close_command
));
1304 /*****************************************************************************
1305 * Connect Tech's White Heat utility functions
1306 *****************************************************************************/
1307 static int start_command_port(struct usb_serial
*serial
)
1309 struct usb_serial_port
*command_port
;
1310 struct whiteheat_command_private
*command_info
;
1311 unsigned long flags
;
1314 command_port
= serial
->port
[COMMAND_PORT
];
1315 command_info
= usb_get_serial_port_data(command_port
);
1316 spin_lock_irqsave(&command_info
->lock
, flags
);
1317 if (!command_info
->port_running
) {
1318 /* Work around HCD bugs */
1319 usb_clear_halt(serial
->dev
, command_port
->read_urb
->pipe
);
1321 command_port
->read_urb
->dev
= serial
->dev
;
1322 retval
= usb_submit_urb(command_port
->read_urb
, GFP_KERNEL
);
1324 err("%s - failed submitting read urb, error %d", __FUNCTION__
, retval
);
1328 command_info
->port_running
++;
1331 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1336 static void stop_command_port(struct usb_serial
*serial
)
1338 struct usb_serial_port
*command_port
;
1339 struct whiteheat_command_private
*command_info
;
1340 unsigned long flags
;
1342 command_port
= serial
->port
[COMMAND_PORT
];
1343 command_info
= usb_get_serial_port_data(command_port
);
1344 spin_lock_irqsave(&command_info
->lock
, flags
);
1345 command_info
->port_running
--;
1346 if (!command_info
->port_running
)
1347 usb_kill_urb(command_port
->read_urb
);
1348 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1352 static int start_port_read(struct usb_serial_port
*port
)
1354 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1355 struct whiteheat_urb_wrap
*wrap
;
1358 unsigned long flags
;
1359 struct list_head
*tmp
;
1360 struct list_head
*tmp2
;
1362 spin_lock_irqsave(&info
->lock
, flags
);
1364 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
1366 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1368 urb
->dev
= port
->serial
->dev
;
1369 retval
= usb_submit_urb(urb
, GFP_KERNEL
);
1371 list_add(tmp
, &info
->rx_urbs_free
);
1372 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
1373 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1377 list_add(tmp
, &info
->rx_urbs_free
);
1381 list_add(tmp
, &info
->rx_urbs_submitted
);
1384 spin_unlock_irqrestore(&info
->lock
, flags
);
1390 static struct whiteheat_urb_wrap
*urb_to_wrap(struct urb
* urb
, struct list_head
*head
)
1392 struct whiteheat_urb_wrap
*wrap
;
1393 struct list_head
*tmp
;
1395 list_for_each(tmp
, head
) {
1396 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1397 if (wrap
->urb
== urb
)
1405 static struct list_head
*list_first(struct list_head
*head
)
1411 static void rx_data_softint(void *private)
1413 struct usb_serial_port
*port
= (struct usb_serial_port
*)private;
1414 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1415 struct tty_struct
*tty
= port
->tty
;
1416 struct whiteheat_urb_wrap
*wrap
;
1418 unsigned long flags
;
1419 struct list_head
*tmp
;
1420 struct list_head
*tmp2
;
1424 spin_lock_irqsave(&info
->lock
, flags
);
1425 if (info
->flags
& THROTTLED
) {
1426 spin_unlock_irqrestore(&info
->lock
, flags
);
1430 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
) {
1432 spin_unlock_irqrestore(&info
->lock
, flags
);
1434 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1437 if (tty
&& urb
->actual_length
) {
1438 int len
= tty_buffer_request_room(tty
, urb
->actual_length
);
1439 /* This stuff can go away now I suspect */
1440 if (unlikely(len
< urb
->actual_length
)) {
1441 spin_lock_irqsave(&info
->lock
, flags
);
1442 list_add(tmp
, &info
->rx_urb_q
);
1443 spin_unlock_irqrestore(&info
->lock
, flags
);
1444 tty_flip_buffer_push(tty
);
1445 schedule_work(&info
->rx_work
);
1448 tty_insert_flip_string(tty
, urb
->transfer_buffer
, len
);
1452 urb
->dev
= port
->serial
->dev
;
1453 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1455 err("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
1456 spin_lock_irqsave(&info
->lock
, flags
);
1457 list_add(tmp
, &info
->rx_urbs_free
);
1461 spin_lock_irqsave(&info
->lock
, flags
);
1462 list_add(tmp
, &info
->rx_urbs_submitted
);
1464 spin_unlock_irqrestore(&info
->lock
, flags
);
1467 tty_flip_buffer_push(tty
);
1471 /*****************************************************************************
1472 * Connect Tech's White Heat module functions
1473 *****************************************************************************/
1474 static int __init
whiteheat_init (void)
1477 retval
= usb_serial_register(&whiteheat_fake_device
);
1479 goto failed_fake_register
;
1480 retval
= usb_serial_register(&whiteheat_device
);
1482 goto failed_device_register
;
1483 retval
= usb_register(&whiteheat_driver
);
1485 goto failed_usb_register
;
1486 info(DRIVER_DESC
" " DRIVER_VERSION
);
1488 failed_usb_register
:
1489 usb_serial_deregister(&whiteheat_device
);
1490 failed_device_register
:
1491 usb_serial_deregister(&whiteheat_fake_device
);
1492 failed_fake_register
:
1497 static void __exit
whiteheat_exit (void)
1499 usb_deregister (&whiteheat_driver
);
1500 usb_serial_deregister (&whiteheat_fake_device
);
1501 usb_serial_deregister (&whiteheat_device
);
1505 module_init(whiteheat_init
);
1506 module_exit(whiteheat_exit
);
1508 MODULE_AUTHOR( DRIVER_AUTHOR
);
1509 MODULE_DESCRIPTION( DRIVER_DESC
);
1510 MODULE_LICENSE("GPL");
1512 module_param(urb_pool_size
, int, 0);
1513 MODULE_PARM_DESC(urb_pool_size
, "Number of urbs to use for buffering");
1515 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1516 MODULE_PARM_DESC(debug
, "Debug enabled or not");