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
, struct pt_regs
*regs
);
156 static void whiteheat_write_callback (struct urb
*urb
, struct pt_regs
*regs
);
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 list_head tx_urbs_free
;
231 struct list_head tx_urbs_submitted
;
235 /* local function prototypes */
236 static int start_command_port(struct usb_serial
*serial
);
237 static void stop_command_port(struct usb_serial
*serial
);
238 static void command_port_write_callback(struct urb
*urb
, struct pt_regs
*regs
);
239 static void command_port_read_callback(struct urb
*urb
, struct pt_regs
*regs
);
241 static int start_port_read(struct usb_serial_port
*port
);
242 static struct whiteheat_urb_wrap
*urb_to_wrap(struct urb
*urb
, struct list_head
*head
);
243 static struct list_head
*list_first(struct list_head
*head
);
244 static void rx_data_softint(void *private);
246 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
, __u8
*data
, __u8 datasize
);
247 static int firm_open(struct usb_serial_port
*port
);
248 static int firm_close(struct usb_serial_port
*port
);
249 static int firm_setup_port(struct usb_serial_port
*port
);
250 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
);
251 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
);
252 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
);
253 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
);
254 static int firm_get_dtr_rts(struct usb_serial_port
*port
);
255 static int firm_report_tx_done(struct usb_serial_port
*port
);
258 #define COMMAND_PORT 4
259 #define COMMAND_TIMEOUT (2*HZ) /* 2 second timeout for a command */
260 #define COMMAND_TIMEOUT_MS 2000
261 #define CLOSING_DELAY (30 * HZ)
264 /*****************************************************************************
265 * Connect Tech's White Heat prerenumeration driver functions
266 *****************************************************************************/
268 /* steps to download the firmware to the WhiteHEAT device:
269 - hold the reset (by writing to the reset bit of the CPUCS register)
270 - download the VEND_AX.HEX file to the chip using VENDOR_REQUEST-ANCHOR_LOAD
271 - release the reset (by writing to the CPUCS register)
272 - download the WH.HEX file for all addresses greater than 0x1b3f using
273 VENDOR_REQUEST-ANCHOR_EXTERNAL_RAM_LOAD
275 - download the WH.HEX file for all addresses less than 0x1b40 using
276 VENDOR_REQUEST_ANCHOR_LOAD
278 - device renumerated itself and comes up as new device id with all
279 firmware download completed.
281 static int whiteheat_firmware_download (struct usb_serial
*serial
, const struct usb_device_id
*id
)
284 const struct whiteheat_hex_record
*record
;
286 dbg("%s", __FUNCTION__
);
288 response
= ezusb_set_reset (serial
, 1);
290 record
= &whiteheat_loader
[0];
291 while (record
->address
!= 0xffff) {
292 response
= ezusb_writememory (serial
, record
->address
,
293 (unsigned char *)record
->data
, record
->data_size
, 0xa0);
295 err("%s - ezusb_writememory failed for loader (%d %04X %p %d)",
296 __FUNCTION__
, response
, record
->address
, record
->data
, record
->data_size
);
302 response
= ezusb_set_reset (serial
, 0);
304 record
= &whiteheat_firmware
[0];
305 while (record
->address
< 0x1b40) {
308 while (record
->address
!= 0xffff) {
309 response
= ezusb_writememory (serial
, record
->address
,
310 (unsigned char *)record
->data
, record
->data_size
, 0xa3);
312 err("%s - ezusb_writememory failed for first firmware step (%d %04X %p %d)",
313 __FUNCTION__
, response
, record
->address
, record
->data
, record
->data_size
);
319 response
= ezusb_set_reset (serial
, 1);
321 record
= &whiteheat_firmware
[0];
322 while (record
->address
< 0x1b40) {
323 response
= ezusb_writememory (serial
, record
->address
,
324 (unsigned char *)record
->data
, record
->data_size
, 0xa0);
326 err("%s - ezusb_writememory failed for second firmware step (%d %04X %p %d)",
327 __FUNCTION__
, response
, record
->address
, record
->data
, record
->data_size
);
333 response
= ezusb_set_reset (serial
, 0);
339 static int whiteheat_firmware_attach (struct usb_serial
*serial
)
341 /* We want this device to fail to have a driver assigned to it */
346 /*****************************************************************************
347 * Connect Tech's White Heat serial driver functions
348 *****************************************************************************/
349 static int whiteheat_attach (struct usb_serial
*serial
)
351 struct usb_serial_port
*command_port
;
352 struct whiteheat_command_private
*command_info
;
353 struct usb_serial_port
*port
;
354 struct whiteheat_private
*info
;
355 struct whiteheat_hw_info
*hw_info
;
365 struct whiteheat_urb_wrap
*wrap
;
366 struct list_head
*tmp
;
368 command_port
= serial
->port
[COMMAND_PORT
];
370 pipe
= usb_sndbulkpipe (serial
->dev
, command_port
->bulk_out_endpointAddress
);
371 command
= kmalloc(2, GFP_KERNEL
);
373 goto no_command_buffer
;
374 command
[0] = WHITEHEAT_GET_HW_INFO
;
377 result
= kmalloc(sizeof(*hw_info
) + 1, GFP_KERNEL
);
379 goto no_result_buffer
;
381 * When the module is reloaded the firmware is still there and
382 * the endpoints are still in the usb core unchanged. This is the
383 * unlinking bug in disguise. Same for the call below.
385 usb_clear_halt(serial
->dev
, pipe
);
386 ret
= usb_bulk_msg (serial
->dev
, pipe
, command
, 2, &alen
, COMMAND_TIMEOUT_MS
);
388 err("%s: Couldn't send command [%d]", serial
->type
->description
, ret
);
390 } else if (alen
!= 2) {
391 err("%s: Send command incomplete [%d]", serial
->type
->description
, alen
);
395 pipe
= usb_rcvbulkpipe (serial
->dev
, command_port
->bulk_in_endpointAddress
);
396 /* See the comment on the usb_clear_halt() above */
397 usb_clear_halt(serial
->dev
, pipe
);
398 ret
= usb_bulk_msg (serial
->dev
, pipe
, result
, sizeof(*hw_info
) + 1, &alen
, COMMAND_TIMEOUT_MS
);
400 err("%s: Couldn't get results [%d]", serial
->type
->description
, ret
);
402 } else if (alen
!= sizeof(*hw_info
) + 1) {
403 err("%s: Get results incomplete [%d]", serial
->type
->description
, alen
);
405 } else if (result
[0] != command
[0]) {
406 err("%s: Command failed [%d]", serial
->type
->description
, result
[0]);
410 hw_info
= (struct whiteheat_hw_info
*)&result
[1];
412 info("%s: Driver %s: Firmware v%d.%02d", serial
->type
->description
,
413 DRIVER_VERSION
, hw_info
->sw_major_rev
, hw_info
->sw_minor_rev
);
415 for (i
= 0; i
< serial
->num_ports
; i
++) {
416 port
= serial
->port
[i
];
418 info
= (struct whiteheat_private
*)kmalloc(sizeof(struct whiteheat_private
), GFP_KERNEL
);
420 err("%s: Out of memory for port structures\n", serial
->type
->description
);
424 spin_lock_init(&info
->lock
);
427 INIT_WORK(&info
->rx_work
, rx_data_softint
, port
);
429 INIT_LIST_HEAD(&info
->rx_urbs_free
);
430 INIT_LIST_HEAD(&info
->rx_urbs_submitted
);
431 INIT_LIST_HEAD(&info
->rx_urb_q
);
432 INIT_LIST_HEAD(&info
->tx_urbs_free
);
433 INIT_LIST_HEAD(&info
->tx_urbs_submitted
);
435 for (j
= 0; j
< urb_pool_size
; j
++) {
436 urb
= usb_alloc_urb(0, GFP_KERNEL
);
438 err("No free urbs available");
441 buf_size
= port
->read_urb
->transfer_buffer_length
;
442 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
443 if (!urb
->transfer_buffer
) {
444 err("Couldn't allocate urb buffer");
447 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
449 err("Couldn't allocate urb wrapper");
452 usb_fill_bulk_urb(urb
, serial
->dev
,
453 usb_rcvbulkpipe(serial
->dev
,
454 port
->bulk_in_endpointAddress
),
455 urb
->transfer_buffer
, buf_size
,
456 whiteheat_read_callback
, port
);
458 list_add(&wrap
->list
, &info
->rx_urbs_free
);
460 urb
= usb_alloc_urb(0, GFP_KERNEL
);
462 err("No free urbs available");
465 buf_size
= port
->write_urb
->transfer_buffer_length
;
466 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
467 if (!urb
->transfer_buffer
) {
468 err("Couldn't allocate urb buffer");
471 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
473 err("Couldn't allocate urb wrapper");
476 usb_fill_bulk_urb(urb
, serial
->dev
,
477 usb_sndbulkpipe(serial
->dev
,
478 port
->bulk_out_endpointAddress
),
479 urb
->transfer_buffer
, buf_size
,
480 whiteheat_write_callback
, port
);
482 list_add(&wrap
->list
, &info
->tx_urbs_free
);
485 usb_set_serial_port_data(port
, info
);
488 command_info
= (struct whiteheat_command_private
*)kmalloc(sizeof(struct whiteheat_command_private
), GFP_KERNEL
);
489 if (command_info
== NULL
) {
490 err("%s: Out of memory for port structures\n", serial
->type
->description
);
491 goto no_command_private
;
494 spin_lock_init(&command_info
->lock
);
495 command_info
->port_running
= 0;
496 init_waitqueue_head(&command_info
->wait_command
);
497 usb_set_serial_port_data(command_port
, command_info
);
498 command_port
->write_urb
->complete
= command_port_write_callback
;
499 command_port
->read_urb
->complete
= command_port_read_callback
;
506 /* Firmware likely not running */
507 err("%s: Unable to retrieve firmware version, try replugging\n", serial
->type
->description
);
508 err("%s: If the firmware is not running (status led not blinking)\n", serial
->type
->description
);
509 err("%s: please contact support@connecttech.com\n", serial
->type
->description
);
514 for (i
= serial
->num_ports
- 1; i
>= 0; i
--) {
515 port
= serial
->port
[i
];
516 info
= usb_get_serial_port_data(port
);
517 for (j
= urb_pool_size
- 1; j
>= 0; j
--) {
518 tmp
= list_first(&info
->tx_urbs_free
);
520 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
524 kfree(urb
->transfer_buffer
);
528 tmp
= list_first(&info
->rx_urbs_free
);
530 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
534 kfree(urb
->transfer_buffer
);
552 static void whiteheat_shutdown (struct usb_serial
*serial
)
554 struct usb_serial_port
*command_port
;
555 struct usb_serial_port
*port
;
556 struct whiteheat_private
*info
;
557 struct whiteheat_urb_wrap
*wrap
;
559 struct list_head
*tmp
;
560 struct list_head
*tmp2
;
563 dbg("%s", __FUNCTION__
);
565 /* free up our private data for our command port */
566 command_port
= serial
->port
[COMMAND_PORT
];
567 kfree (usb_get_serial_port_data(command_port
));
569 for (i
= 0; i
< serial
->num_ports
; i
++) {
570 port
= serial
->port
[i
];
571 info
= usb_get_serial_port_data(port
);
572 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
574 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
577 kfree(urb
->transfer_buffer
);
580 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_free
) {
582 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
585 kfree(urb
->transfer_buffer
);
595 static int whiteheat_open (struct usb_serial_port
*port
, struct file
*filp
)
598 struct termios old_term
;
600 dbg("%s - port %d", __FUNCTION__
, port
->number
);
602 retval
= start_command_port(port
->serial
);
607 port
->tty
->low_latency
= 1;
609 /* send an open port command */
610 retval
= firm_open(port
);
612 stop_command_port(port
->serial
);
616 retval
= firm_purge(port
, WHITEHEAT_PURGE_RX
| WHITEHEAT_PURGE_TX
);
619 stop_command_port(port
->serial
);
623 old_term
.c_cflag
= ~port
->tty
->termios
->c_cflag
;
624 old_term
.c_iflag
= ~port
->tty
->termios
->c_iflag
;
625 whiteheat_set_termios(port
, &old_term
);
627 /* Work around HCD bugs */
628 usb_clear_halt(port
->serial
->dev
, port
->read_urb
->pipe
);
629 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
631 /* Start reading from the device */
632 retval
= start_port_read(port
);
634 err("%s - failed submitting read urb, error %d", __FUNCTION__
, retval
);
636 stop_command_port(port
->serial
);
641 dbg("%s - exit, retval = %d", __FUNCTION__
, retval
);
646 static void whiteheat_close(struct usb_serial_port
*port
, struct file
* filp
)
648 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
649 struct whiteheat_urb_wrap
*wrap
;
651 struct list_head
*tmp
;
652 struct list_head
*tmp2
;
655 dbg("%s - port %d", __FUNCTION__
, port
->number
);
657 /* filp is NULL when called from usb_serial_disconnect */
658 if (filp
&& (tty_hung_up_p(filp
))) {
662 port
->tty
->closing
= 1;
665 * Not currently in use; tty_wait_until_sent() calls
666 * serial_chars_in_buffer() which deadlocks on the second semaphore
667 * acquisition. This should be fixed at some point. Greg's been
669 if ((filp->f_flags & (O_NDELAY | O_NONBLOCK)) == 0) {
670 tty_wait_until_sent(port->tty, CLOSING_DELAY);
674 if (port
->tty
->driver
->flush_buffer
)
675 port
->tty
->driver
->flush_buffer(port
->tty
);
676 tty_ldisc_flush(port
->tty
);
678 firm_report_tx_done(port
);
682 /* shutdown our bulk reads and writes */
683 spin_lock_irqsave(&info
->lock
, flags
);
684 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
685 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
688 list_move(tmp
, &info
->rx_urbs_free
);
690 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
)
691 list_move(tmp
, &info
->rx_urbs_free
);
693 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_submitted
) {
694 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
697 list_move(tmp
, &info
->tx_urbs_free
);
699 spin_unlock_irqrestore(&info
->lock
, flags
);
701 stop_command_port(port
->serial
);
703 port
->tty
->closing
= 0;
707 static int whiteheat_write(struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
709 struct usb_serial
*serial
= port
->serial
;
710 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
711 struct whiteheat_urb_wrap
*wrap
;
717 struct list_head
*tmp
;
719 dbg("%s - port %d", __FUNCTION__
, port
->number
);
722 dbg("%s - write request of 0 bytes", __FUNCTION__
);
727 spin_lock_irqsave(&info
->lock
, flags
);
728 if (list_empty(&info
->tx_urbs_free
)) {
729 spin_unlock_irqrestore(&info
->lock
, flags
);
732 tmp
= list_first(&info
->tx_urbs_free
);
734 spin_unlock_irqrestore(&info
->lock
, flags
);
736 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
738 bytes
= (count
> port
->bulk_out_size
) ? port
->bulk_out_size
: count
;
739 memcpy (urb
->transfer_buffer
, buf
+ sent
, bytes
);
741 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, bytes
, urb
->transfer_buffer
);
743 urb
->dev
= serial
->dev
;
744 urb
->transfer_buffer_length
= bytes
;
745 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
747 err("%s - failed submitting write urb, error %d", __FUNCTION__
, result
);
749 spin_lock_irqsave(&info
->lock
, flags
);
750 list_add(tmp
, &info
->tx_urbs_free
);
751 spin_unlock_irqrestore(&info
->lock
, flags
);
756 spin_lock_irqsave(&info
->lock
, flags
);
757 list_add(tmp
, &info
->tx_urbs_submitted
);
758 spin_unlock_irqrestore(&info
->lock
, flags
);
766 static int whiteheat_write_room(struct usb_serial_port
*port
)
768 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
769 struct list_head
*tmp
;
773 dbg("%s - port %d", __FUNCTION__
, port
->number
);
775 spin_lock_irqsave(&info
->lock
, flags
);
776 list_for_each(tmp
, &info
->tx_urbs_free
)
778 spin_unlock_irqrestore(&info
->lock
, flags
);
779 room
*= port
->bulk_out_size
;
781 dbg("%s - returns %d", __FUNCTION__
, room
);
786 static int whiteheat_tiocmget (struct usb_serial_port
*port
, struct file
*file
)
788 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
789 unsigned int modem_signals
= 0;
791 dbg("%s - port %d", __FUNCTION__
, port
->number
);
793 firm_get_dtr_rts(port
);
794 if (info
->mcr
& UART_MCR_DTR
)
795 modem_signals
|= TIOCM_DTR
;
796 if (info
->mcr
& UART_MCR_RTS
)
797 modem_signals
|= TIOCM_RTS
;
799 return modem_signals
;
803 static int whiteheat_tiocmset (struct usb_serial_port
*port
, struct file
*file
,
804 unsigned int set
, unsigned int clear
)
806 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
808 dbg("%s - port %d", __FUNCTION__
, port
->number
);
811 info
->mcr
|= UART_MCR_RTS
;
813 info
->mcr
|= UART_MCR_DTR
;
815 if (clear
& TIOCM_RTS
)
816 info
->mcr
&= ~UART_MCR_RTS
;
817 if (clear
& TIOCM_DTR
)
818 info
->mcr
&= ~UART_MCR_DTR
;
820 firm_set_dtr(port
, info
->mcr
& UART_MCR_DTR
);
821 firm_set_rts(port
, info
->mcr
& UART_MCR_RTS
);
826 static int whiteheat_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
)
828 struct serial_struct serstruct
;
829 void __user
*user_arg
= (void __user
*)arg
;
831 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__
, port
->number
, cmd
);
835 memset(&serstruct
, 0, sizeof(serstruct
));
836 serstruct
.type
= PORT_16654
;
837 serstruct
.line
= port
->serial
->minor
;
838 serstruct
.port
= port
->number
;
839 serstruct
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
840 serstruct
.xmit_fifo_size
= port
->bulk_out_size
;
841 serstruct
.custom_divisor
= 0;
842 serstruct
.baud_base
= 460800;
843 serstruct
.close_delay
= CLOSING_DELAY
;
844 serstruct
.closing_wait
= CLOSING_DELAY
;
846 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
852 if (copy_from_user(&serstruct
, user_arg
, sizeof(serstruct
)))
856 * For now this is ignored. dip sets the ASYNC_[V]HI flags
857 * but this isn't used by us at all. Maybe someone somewhere
858 * will need the custom_divisor setting.
871 static void whiteheat_set_termios (struct usb_serial_port
*port
, struct termios
*old_termios
)
873 dbg("%s -port %d", __FUNCTION__
, port
->number
);
875 if ((!port
->tty
) || (!port
->tty
->termios
)) {
876 dbg("%s - no tty structures", __FUNCTION__
);
880 /* check that they really want us to change something */
882 if ((port
->tty
->termios
->c_cflag
== old_termios
->c_cflag
) &&
883 (port
->tty
->termios
->c_iflag
== old_termios
->c_iflag
)) {
884 dbg("%s - nothing to change...", __FUNCTION__
);
889 firm_setup_port(port
);
896 static void whiteheat_break_ctl(struct usb_serial_port
*port
, int break_state
) {
897 firm_set_break(port
, break_state
);
901 static int whiteheat_chars_in_buffer(struct usb_serial_port
*port
)
903 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
904 struct list_head
*tmp
;
905 struct whiteheat_urb_wrap
*wrap
;
909 dbg("%s - port %d", __FUNCTION__
, port
->number
);
911 spin_lock_irqsave(&info
->lock
, flags
);
912 list_for_each(tmp
, &info
->tx_urbs_submitted
) {
913 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
914 chars
+= wrap
->urb
->transfer_buffer_length
;
916 spin_unlock_irqrestore(&info
->lock
, flags
);
918 dbg ("%s - returns %d", __FUNCTION__
, chars
);
923 static void whiteheat_throttle (struct usb_serial_port
*port
)
925 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
928 dbg("%s - port %d", __FUNCTION__
, port
->number
);
930 spin_lock_irqsave(&info
->lock
, flags
);
931 info
->flags
|= THROTTLED
;
932 spin_unlock_irqrestore(&info
->lock
, flags
);
938 static void whiteheat_unthrottle (struct usb_serial_port
*port
)
940 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
941 int actually_throttled
;
944 dbg("%s - port %d", __FUNCTION__
, port
->number
);
946 spin_lock_irqsave(&info
->lock
, flags
);
947 actually_throttled
= info
->flags
& ACTUALLY_THROTTLED
;
948 info
->flags
&= ~(THROTTLED
| ACTUALLY_THROTTLED
);
949 spin_unlock_irqrestore(&info
->lock
, flags
);
951 if (actually_throttled
)
952 rx_data_softint(port
);
958 /*****************************************************************************
959 * Connect Tech's White Heat callback routines
960 *****************************************************************************/
961 static void command_port_write_callback (struct urb
*urb
, struct pt_regs
*regs
)
963 dbg("%s", __FUNCTION__
);
966 dbg ("nonzero urb status: %d", urb
->status
);
972 static void command_port_read_callback (struct urb
*urb
, struct pt_regs
*regs
)
974 struct usb_serial_port
*command_port
= (struct usb_serial_port
*)urb
->context
;
975 struct whiteheat_command_private
*command_info
;
976 unsigned char *data
= urb
->transfer_buffer
;
980 dbg("%s", __FUNCTION__
);
983 dbg("%s - nonzero urb status: %d", __FUNCTION__
, urb
->status
);
987 usb_serial_debug_data(debug
, &command_port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
989 command_info
= usb_get_serial_port_data(command_port
);
991 dbg ("%s - command_info is NULL, exiting.", __FUNCTION__
);
994 spin_lock_irqsave(&command_info
->lock
, flags
);
996 if (data
[0] == WHITEHEAT_CMD_COMPLETE
) {
997 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
998 wake_up_interruptible(&command_info
->wait_command
);
999 } else if (data
[0] == WHITEHEAT_CMD_FAILURE
) {
1000 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
1001 wake_up_interruptible(&command_info
->wait_command
);
1002 } else if (data
[0] == WHITEHEAT_EVENT
) {
1003 /* These are unsolicited reports from the firmware, hence no waiting command to wakeup */
1004 dbg("%s - event received", __FUNCTION__
);
1005 } else if (data
[0] == WHITEHEAT_GET_DTR_RTS
) {
1006 memcpy(command_info
->result_buffer
, &data
[1], urb
->actual_length
- 1);
1007 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
1008 wake_up_interruptible(&command_info
->wait_command
);
1010 dbg("%s - bad reply from firmware", __FUNCTION__
);
1013 /* Continue trying to always read */
1014 command_port
->read_urb
->dev
= command_port
->serial
->dev
;
1015 result
= usb_submit_urb(command_port
->read_urb
, GFP_ATOMIC
);
1016 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1018 dbg("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
1022 static void whiteheat_read_callback(struct urb
*urb
, struct pt_regs
*regs
)
1024 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1025 struct whiteheat_urb_wrap
*wrap
;
1026 unsigned char *data
= urb
->transfer_buffer
;
1027 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1029 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1031 spin_lock(&info
->lock
);
1032 wrap
= urb_to_wrap(urb
, &info
->rx_urbs_submitted
);
1034 spin_unlock(&info
->lock
);
1035 err("%s - Not my urb!", __FUNCTION__
);
1038 list_del(&wrap
->list
);
1039 spin_unlock(&info
->lock
);
1042 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__
, urb
->status
);
1043 spin_lock(&info
->lock
);
1044 list_add(&wrap
->list
, &info
->rx_urbs_free
);
1045 spin_unlock(&info
->lock
);
1049 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, urb
->actual_length
, data
);
1051 spin_lock(&info
->lock
);
1052 list_add_tail(&wrap
->list
, &info
->rx_urb_q
);
1053 if (info
->flags
& THROTTLED
) {
1054 info
->flags
|= ACTUALLY_THROTTLED
;
1055 spin_unlock(&info
->lock
);
1058 spin_unlock(&info
->lock
);
1060 schedule_work(&info
->rx_work
);
1064 static void whiteheat_write_callback(struct urb
*urb
, struct pt_regs
*regs
)
1066 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1067 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1068 struct whiteheat_urb_wrap
*wrap
;
1070 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1072 spin_lock(&info
->lock
);
1073 wrap
= urb_to_wrap(urb
, &info
->tx_urbs_submitted
);
1075 spin_unlock(&info
->lock
);
1076 err("%s - Not my urb!", __FUNCTION__
);
1079 list_move(&wrap
->list
, &info
->tx_urbs_free
);
1080 spin_unlock(&info
->lock
);
1083 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__
, urb
->status
);
1087 usb_serial_port_softint(port
);
1091 /*****************************************************************************
1092 * Connect Tech's White Heat firmware interface
1093 *****************************************************************************/
1094 static int firm_send_command (struct usb_serial_port
*port
, __u8 command
, __u8
*data
, __u8 datasize
)
1096 struct usb_serial_port
*command_port
;
1097 struct whiteheat_command_private
*command_info
;
1098 struct whiteheat_private
*info
;
1099 __u8
*transfer_buffer
;
1101 unsigned long flags
;
1103 dbg("%s - command %d", __FUNCTION__
, command
);
1105 command_port
= port
->serial
->port
[COMMAND_PORT
];
1106 command_info
= usb_get_serial_port_data(command_port
);
1107 spin_lock_irqsave(&command_info
->lock
, flags
);
1108 command_info
->command_finished
= FALSE
;
1110 transfer_buffer
= (__u8
*)command_port
->write_urb
->transfer_buffer
;
1111 transfer_buffer
[0] = command
;
1112 memcpy (&transfer_buffer
[1], data
, datasize
);
1113 command_port
->write_urb
->transfer_buffer_length
= datasize
+ 1;
1114 command_port
->write_urb
->dev
= port
->serial
->dev
;
1115 retval
= usb_submit_urb (command_port
->write_urb
, GFP_KERNEL
);
1117 dbg("%s - submit urb failed", __FUNCTION__
);
1120 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1122 /* wait for the command to complete */
1123 wait_event_interruptible_timeout(command_info
->wait_command
,
1124 (command_info
->command_finished
!= FALSE
), COMMAND_TIMEOUT
);
1126 spin_lock_irqsave(&command_info
->lock
, flags
);
1128 if (command_info
->command_finished
== FALSE
) {
1129 dbg("%s - command timed out.", __FUNCTION__
);
1130 retval
= -ETIMEDOUT
;
1134 if (command_info
->command_finished
== WHITEHEAT_CMD_FAILURE
) {
1135 dbg("%s - command failed.", __FUNCTION__
);
1140 if (command_info
->command_finished
== WHITEHEAT_CMD_COMPLETE
) {
1141 dbg("%s - command completed.", __FUNCTION__
);
1143 case WHITEHEAT_GET_DTR_RTS
:
1144 info
= usb_get_serial_port_data(port
);
1145 memcpy(&info
->mcr
, command_info
->result_buffer
, sizeof(struct whiteheat_dr_info
));
1151 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1156 static int firm_open(struct usb_serial_port
*port
) {
1157 struct whiteheat_simple open_command
;
1159 open_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1160 return firm_send_command(port
, WHITEHEAT_OPEN
, (__u8
*)&open_command
, sizeof(open_command
));
1164 static int firm_close(struct usb_serial_port
*port
) {
1165 struct whiteheat_simple close_command
;
1167 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1168 return firm_send_command(port
, WHITEHEAT_CLOSE
, (__u8
*)&close_command
, sizeof(close_command
));
1172 static int firm_setup_port(struct usb_serial_port
*port
) {
1173 struct whiteheat_port_settings port_settings
;
1174 unsigned int cflag
= port
->tty
->termios
->c_cflag
;
1176 port_settings
.port
= port
->number
+ 1;
1178 /* get the byte size */
1179 switch (cflag
& CSIZE
) {
1180 case CS5
: port_settings
.bits
= 5; break;
1181 case CS6
: port_settings
.bits
= 6; break;
1182 case CS7
: port_settings
.bits
= 7; break;
1184 case CS8
: port_settings
.bits
= 8; break;
1186 dbg("%s - data bits = %d", __FUNCTION__
, port_settings
.bits
);
1188 /* determine the parity */
1192 port_settings
.parity
= WHITEHEAT_PAR_MARK
;
1194 port_settings
.parity
= WHITEHEAT_PAR_SPACE
;
1197 port_settings
.parity
= WHITEHEAT_PAR_ODD
;
1199 port_settings
.parity
= WHITEHEAT_PAR_EVEN
;
1201 port_settings
.parity
= WHITEHEAT_PAR_NONE
;
1202 dbg("%s - parity = %c", __FUNCTION__
, port_settings
.parity
);
1204 /* figure out the stop bits requested */
1206 port_settings
.stop
= 2;
1208 port_settings
.stop
= 1;
1209 dbg("%s - stop bits = %d", __FUNCTION__
, port_settings
.stop
);
1211 /* figure out the flow control settings */
1212 if (cflag
& CRTSCTS
)
1213 port_settings
.hflow
= (WHITEHEAT_HFLOW_CTS
| WHITEHEAT_HFLOW_RTS
);
1215 port_settings
.hflow
= WHITEHEAT_HFLOW_NONE
;
1216 dbg("%s - hardware flow control = %s %s %s %s", __FUNCTION__
,
1217 (port_settings
.hflow
& WHITEHEAT_HFLOW_CTS
) ? "CTS" : "",
1218 (port_settings
.hflow
& WHITEHEAT_HFLOW_RTS
) ? "RTS" : "",
1219 (port_settings
.hflow
& WHITEHEAT_HFLOW_DSR
) ? "DSR" : "",
1220 (port_settings
.hflow
& WHITEHEAT_HFLOW_DTR
) ? "DTR" : "");
1222 /* determine software flow control */
1223 if (I_IXOFF(port
->tty
))
1224 port_settings
.sflow
= WHITEHEAT_SFLOW_RXTX
;
1226 port_settings
.sflow
= WHITEHEAT_SFLOW_NONE
;
1227 dbg("%s - software flow control = %c", __FUNCTION__
, port_settings
.sflow
);
1229 port_settings
.xon
= START_CHAR(port
->tty
);
1230 port_settings
.xoff
= STOP_CHAR(port
->tty
);
1231 dbg("%s - XON = %2x, XOFF = %2x", __FUNCTION__
, port_settings
.xon
, port_settings
.xoff
);
1233 /* get the baud rate wanted */
1234 port_settings
.baud
= tty_get_baud_rate(port
->tty
);
1235 dbg("%s - baud rate = %d", __FUNCTION__
, port_settings
.baud
);
1237 /* handle any settings that aren't specified in the tty structure */
1238 port_settings
.lloop
= 0;
1240 /* now send the message to the device */
1241 return firm_send_command(port
, WHITEHEAT_SETUP_PORT
, (__u8
*)&port_settings
, sizeof(port_settings
));
1245 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
) {
1246 struct whiteheat_set_rdb rts_command
;
1248 rts_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1249 rts_command
.state
= onoff
;
1250 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&rts_command
, sizeof(rts_command
));
1254 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
) {
1255 struct whiteheat_set_rdb dtr_command
;
1257 dtr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1258 dtr_command
.state
= onoff
;
1259 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&dtr_command
, sizeof(dtr_command
));
1263 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
) {
1264 struct whiteheat_set_rdb break_command
;
1266 break_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1267 break_command
.state
= onoff
;
1268 return firm_send_command(port
, WHITEHEAT_SET_RTS
, (__u8
*)&break_command
, sizeof(break_command
));
1272 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
) {
1273 struct whiteheat_purge purge_command
;
1275 purge_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1276 purge_command
.what
= rxtx
;
1277 return firm_send_command(port
, WHITEHEAT_PURGE
, (__u8
*)&purge_command
, sizeof(purge_command
));
1281 static int firm_get_dtr_rts(struct usb_serial_port
*port
) {
1282 struct whiteheat_simple get_dr_command
;
1284 get_dr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1285 return firm_send_command(port
, WHITEHEAT_GET_DTR_RTS
, (__u8
*)&get_dr_command
, sizeof(get_dr_command
));
1289 static int firm_report_tx_done(struct usb_serial_port
*port
) {
1290 struct whiteheat_simple close_command
;
1292 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1293 return firm_send_command(port
, WHITEHEAT_REPORT_TX_DONE
, (__u8
*)&close_command
, sizeof(close_command
));
1297 /*****************************************************************************
1298 * Connect Tech's White Heat utility functions
1299 *****************************************************************************/
1300 static int start_command_port(struct usb_serial
*serial
)
1302 struct usb_serial_port
*command_port
;
1303 struct whiteheat_command_private
*command_info
;
1304 unsigned long flags
;
1307 command_port
= serial
->port
[COMMAND_PORT
];
1308 command_info
= usb_get_serial_port_data(command_port
);
1309 spin_lock_irqsave(&command_info
->lock
, flags
);
1310 if (!command_info
->port_running
) {
1311 /* Work around HCD bugs */
1312 usb_clear_halt(serial
->dev
, command_port
->read_urb
->pipe
);
1314 command_port
->read_urb
->dev
= serial
->dev
;
1315 retval
= usb_submit_urb(command_port
->read_urb
, GFP_KERNEL
);
1317 err("%s - failed submitting read urb, error %d", __FUNCTION__
, retval
);
1321 command_info
->port_running
++;
1324 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1329 static void stop_command_port(struct usb_serial
*serial
)
1331 struct usb_serial_port
*command_port
;
1332 struct whiteheat_command_private
*command_info
;
1333 unsigned long flags
;
1335 command_port
= serial
->port
[COMMAND_PORT
];
1336 command_info
= usb_get_serial_port_data(command_port
);
1337 spin_lock_irqsave(&command_info
->lock
, flags
);
1338 command_info
->port_running
--;
1339 if (!command_info
->port_running
)
1340 usb_kill_urb(command_port
->read_urb
);
1341 spin_unlock_irqrestore(&command_info
->lock
, flags
);
1345 static int start_port_read(struct usb_serial_port
*port
)
1347 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1348 struct whiteheat_urb_wrap
*wrap
;
1351 unsigned long flags
;
1352 struct list_head
*tmp
;
1353 struct list_head
*tmp2
;
1355 spin_lock_irqsave(&info
->lock
, flags
);
1357 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
1359 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1361 urb
->dev
= port
->serial
->dev
;
1362 retval
= usb_submit_urb(urb
, GFP_KERNEL
);
1364 list_add(tmp
, &info
->rx_urbs_free
);
1365 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
1366 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1369 list_move(tmp
, &info
->rx_urbs_free
);
1373 list_add(tmp
, &info
->rx_urbs_submitted
);
1376 spin_unlock_irqrestore(&info
->lock
, flags
);
1382 static struct whiteheat_urb_wrap
*urb_to_wrap(struct urb
* urb
, struct list_head
*head
)
1384 struct whiteheat_urb_wrap
*wrap
;
1385 struct list_head
*tmp
;
1387 list_for_each(tmp
, head
) {
1388 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1389 if (wrap
->urb
== urb
)
1397 static struct list_head
*list_first(struct list_head
*head
)
1403 static void rx_data_softint(void *private)
1405 struct usb_serial_port
*port
= (struct usb_serial_port
*)private;
1406 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1407 struct tty_struct
*tty
= port
->tty
;
1408 struct whiteheat_urb_wrap
*wrap
;
1410 unsigned long flags
;
1411 struct list_head
*tmp
;
1412 struct list_head
*tmp2
;
1416 spin_lock_irqsave(&info
->lock
, flags
);
1417 if (info
->flags
& THROTTLED
) {
1418 spin_unlock_irqrestore(&info
->lock
, flags
);
1422 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
) {
1424 spin_unlock_irqrestore(&info
->lock
, flags
);
1426 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1429 if (tty
&& urb
->actual_length
) {
1430 int len
= tty_buffer_request_room(tty
, urb
->actual_length
);
1431 /* This stuff can go away now I suspect */
1432 if (unlikely(len
< urb
->actual_length
)) {
1433 spin_lock_irqsave(&info
->lock
, flags
);
1434 list_add(tmp
, &info
->rx_urb_q
);
1435 spin_unlock_irqrestore(&info
->lock
, flags
);
1436 tty_flip_buffer_push(tty
);
1437 schedule_work(&info
->rx_work
);
1440 tty_insert_flip_string(tty
, urb
->transfer_buffer
, len
);
1444 urb
->dev
= port
->serial
->dev
;
1445 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1447 err("%s - failed resubmitting read urb, error %d", __FUNCTION__
, result
);
1448 spin_lock_irqsave(&info
->lock
, flags
);
1449 list_add(tmp
, &info
->rx_urbs_free
);
1453 spin_lock_irqsave(&info
->lock
, flags
);
1454 list_add(tmp
, &info
->rx_urbs_submitted
);
1456 spin_unlock_irqrestore(&info
->lock
, flags
);
1459 tty_flip_buffer_push(tty
);
1463 /*****************************************************************************
1464 * Connect Tech's White Heat module functions
1465 *****************************************************************************/
1466 static int __init
whiteheat_init (void)
1469 retval
= usb_serial_register(&whiteheat_fake_device
);
1471 goto failed_fake_register
;
1472 retval
= usb_serial_register(&whiteheat_device
);
1474 goto failed_device_register
;
1475 retval
= usb_register(&whiteheat_driver
);
1477 goto failed_usb_register
;
1478 info(DRIVER_DESC
" " DRIVER_VERSION
);
1480 failed_usb_register
:
1481 usb_serial_deregister(&whiteheat_device
);
1482 failed_device_register
:
1483 usb_serial_deregister(&whiteheat_fake_device
);
1484 failed_fake_register
:
1489 static void __exit
whiteheat_exit (void)
1491 usb_deregister (&whiteheat_driver
);
1492 usb_serial_deregister (&whiteheat_fake_device
);
1493 usb_serial_deregister (&whiteheat_device
);
1497 module_init(whiteheat_init
);
1498 module_exit(whiteheat_exit
);
1500 MODULE_AUTHOR( DRIVER_AUTHOR
);
1501 MODULE_DESCRIPTION( DRIVER_DESC
);
1502 MODULE_LICENSE("GPL");
1504 module_param(urb_pool_size
, int, 0);
1505 MODULE_PARM_DESC(urb_pool_size
, "Number of urbs to use for buffering");
1507 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1508 MODULE_PARM_DESC(debug
, "Debug enabled or not");