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/kernel.h>
69 #include <linux/errno.h>
70 #include <linux/init.h>
71 #include <linux/slab.h>
72 #include <linux/tty.h>
73 #include <linux/tty_driver.h>
74 #include <linux/tty_flip.h>
75 #include <linux/module.h>
76 #include <linux/spinlock.h>
77 #include <asm/uaccess.h>
78 #include <asm/termbits.h>
79 #include <linux/usb.h>
80 #include <linux/serial_reg.h>
81 #include <linux/serial.h>
82 #include <linux/usb/serial.h>
83 #include "whiteheat_fw.h" /* firmware for the ConnectTech WhiteHEAT device */
84 #include "whiteheat.h" /* WhiteHEAT specific commands */
95 #define DRIVER_VERSION "v2.0"
96 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Stuart MacDonald <stuartm@connecttech.com>"
97 #define DRIVER_DESC "USB ConnectTech WhiteHEAT driver"
99 #define CONNECT_TECH_VENDOR_ID 0x0710
100 #define CONNECT_TECH_FAKE_WHITE_HEAT_ID 0x0001
101 #define CONNECT_TECH_WHITE_HEAT_ID 0x8001
104 ID tables for whiteheat are unusual, because we want to different
105 things for different versions of the device. Eventually, this
106 will be doable from a single table. But, for now, we define two
107 separate ID tables, and then a third table that combines them
108 just for the purpose of exporting the autoloading information.
110 static struct usb_device_id id_table_std
[] = {
111 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
112 { } /* Terminating entry */
115 static struct usb_device_id id_table_prerenumeration
[] = {
116 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
117 { } /* Terminating entry */
120 static struct usb_device_id id_table_combined
[] = {
121 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
122 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
123 { } /* Terminating entry */
126 MODULE_DEVICE_TABLE (usb
, id_table_combined
);
128 static struct usb_driver whiteheat_driver
= {
130 .probe
= usb_serial_probe
,
131 .disconnect
= usb_serial_disconnect
,
132 .id_table
= id_table_combined
,
136 /* function prototypes for the Connect Tech WhiteHEAT prerenumeration device */
137 static int whiteheat_firmware_download (struct usb_serial
*serial
, const struct usb_device_id
*id
);
138 static int whiteheat_firmware_attach (struct usb_serial
*serial
);
140 /* function prototypes for the Connect Tech WhiteHEAT serial converter */
141 static int whiteheat_attach (struct usb_serial
*serial
);
142 static void whiteheat_shutdown (struct usb_serial
*serial
);
143 static int whiteheat_open (struct usb_serial_port
*port
, struct file
*filp
);
144 static void whiteheat_close (struct usb_serial_port
*port
, struct file
*filp
);
145 static int whiteheat_write (struct usb_serial_port
*port
, const unsigned char *buf
, int count
);
146 static int whiteheat_write_room (struct usb_serial_port
*port
);
147 static int whiteheat_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
);
148 static void whiteheat_set_termios (struct usb_serial_port
*port
, struct termios
* old
);
149 static int whiteheat_tiocmget (struct usb_serial_port
*port
, struct file
*file
);
150 static int whiteheat_tiocmset (struct usb_serial_port
*port
, struct file
*file
, unsigned int set
, unsigned int clear
);
151 static void whiteheat_break_ctl (struct usb_serial_port
*port
, int break_state
);
152 static int whiteheat_chars_in_buffer (struct usb_serial_port
*port
);
153 static void whiteheat_throttle (struct usb_serial_port
*port
);
154 static void whiteheat_unthrottle (struct usb_serial_port
*port
);
155 static void whiteheat_read_callback (struct urb
*urb
);
156 static void whiteheat_write_callback (struct urb
*urb
);
158 static struct usb_serial_driver whiteheat_fake_device
= {
160 .owner
= THIS_MODULE
,
161 .name
= "whiteheatnofirm",
163 .description
= "Connect Tech - WhiteHEAT - (prerenumeration)",
164 .id_table
= id_table_prerenumeration
,
165 .num_interrupt_in
= NUM_DONT_CARE
,
166 .num_bulk_in
= NUM_DONT_CARE
,
167 .num_bulk_out
= NUM_DONT_CARE
,
169 .probe
= whiteheat_firmware_download
,
170 .attach
= whiteheat_firmware_attach
,
173 static struct usb_serial_driver whiteheat_device
= {
175 .owner
= THIS_MODULE
,
178 .description
= "Connect Tech - WhiteHEAT",
179 .id_table
= id_table_std
,
180 .num_interrupt_in
= NUM_DONT_CARE
,
181 .num_bulk_in
= NUM_DONT_CARE
,
182 .num_bulk_out
= NUM_DONT_CARE
,
184 .attach
= whiteheat_attach
,
185 .shutdown
= whiteheat_shutdown
,
186 .open
= whiteheat_open
,
187 .close
= whiteheat_close
,
188 .write
= whiteheat_write
,
189 .write_room
= whiteheat_write_room
,
190 .ioctl
= whiteheat_ioctl
,
191 .set_termios
= whiteheat_set_termios
,
192 .break_ctl
= whiteheat_break_ctl
,
193 .tiocmget
= whiteheat_tiocmget
,
194 .tiocmset
= whiteheat_tiocmset
,
195 .chars_in_buffer
= whiteheat_chars_in_buffer
,
196 .throttle
= whiteheat_throttle
,
197 .unthrottle
= whiteheat_unthrottle
,
198 .read_bulk_callback
= whiteheat_read_callback
,
199 .write_bulk_callback
= whiteheat_write_callback
,
203 struct whiteheat_command_private
{
206 __u8 command_finished
;
207 wait_queue_head_t wait_command
; /* for handling sleeping while waiting for a command to finish */
208 __u8 result_buffer
[64];
212 #define THROTTLED 0x01
213 #define ACTUALLY_THROTTLED 0x02
215 static int urb_pool_size
= 8;
217 struct whiteheat_urb_wrap
{
218 struct list_head list
;
222 struct whiteheat_private
{
226 struct list_head rx_urbs_free
;
227 struct list_head rx_urbs_submitted
;
228 struct list_head rx_urb_q
;
229 struct work_struct rx_work
;
230 struct usb_serial_port
*port
;
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
);
240 static void command_port_read_callback(struct urb
*urb
);
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(struct work_struct
*work
);
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
!= 2) {
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(*hw_info
) + 1) {
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
);
431 INIT_LIST_HEAD(&info
->rx_urbs_free
);
432 INIT_LIST_HEAD(&info
->rx_urbs_submitted
);
433 INIT_LIST_HEAD(&info
->rx_urb_q
);
434 INIT_LIST_HEAD(&info
->tx_urbs_free
);
435 INIT_LIST_HEAD(&info
->tx_urbs_submitted
);
437 for (j
= 0; j
< urb_pool_size
; j
++) {
438 urb
= usb_alloc_urb(0, GFP_KERNEL
);
440 err("No free urbs available");
443 buf_size
= port
->read_urb
->transfer_buffer_length
;
444 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
445 if (!urb
->transfer_buffer
) {
446 err("Couldn't allocate urb buffer");
449 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
451 err("Couldn't allocate urb wrapper");
454 usb_fill_bulk_urb(urb
, serial
->dev
,
455 usb_rcvbulkpipe(serial
->dev
,
456 port
->bulk_in_endpointAddress
),
457 urb
->transfer_buffer
, buf_size
,
458 whiteheat_read_callback
, port
);
460 list_add(&wrap
->list
, &info
->rx_urbs_free
);
462 urb
= usb_alloc_urb(0, GFP_KERNEL
);
464 err("No free urbs available");
467 buf_size
= port
->write_urb
->transfer_buffer_length
;
468 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
469 if (!urb
->transfer_buffer
) {
470 err("Couldn't allocate urb buffer");
473 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
475 err("Couldn't allocate urb wrapper");
478 usb_fill_bulk_urb(urb
, serial
->dev
,
479 usb_sndbulkpipe(serial
->dev
,
480 port
->bulk_out_endpointAddress
),
481 urb
->transfer_buffer
, buf_size
,
482 whiteheat_write_callback
, port
);
484 list_add(&wrap
->list
, &info
->tx_urbs_free
);
487 usb_set_serial_port_data(port
, info
);
490 command_info
= (struct whiteheat_command_private
*)kmalloc(sizeof(struct whiteheat_command_private
), GFP_KERNEL
);
491 if (command_info
== NULL
) {
492 err("%s: Out of memory for port structures\n", serial
->type
->description
);
493 goto no_command_private
;
496 spin_lock_init(&command_info
->lock
);
497 command_info
->port_running
= 0;
498 init_waitqueue_head(&command_info
->wait_command
);
499 usb_set_serial_port_data(command_port
, command_info
);
500 command_port
->write_urb
->complete
= command_port_write_callback
;
501 command_port
->read_urb
->complete
= command_port_read_callback
;
508 /* Firmware likely not running */
509 err("%s: Unable to retrieve firmware version, try replugging\n", serial
->type
->description
);
510 err("%s: If the firmware is not running (status led not blinking)\n", serial
->type
->description
);
511 err("%s: please contact support@connecttech.com\n", serial
->type
->description
);
516 for (i
= serial
->num_ports
- 1; i
>= 0; i
--) {
517 port
= serial
->port
[i
];
518 info
= usb_get_serial_port_data(port
);
519 for (j
= urb_pool_size
- 1; j
>= 0; j
--) {
520 tmp
= list_first(&info
->tx_urbs_free
);
522 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
526 kfree(urb
->transfer_buffer
);
530 tmp
= list_first(&info
->rx_urbs_free
);
532 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
536 kfree(urb
->transfer_buffer
);
554 static void whiteheat_shutdown (struct usb_serial
*serial
)
556 struct usb_serial_port
*command_port
;
557 struct usb_serial_port
*port
;
558 struct whiteheat_private
*info
;
559 struct whiteheat_urb_wrap
*wrap
;
561 struct list_head
*tmp
;
562 struct list_head
*tmp2
;
565 dbg("%s", __FUNCTION__
);
567 /* free up our private data for our command port */
568 command_port
= serial
->port
[COMMAND_PORT
];
569 kfree (usb_get_serial_port_data(command_port
));
571 for (i
= 0; i
< serial
->num_ports
; i
++) {
572 port
= serial
->port
[i
];
573 info
= usb_get_serial_port_data(port
);
574 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
576 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
579 kfree(urb
->transfer_buffer
);
582 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_free
) {
584 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
587 kfree(urb
->transfer_buffer
);
597 static int whiteheat_open (struct usb_serial_port
*port
, struct file
*filp
)
600 struct termios old_term
;
602 dbg("%s - port %d", __FUNCTION__
, port
->number
);
604 retval
= start_command_port(port
->serial
);
609 port
->tty
->low_latency
= 1;
611 /* send an open port command */
612 retval
= firm_open(port
);
614 stop_command_port(port
->serial
);
618 retval
= firm_purge(port
, WHITEHEAT_PURGE_RX
| WHITEHEAT_PURGE_TX
);
621 stop_command_port(port
->serial
);
625 old_term
.c_cflag
= ~port
->tty
->termios
->c_cflag
;
626 old_term
.c_iflag
= ~port
->tty
->termios
->c_iflag
;
627 whiteheat_set_termios(port
, &old_term
);
629 /* Work around HCD bugs */
630 usb_clear_halt(port
->serial
->dev
, port
->read_urb
->pipe
);
631 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
633 /* Start reading from the device */
634 retval
= start_port_read(port
);
636 err("%s - failed submitting read urb, error %d", __FUNCTION__
, retval
);
638 stop_command_port(port
->serial
);
643 dbg("%s - exit, retval = %d", __FUNCTION__
, retval
);
648 static void whiteheat_close(struct usb_serial_port
*port
, struct file
* filp
)
650 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
651 struct whiteheat_urb_wrap
*wrap
;
653 struct list_head
*tmp
;
654 struct list_head
*tmp2
;
657 dbg("%s - port %d", __FUNCTION__
, port
->number
);
659 /* filp is NULL when called from usb_serial_disconnect */
660 if (filp
&& (tty_hung_up_p(filp
))) {
664 port
->tty
->closing
= 1;
667 * Not currently in use; tty_wait_until_sent() calls
668 * serial_chars_in_buffer() which deadlocks on the second semaphore
669 * acquisition. This should be fixed at some point. Greg's been
671 if ((filp->f_flags & (O_NDELAY | O_NONBLOCK)) == 0) {
672 tty_wait_until_sent(port->tty, CLOSING_DELAY);
676 if (port
->tty
->driver
->flush_buffer
)
677 port
->tty
->driver
->flush_buffer(port
->tty
);
678 tty_ldisc_flush(port
->tty
);
680 firm_report_tx_done(port
);
684 /* shutdown our bulk reads and writes */
685 spin_lock_irqsave(&info
->lock
, flags
);
686 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
687 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
690 list_move(tmp
, &info
->rx_urbs_free
);
692 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
)
693 list_move(tmp
, &info
->rx_urbs_free
);
695 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_submitted
) {
696 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
699 list_move(tmp
, &info
->tx_urbs_free
);
701 spin_unlock_irqrestore(&info
->lock
, flags
);
703 stop_command_port(port
->serial
);
705 port
->tty
->closing
= 0;
709 static int whiteheat_write(struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
711 struct usb_serial
*serial
= port
->serial
;
712 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
713 struct whiteheat_urb_wrap
*wrap
;
719 struct list_head
*tmp
;
721 dbg("%s - port %d", __FUNCTION__
, port
->number
);
724 dbg("%s - write request of 0 bytes", __FUNCTION__
);
729 spin_lock_irqsave(&info
->lock
, flags
);
730 if (list_empty(&info
->tx_urbs_free
)) {
731 spin_unlock_irqrestore(&info
->lock
, flags
);
734 tmp
= list_first(&info
->tx_urbs_free
);
736 spin_unlock_irqrestore(&info
->lock
, flags
);
738 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
740 bytes
= (count
> port
->bulk_out_size
) ? port
->bulk_out_size
: count
;
741 memcpy (urb
->transfer_buffer
, buf
+ sent
, bytes
);
743 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, bytes
, urb
->transfer_buffer
);
745 urb
->dev
= serial
->dev
;
746 urb
->transfer_buffer_length
= bytes
;
747 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
749 err("%s - failed submitting write urb, error %d", __FUNCTION__
, result
);
751 spin_lock_irqsave(&info
->lock
, flags
);
752 list_add(tmp
, &info
->tx_urbs_free
);
753 spin_unlock_irqrestore(&info
->lock
, flags
);
758 spin_lock_irqsave(&info
->lock
, flags
);
759 list_add(tmp
, &info
->tx_urbs_submitted
);
760 spin_unlock_irqrestore(&info
->lock
, flags
);
768 static int whiteheat_write_room(struct usb_serial_port
*port
)
770 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
771 struct list_head
*tmp
;
775 dbg("%s - port %d", __FUNCTION__
, port
->number
);
777 spin_lock_irqsave(&info
->lock
, flags
);
778 list_for_each(tmp
, &info
->tx_urbs_free
)
780 spin_unlock_irqrestore(&info
->lock
, flags
);
781 room
*= port
->bulk_out_size
;
783 dbg("%s - returns %d", __FUNCTION__
, room
);
788 static int whiteheat_tiocmget (struct usb_serial_port
*port
, struct file
*file
)
790 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
791 unsigned int modem_signals
= 0;
793 dbg("%s - port %d", __FUNCTION__
, port
->number
);
795 firm_get_dtr_rts(port
);
796 if (info
->mcr
& UART_MCR_DTR
)
797 modem_signals
|= TIOCM_DTR
;
798 if (info
->mcr
& UART_MCR_RTS
)
799 modem_signals
|= TIOCM_RTS
;
801 return modem_signals
;
805 static int whiteheat_tiocmset (struct usb_serial_port
*port
, struct file
*file
,
806 unsigned int set
, unsigned int clear
)
808 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
810 dbg("%s - port %d", __FUNCTION__
, port
->number
);
813 info
->mcr
|= UART_MCR_RTS
;
815 info
->mcr
|= UART_MCR_DTR
;
817 if (clear
& TIOCM_RTS
)
818 info
->mcr
&= ~UART_MCR_RTS
;
819 if (clear
& TIOCM_DTR
)
820 info
->mcr
&= ~UART_MCR_DTR
;
822 firm_set_dtr(port
, info
->mcr
& UART_MCR_DTR
);
823 firm_set_rts(port
, info
->mcr
& UART_MCR_RTS
);
828 static int whiteheat_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
)
830 struct serial_struct serstruct
;
831 void __user
*user_arg
= (void __user
*)arg
;
833 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__
, port
->number
, cmd
);
837 memset(&serstruct
, 0, sizeof(serstruct
));
838 serstruct
.type
= PORT_16654
;
839 serstruct
.line
= port
->serial
->minor
;
840 serstruct
.port
= port
->number
;
841 serstruct
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
842 serstruct
.xmit_fifo_size
= port
->bulk_out_size
;
843 serstruct
.custom_divisor
= 0;
844 serstruct
.baud_base
= 460800;
845 serstruct
.close_delay
= CLOSING_DELAY
;
846 serstruct
.closing_wait
= CLOSING_DELAY
;
848 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
854 if (copy_from_user(&serstruct
, user_arg
, sizeof(serstruct
)))
858 * For now this is ignored. dip sets the ASYNC_[V]HI flags
859 * but this isn't used by us at all. Maybe someone somewhere
860 * will need the custom_divisor setting.
873 static void whiteheat_set_termios (struct usb_serial_port
*port
, struct termios
*old_termios
)
875 dbg("%s -port %d", __FUNCTION__
, port
->number
);
877 if ((!port
->tty
) || (!port
->tty
->termios
)) {
878 dbg("%s - no tty structures", __FUNCTION__
);
882 /* check that they really want us to change something */
884 if ((port
->tty
->termios
->c_cflag
== old_termios
->c_cflag
) &&
885 (port
->tty
->termios
->c_iflag
== old_termios
->c_iflag
)) {
886 dbg("%s - nothing to change...", __FUNCTION__
);
891 firm_setup_port(port
);
898 static void whiteheat_break_ctl(struct usb_serial_port
*port
, int break_state
) {
899 firm_set_break(port
, break_state
);
903 static int whiteheat_chars_in_buffer(struct usb_serial_port
*port
)
905 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
906 struct list_head
*tmp
;
907 struct whiteheat_urb_wrap
*wrap
;
911 dbg("%s - port %d", __FUNCTION__
, port
->number
);
913 spin_lock_irqsave(&info
->lock
, flags
);
914 list_for_each(tmp
, &info
->tx_urbs_submitted
) {
915 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
916 chars
+= wrap
->urb
->transfer_buffer_length
;
918 spin_unlock_irqrestore(&info
->lock
, flags
);
920 dbg ("%s - returns %d", __FUNCTION__
, chars
);
925 static void whiteheat_throttle (struct usb_serial_port
*port
)
927 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
930 dbg("%s - port %d", __FUNCTION__
, port
->number
);
932 spin_lock_irqsave(&info
->lock
, flags
);
933 info
->flags
|= THROTTLED
;
934 spin_unlock_irqrestore(&info
->lock
, flags
);
940 static void whiteheat_unthrottle (struct usb_serial_port
*port
)
942 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
943 int actually_throttled
;
946 dbg("%s - port %d", __FUNCTION__
, port
->number
);
948 spin_lock_irqsave(&info
->lock
, flags
);
949 actually_throttled
= info
->flags
& ACTUALLY_THROTTLED
;
950 info
->flags
&= ~(THROTTLED
| ACTUALLY_THROTTLED
);
951 spin_unlock_irqrestore(&info
->lock
, flags
);
953 if (actually_throttled
)
954 rx_data_softint(&info
->rx_work
);
960 /*****************************************************************************
961 * Connect Tech's White Heat callback routines
962 *****************************************************************************/
963 static void command_port_write_callback (struct urb
*urb
)
965 dbg("%s", __FUNCTION__
);
968 dbg ("nonzero urb status: %d", urb
->status
);
974 static void command_port_read_callback (struct urb
*urb
)
976 struct usb_serial_port
*command_port
= (struct usb_serial_port
*)urb
->context
;
977 struct whiteheat_command_private
*command_info
;
978 unsigned char *data
= urb
->transfer_buffer
;
982 dbg("%s", __FUNCTION__
);
985 dbg("%s - nonzero urb status: %d", __FUNCTION__
, urb
->status
);
989 usb_serial_debug_data(debug
, &command_port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
991 command_info
= usb_get_serial_port_data(command_port
);
993 dbg ("%s - command_info is NULL, exiting.", __FUNCTION__
);
996 spin_lock_irqsave(&command_info
->lock
, flags
);
998 if (data
[0] == WHITEHEAT_CMD_COMPLETE
) {
999 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
1000 wake_up_interruptible(&command_info
->wait_command
);
1001 } else if (data
[0] == WHITEHEAT_CMD_FAILURE
) {
1002 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
1003 wake_up_interruptible(&command_info
->wait_command
);
1004 } else if (data
[0] == WHITEHEAT_EVENT
) {
1005 /* These are unsolicited reports from the firmware, hence no waiting command to wakeup */
1006 dbg("%s - event received", __FUNCTION__
);
1007 } else if (data
[0] == WHITEHEAT_GET_DTR_RTS
) {
1008 memcpy(command_info
->result_buffer
, &data
[1], urb
->actual_length
- 1);
1009 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
1010 wake_up_interruptible(&command_info
->wait_command
);
1012 dbg("%s - bad reply from firmware", __FUNCTION__
);
1015 /* Continue trying to always read */
1016 command_port
->read_urb
->dev
= command_port
->serial
->dev
;
1017 result
= usb_submit_urb(command_port
->read_urb
, GFP_ATOMIC
);
1018 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1020 dbg("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
1024 static void whiteheat_read_callback(struct urb
*urb
)
1026 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1027 struct whiteheat_urb_wrap
*wrap
;
1028 unsigned char *data
= urb
->transfer_buffer
;
1029 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1031 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1033 spin_lock(&info
->lock
);
1034 wrap
= urb_to_wrap(urb
, &info
->rx_urbs_submitted
);
1036 spin_unlock(&info
->lock
);
1037 err("%s - Not my urb!", __FUNCTION__
);
1040 list_del(&wrap
->list
);
1041 spin_unlock(&info
->lock
);
1044 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__
, urb
->status
);
1045 spin_lock(&info
->lock
);
1046 list_add(&wrap
->list
, &info
->rx_urbs_free
);
1047 spin_unlock(&info
->lock
);
1051 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
1053 spin_lock(&info
->lock
);
1054 list_add_tail(&wrap
->list
, &info
->rx_urb_q
);
1055 if (info
->flags
& THROTTLED
) {
1056 info
->flags
|= ACTUALLY_THROTTLED
;
1057 spin_unlock(&info
->lock
);
1060 spin_unlock(&info
->lock
);
1062 schedule_work(&info
->rx_work
);
1066 static void whiteheat_write_callback(struct urb
*urb
)
1068 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1069 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1070 struct whiteheat_urb_wrap
*wrap
;
1072 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1074 spin_lock(&info
->lock
);
1075 wrap
= urb_to_wrap(urb
, &info
->tx_urbs_submitted
);
1077 spin_unlock(&info
->lock
);
1078 err("%s - Not my urb!", __FUNCTION__
);
1081 list_move(&wrap
->list
, &info
->tx_urbs_free
);
1082 spin_unlock(&info
->lock
);
1085 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__
, urb
->status
);
1089 usb_serial_port_softint(port
);
1093 /*****************************************************************************
1094 * Connect Tech's White Heat firmware interface
1095 *****************************************************************************/
1096 static int firm_send_command (struct usb_serial_port
*port
, __u8 command
, __u8
*data
, __u8 datasize
)
1098 struct usb_serial_port
*command_port
;
1099 struct whiteheat_command_private
*command_info
;
1100 struct whiteheat_private
*info
;
1101 __u8
*transfer_buffer
;
1103 unsigned long flags
;
1105 dbg("%s - command %d", __FUNCTION__
, command
);
1107 command_port
= port
->serial
->port
[COMMAND_PORT
];
1108 command_info
= usb_get_serial_port_data(command_port
);
1109 spin_lock_irqsave(&command_info
->lock
, flags
);
1110 command_info
->command_finished
= FALSE
;
1112 transfer_buffer
= (__u8
*)command_port
->write_urb
->transfer_buffer
;
1113 transfer_buffer
[0] = command
;
1114 memcpy (&transfer_buffer
[1], data
, datasize
);
1115 command_port
->write_urb
->transfer_buffer_length
= datasize
+ 1;
1116 command_port
->write_urb
->dev
= port
->serial
->dev
;
1117 retval
= usb_submit_urb (command_port
->write_urb
, GFP_KERNEL
);
1119 dbg("%s - submit urb failed", __FUNCTION__
);
1122 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1124 /* wait for the command to complete */
1125 wait_event_interruptible_timeout(command_info
->wait_command
,
1126 (command_info
->command_finished
!= FALSE
), COMMAND_TIMEOUT
);
1128 spin_lock_irqsave(&command_info
->lock
, flags
);
1130 if (command_info
->command_finished
== FALSE
) {
1131 dbg("%s - command timed out.", __FUNCTION__
);
1132 retval
= -ETIMEDOUT
;
1136 if (command_info
->command_finished
== WHITEHEAT_CMD_FAILURE
) {
1137 dbg("%s - command failed.", __FUNCTION__
);
1142 if (command_info
->command_finished
== WHITEHEAT_CMD_COMPLETE
) {
1143 dbg("%s - command completed.", __FUNCTION__
);
1145 case WHITEHEAT_GET_DTR_RTS
:
1146 info
= usb_get_serial_port_data(port
);
1147 memcpy(&info
->mcr
, command_info
->result_buffer
, sizeof(struct whiteheat_dr_info
));
1153 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1158 static int firm_open(struct usb_serial_port
*port
) {
1159 struct whiteheat_simple open_command
;
1161 open_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1162 return firm_send_command(port
, WHITEHEAT_OPEN
, (__u8
*)&open_command
, sizeof(open_command
));
1166 static int firm_close(struct usb_serial_port
*port
) {
1167 struct whiteheat_simple close_command
;
1169 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1170 return firm_send_command(port
, WHITEHEAT_CLOSE
, (__u8
*)&close_command
, sizeof(close_command
));
1174 static int firm_setup_port(struct usb_serial_port
*port
) {
1175 struct whiteheat_port_settings port_settings
;
1176 unsigned int cflag
= port
->tty
->termios
->c_cflag
;
1178 port_settings
.port
= port
->number
+ 1;
1180 /* get the byte size */
1181 switch (cflag
& CSIZE
) {
1182 case CS5
: port_settings
.bits
= 5; break;
1183 case CS6
: port_settings
.bits
= 6; break;
1184 case CS7
: port_settings
.bits
= 7; break;
1186 case CS8
: port_settings
.bits
= 8; break;
1188 dbg("%s - data bits = %d", __FUNCTION__
, port_settings
.bits
);
1190 /* determine the parity */
1194 port_settings
.parity
= WHITEHEAT_PAR_MARK
;
1196 port_settings
.parity
= WHITEHEAT_PAR_SPACE
;
1199 port_settings
.parity
= WHITEHEAT_PAR_ODD
;
1201 port_settings
.parity
= WHITEHEAT_PAR_EVEN
;
1203 port_settings
.parity
= WHITEHEAT_PAR_NONE
;
1204 dbg("%s - parity = %c", __FUNCTION__
, port_settings
.parity
);
1206 /* figure out the stop bits requested */
1208 port_settings
.stop
= 2;
1210 port_settings
.stop
= 1;
1211 dbg("%s - stop bits = %d", __FUNCTION__
, port_settings
.stop
);
1213 /* figure out the flow control settings */
1214 if (cflag
& CRTSCTS
)
1215 port_settings
.hflow
= (WHITEHEAT_HFLOW_CTS
| WHITEHEAT_HFLOW_RTS
);
1217 port_settings
.hflow
= WHITEHEAT_HFLOW_NONE
;
1218 dbg("%s - hardware flow control = %s %s %s %s", __FUNCTION__
,
1219 (port_settings
.hflow
& WHITEHEAT_HFLOW_CTS
) ? "CTS" : "",
1220 (port_settings
.hflow
& WHITEHEAT_HFLOW_RTS
) ? "RTS" : "",
1221 (port_settings
.hflow
& WHITEHEAT_HFLOW_DSR
) ? "DSR" : "",
1222 (port_settings
.hflow
& WHITEHEAT_HFLOW_DTR
) ? "DTR" : "");
1224 /* determine software flow control */
1225 if (I_IXOFF(port
->tty
))
1226 port_settings
.sflow
= WHITEHEAT_SFLOW_RXTX
;
1228 port_settings
.sflow
= WHITEHEAT_SFLOW_NONE
;
1229 dbg("%s - software flow control = %c", __FUNCTION__
, port_settings
.sflow
);
1231 port_settings
.xon
= START_CHAR(port
->tty
);
1232 port_settings
.xoff
= STOP_CHAR(port
->tty
);
1233 dbg("%s - XON = %2x, XOFF = %2x", __FUNCTION__
, port_settings
.xon
, port_settings
.xoff
);
1235 /* get the baud rate wanted */
1236 port_settings
.baud
= tty_get_baud_rate(port
->tty
);
1237 dbg("%s - baud rate = %d", __FUNCTION__
, port_settings
.baud
);
1239 /* handle any settings that aren't specified in the tty structure */
1240 port_settings
.lloop
= 0;
1242 /* now send the message to the device */
1243 return firm_send_command(port
, WHITEHEAT_SETUP_PORT
, (__u8
*)&port_settings
, sizeof(port_settings
));
1247 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
) {
1248 struct whiteheat_set_rdb rts_command
;
1250 rts_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1251 rts_command
.state
= onoff
;
1252 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&rts_command
, sizeof(rts_command
));
1256 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
) {
1257 struct whiteheat_set_rdb dtr_command
;
1259 dtr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1260 dtr_command
.state
= onoff
;
1261 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&dtr_command
, sizeof(dtr_command
));
1265 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
) {
1266 struct whiteheat_set_rdb break_command
;
1268 break_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1269 break_command
.state
= onoff
;
1270 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&break_command
, sizeof(break_command
));
1274 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
) {
1275 struct whiteheat_purge purge_command
;
1277 purge_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1278 purge_command
.what
= rxtx
;
1279 return firm_send_command(port
, WHITEHEAT_PURGE
, (__u8
*)&purge_command
, sizeof(purge_command
));
1283 static int firm_get_dtr_rts(struct usb_serial_port
*port
) {
1284 struct whiteheat_simple get_dr_command
;
1286 get_dr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1287 return firm_send_command(port
, WHITEHEAT_GET_DTR_RTS
, (__u8
*)&get_dr_command
, sizeof(get_dr_command
));
1291 static int firm_report_tx_done(struct usb_serial_port
*port
) {
1292 struct whiteheat_simple close_command
;
1294 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1295 return firm_send_command(port
, WHITEHEAT_REPORT_TX_DONE
, (__u8
*)&close_command
, sizeof(close_command
));
1299 /*****************************************************************************
1300 * Connect Tech's White Heat utility functions
1301 *****************************************************************************/
1302 static int start_command_port(struct usb_serial
*serial
)
1304 struct usb_serial_port
*command_port
;
1305 struct whiteheat_command_private
*command_info
;
1306 unsigned long flags
;
1309 command_port
= serial
->port
[COMMAND_PORT
];
1310 command_info
= usb_get_serial_port_data(command_port
);
1311 spin_lock_irqsave(&command_info
->lock
, flags
);
1312 if (!command_info
->port_running
) {
1313 /* Work around HCD bugs */
1314 usb_clear_halt(serial
->dev
, command_port
->read_urb
->pipe
);
1316 command_port
->read_urb
->dev
= serial
->dev
;
1317 retval
= usb_submit_urb(command_port
->read_urb
, GFP_KERNEL
);
1319 err("%s - failed submitting read urb, error %d", __FUNCTION__
, retval
);
1323 command_info
->port_running
++;
1326 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1331 static void stop_command_port(struct usb_serial
*serial
)
1333 struct usb_serial_port
*command_port
;
1334 struct whiteheat_command_private
*command_info
;
1335 unsigned long flags
;
1337 command_port
= serial
->port
[COMMAND_PORT
];
1338 command_info
= usb_get_serial_port_data(command_port
);
1339 spin_lock_irqsave(&command_info
->lock
, flags
);
1340 command_info
->port_running
--;
1341 if (!command_info
->port_running
)
1342 usb_kill_urb(command_port
->read_urb
);
1343 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1347 static int start_port_read(struct usb_serial_port
*port
)
1349 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1350 struct whiteheat_urb_wrap
*wrap
;
1353 unsigned long flags
;
1354 struct list_head
*tmp
;
1355 struct list_head
*tmp2
;
1357 spin_lock_irqsave(&info
->lock
, flags
);
1359 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
1361 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1363 urb
->dev
= port
->serial
->dev
;
1364 retval
= usb_submit_urb(urb
, GFP_KERNEL
);
1366 list_add(tmp
, &info
->rx_urbs_free
);
1367 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
1368 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1371 list_move(tmp
, &info
->rx_urbs_free
);
1375 list_add(tmp
, &info
->rx_urbs_submitted
);
1378 spin_unlock_irqrestore(&info
->lock
, flags
);
1384 static struct whiteheat_urb_wrap
*urb_to_wrap(struct urb
* urb
, struct list_head
*head
)
1386 struct whiteheat_urb_wrap
*wrap
;
1387 struct list_head
*tmp
;
1389 list_for_each(tmp
, head
) {
1390 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1391 if (wrap
->urb
== urb
)
1399 static struct list_head
*list_first(struct list_head
*head
)
1405 static void rx_data_softint(struct work_struct
*work
)
1407 struct whiteheat_private
*info
=
1408 container_of(work
, struct whiteheat_private
, rx_work
);
1409 struct usb_serial_port
*port
= info
->port
;
1410 struct tty_struct
*tty
= port
->tty
;
1411 struct whiteheat_urb_wrap
*wrap
;
1413 unsigned long flags
;
1414 struct list_head
*tmp
;
1415 struct list_head
*tmp2
;
1419 spin_lock_irqsave(&info
->lock
, flags
);
1420 if (info
->flags
& THROTTLED
) {
1421 spin_unlock_irqrestore(&info
->lock
, flags
);
1425 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
) {
1427 spin_unlock_irqrestore(&info
->lock
, flags
);
1429 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1432 if (tty
&& urb
->actual_length
) {
1433 int len
= tty_buffer_request_room(tty
, urb
->actual_length
);
1434 /* This stuff can go away now I suspect */
1435 if (unlikely(len
< urb
->actual_length
)) {
1436 spin_lock_irqsave(&info
->lock
, flags
);
1437 list_add(tmp
, &info
->rx_urb_q
);
1438 spin_unlock_irqrestore(&info
->lock
, flags
);
1439 tty_flip_buffer_push(tty
);
1440 schedule_work(&info
->rx_work
);
1443 tty_insert_flip_string(tty
, urb
->transfer_buffer
, len
);
1447 urb
->dev
= port
->serial
->dev
;
1448 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1450 err("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
1451 spin_lock_irqsave(&info
->lock
, flags
);
1452 list_add(tmp
, &info
->rx_urbs_free
);
1456 spin_lock_irqsave(&info
->lock
, flags
);
1457 list_add(tmp
, &info
->rx_urbs_submitted
);
1459 spin_unlock_irqrestore(&info
->lock
, flags
);
1462 tty_flip_buffer_push(tty
);
1466 /*****************************************************************************
1467 * Connect Tech's White Heat module functions
1468 *****************************************************************************/
1469 static int __init
whiteheat_init (void)
1472 retval
= usb_serial_register(&whiteheat_fake_device
);
1474 goto failed_fake_register
;
1475 retval
= usb_serial_register(&whiteheat_device
);
1477 goto failed_device_register
;
1478 retval
= usb_register(&whiteheat_driver
);
1480 goto failed_usb_register
;
1481 info(DRIVER_DESC
" " DRIVER_VERSION
);
1483 failed_usb_register
:
1484 usb_serial_deregister(&whiteheat_device
);
1485 failed_device_register
:
1486 usb_serial_deregister(&whiteheat_fake_device
);
1487 failed_fake_register
:
1492 static void __exit
whiteheat_exit (void)
1494 usb_deregister (&whiteheat_driver
);
1495 usb_serial_deregister (&whiteheat_fake_device
);
1496 usb_serial_deregister (&whiteheat_device
);
1500 module_init(whiteheat_init
);
1501 module_exit(whiteheat_exit
);
1503 MODULE_AUTHOR( DRIVER_AUTHOR
);
1504 MODULE_DESCRIPTION( DRIVER_DESC
);
1505 MODULE_LICENSE("GPL");
1507 module_param(urb_pool_size
, int, 0);
1508 MODULE_PARM_DESC(urb_pool_size
, "Number of urbs to use for buffering");
1510 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1511 MODULE_PARM_DESC(debug
, "Debug enabled or not");