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
18 * (10/09/2002) Stuart MacDonald (stuartm@connecttech.com)
19 * Upgrade to full working driver
22 * switched from using spinlock to a semaphore, which fixes lots of
26 * Identify version on module load.
29 * Fixed MOD_INC and MOD_DEC logic, the ability to open a port more
30 * than once, and the got the proper usb_device_id table entries so
31 * the driver works again.
33 * (11/01/2000) Adam J. Richter
34 * usb_device_id table support
37 * Fixed bug with urb->dev not being set properly, now that the usb
41 * firmware is improved to guard against crap sent to device
42 * firmware now replies CMD_FAILURE on bad things
43 * read_callback fix you provided for private info struct
44 * command_finished now indicates success or fail
45 * setup_port struct now packed to avoid gcc padding
46 * firmware uses 1 based port numbering, driver now handles that
49 * Removed DEBUG #ifdefs with call to usb_serial_debug_data
52 * Added module_init and module_exit functions to handle the fact that this
53 * driver is a loadable module now.
54 * Fixed bug with port->minor that was found by Al Borchers
57 * Added support for port settings. Baud rate can now be changed. Line
58 * signals are not transferred to and from the tty layer yet, but things
59 * seem to be working well now.
62 * First cut at open and close commands. Data can flow through the ports at
66 * Split driver up into device specific pieces.
70 #include <linux/kernel.h>
71 #include <linux/errno.h>
72 #include <linux/init.h>
73 #include <linux/slab.h>
74 #include <linux/tty.h>
75 #include <linux/tty_driver.h>
76 #include <linux/tty_flip.h>
77 #include <linux/module.h>
78 #include <linux/spinlock.h>
79 #include <linux/mutex.h>
80 #include <linux/uaccess.h>
81 #include <asm/termbits.h>
82 #include <linux/usb.h>
83 #include <linux/serial_reg.h>
84 #include <linux/serial.h>
85 #include <linux/usb/serial.h>
86 #include <linux/firmware.h>
87 #include <linux/ihex.h>
88 #include "whiteheat.h" /* WhiteHEAT specific commands */
99 #define DRIVER_VERSION "v2.0"
100 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Stuart MacDonald <stuartm@connecttech.com>"
101 #define DRIVER_DESC "USB ConnectTech WhiteHEAT driver"
103 #define CONNECT_TECH_VENDOR_ID 0x0710
104 #define CONNECT_TECH_FAKE_WHITE_HEAT_ID 0x0001
105 #define CONNECT_TECH_WHITE_HEAT_ID 0x8001
108 ID tables for whiteheat are unusual, because we want to different
109 things for different versions of the device. Eventually, this
110 will be doable from a single table. But, for now, we define two
111 separate ID tables, and then a third table that combines them
112 just for the purpose of exporting the autoloading information.
114 static struct usb_device_id id_table_std
[] = {
115 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
116 { } /* Terminating entry */
119 static struct usb_device_id id_table_prerenumeration
[] = {
120 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
121 { } /* Terminating entry */
124 static struct usb_device_id id_table_combined
[] = {
125 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
126 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
127 { } /* Terminating entry */
130 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
132 static struct usb_driver whiteheat_driver
= {
134 .probe
= usb_serial_probe
,
135 .disconnect
= usb_serial_disconnect
,
136 .id_table
= id_table_combined
,
140 /* function prototypes for the Connect Tech WhiteHEAT prerenumeration device */
141 static int whiteheat_firmware_download(struct usb_serial
*serial
,
142 const struct usb_device_id
*id
);
143 static int whiteheat_firmware_attach(struct usb_serial
*serial
);
145 /* function prototypes for the Connect Tech WhiteHEAT serial converter */
146 static int whiteheat_attach(struct usb_serial
*serial
);
147 static void whiteheat_shutdown(struct usb_serial
*serial
);
148 static int whiteheat_open(struct tty_struct
*tty
,
149 struct usb_serial_port
*port
, struct file
*filp
);
150 static void whiteheat_close(struct usb_serial_port
*port
);
151 static int whiteheat_write(struct tty_struct
*tty
,
152 struct usb_serial_port
*port
,
153 const unsigned char *buf
, int count
);
154 static int whiteheat_write_room(struct tty_struct
*tty
);
155 static int whiteheat_ioctl(struct tty_struct
*tty
, struct file
*file
,
156 unsigned int cmd
, unsigned long arg
);
157 static void whiteheat_set_termios(struct tty_struct
*tty
,
158 struct usb_serial_port
*port
, struct ktermios
*old
);
159 static int whiteheat_tiocmget(struct tty_struct
*tty
, struct file
*file
);
160 static int whiteheat_tiocmset(struct tty_struct
*tty
, struct file
*file
,
161 unsigned int set
, unsigned int clear
);
162 static void whiteheat_break_ctl(struct tty_struct
*tty
, int break_state
);
163 static int whiteheat_chars_in_buffer(struct tty_struct
*tty
);
164 static void whiteheat_throttle(struct tty_struct
*tty
);
165 static void whiteheat_unthrottle(struct tty_struct
*tty
);
166 static void whiteheat_read_callback(struct urb
*urb
);
167 static void whiteheat_write_callback(struct urb
*urb
);
169 static struct usb_serial_driver whiteheat_fake_device
= {
171 .owner
= THIS_MODULE
,
172 .name
= "whiteheatnofirm",
174 .description
= "Connect Tech - WhiteHEAT - (prerenumeration)",
175 .usb_driver
= &whiteheat_driver
,
176 .id_table
= id_table_prerenumeration
,
178 .probe
= whiteheat_firmware_download
,
179 .attach
= whiteheat_firmware_attach
,
182 static struct usb_serial_driver whiteheat_device
= {
184 .owner
= THIS_MODULE
,
187 .description
= "Connect Tech - WhiteHEAT",
188 .usb_driver
= &whiteheat_driver
,
189 .id_table
= id_table_std
,
191 .attach
= whiteheat_attach
,
192 .shutdown
= whiteheat_shutdown
,
193 .open
= whiteheat_open
,
194 .close
= whiteheat_close
,
195 .write
= whiteheat_write
,
196 .write_room
= whiteheat_write_room
,
197 .ioctl
= whiteheat_ioctl
,
198 .set_termios
= whiteheat_set_termios
,
199 .break_ctl
= whiteheat_break_ctl
,
200 .tiocmget
= whiteheat_tiocmget
,
201 .tiocmset
= whiteheat_tiocmset
,
202 .chars_in_buffer
= whiteheat_chars_in_buffer
,
203 .throttle
= whiteheat_throttle
,
204 .unthrottle
= whiteheat_unthrottle
,
205 .read_bulk_callback
= whiteheat_read_callback
,
206 .write_bulk_callback
= whiteheat_write_callback
,
210 struct whiteheat_command_private
{
213 __u8 command_finished
;
214 wait_queue_head_t wait_command
; /* for handling sleeping whilst
215 waiting for a command to
217 __u8 result_buffer
[64];
221 #define THROTTLED 0x01
222 #define ACTUALLY_THROTTLED 0x02
224 static int urb_pool_size
= 8;
226 struct whiteheat_urb_wrap
{
227 struct list_head list
;
231 struct whiteheat_private
{
234 __u8 mcr
; /* FIXME: no locking on mcr */
235 struct list_head rx_urbs_free
;
236 struct list_head rx_urbs_submitted
;
237 struct list_head rx_urb_q
;
238 struct work_struct rx_work
;
239 struct usb_serial_port
*port
;
240 struct list_head tx_urbs_free
;
241 struct list_head tx_urbs_submitted
;
242 struct mutex deathwarrant
;
246 /* local function prototypes */
247 static int start_command_port(struct usb_serial
*serial
);
248 static void stop_command_port(struct usb_serial
*serial
);
249 static void command_port_write_callback(struct urb
*urb
);
250 static void command_port_read_callback(struct urb
*urb
);
252 static int start_port_read(struct usb_serial_port
*port
);
253 static struct whiteheat_urb_wrap
*urb_to_wrap(struct urb
*urb
,
254 struct list_head
*head
);
255 static struct list_head
*list_first(struct list_head
*head
);
256 static void rx_data_softint(struct work_struct
*work
);
258 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
,
259 __u8
*data
, __u8 datasize
);
260 static int firm_open(struct usb_serial_port
*port
);
261 static int firm_close(struct usb_serial_port
*port
);
262 static int firm_setup_port(struct tty_struct
*tty
);
263 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
);
264 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
);
265 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
);
266 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
);
267 static int firm_get_dtr_rts(struct usb_serial_port
*port
);
268 static int firm_report_tx_done(struct usb_serial_port
*port
);
271 #define COMMAND_PORT 4
272 #define COMMAND_TIMEOUT (2*HZ) /* 2 second timeout for a command */
273 #define COMMAND_TIMEOUT_MS 2000
274 #define CLOSING_DELAY (30 * HZ)
277 /*****************************************************************************
278 * Connect Tech's White Heat prerenumeration driver functions
279 *****************************************************************************/
281 /* steps to download the firmware to the WhiteHEAT device:
282 - hold the reset (by writing to the reset bit of the CPUCS register)
283 - download the VEND_AX.HEX file to the chip using VENDOR_REQUEST-ANCHOR_LOAD
284 - release the reset (by writing to the CPUCS register)
285 - download the WH.HEX file for all addresses greater than 0x1b3f using
286 VENDOR_REQUEST-ANCHOR_EXTERNAL_RAM_LOAD
288 - download the WH.HEX file for all addresses less than 0x1b40 using
289 VENDOR_REQUEST_ANCHOR_LOAD
291 - device renumerated itself and comes up as new device id with all
292 firmware download completed.
294 static int whiteheat_firmware_download(struct usb_serial
*serial
,
295 const struct usb_device_id
*id
)
297 int response
, ret
= -ENOENT
;
298 const struct firmware
*loader_fw
= NULL
, *firmware_fw
= NULL
;
299 const struct ihex_binrec
*record
;
303 if (request_ihex_firmware(&firmware_fw
, "whiteheat.fw",
304 &serial
->dev
->dev
)) {
305 dev_err(&serial
->dev
->dev
,
306 "%s - request \"whiteheat.fw\" failed\n", __func__
);
309 if (request_ihex_firmware(&loader_fw
, "whiteheat_loader.fw",
310 &serial
->dev
->dev
)) {
311 dev_err(&serial
->dev
->dev
,
312 "%s - request \"whiteheat_loader.fw\" failed\n",
317 response
= ezusb_set_reset (serial
, 1);
319 record
= (const struct ihex_binrec
*)loader_fw
->data
;
321 response
= ezusb_writememory (serial
, be32_to_cpu(record
->addr
),
322 (unsigned char *)record
->data
,
323 be16_to_cpu(record
->len
), 0xa0);
325 dev_err(&serial
->dev
->dev
, "%s - ezusb_writememory "
326 "failed for loader (%d %04X %p %d)\n",
327 __func__
, response
, be32_to_cpu(record
->addr
),
328 record
->data
, be16_to_cpu(record
->len
));
331 record
= ihex_next_binrec(record
);
334 response
= ezusb_set_reset(serial
, 0);
336 record
= (const struct ihex_binrec
*)firmware_fw
->data
;
337 while (record
&& be32_to_cpu(record
->addr
) < 0x1b40)
338 record
= ihex_next_binrec(record
);
340 response
= ezusb_writememory (serial
, be32_to_cpu(record
->addr
),
341 (unsigned char *)record
->data
,
342 be16_to_cpu(record
->len
), 0xa3);
344 dev_err(&serial
->dev
->dev
, "%s - ezusb_writememory "
345 "failed for first firmware step "
346 "(%d %04X %p %d)\n", __func__
, response
,
347 be32_to_cpu(record
->addr
), record
->data
,
348 be16_to_cpu(record
->len
));
354 response
= ezusb_set_reset(serial
, 1);
356 record
= (const struct ihex_binrec
*)firmware_fw
->data
;
357 while (record
&& be32_to_cpu(record
->addr
) < 0x1b40) {
358 response
= ezusb_writememory (serial
, be32_to_cpu(record
->addr
),
359 (unsigned char *)record
->data
,
360 be16_to_cpu(record
->len
), 0xa0);
362 dev_err(&serial
->dev
->dev
, "%s - ezusb_writememory "
363 "failed for second firmware step "
364 "(%d %04X %p %d)\n", __func__
, response
,
365 be32_to_cpu(record
->addr
), record
->data
,
366 be16_to_cpu(record
->len
));
372 response
= ezusb_set_reset (serial
, 0);
374 release_firmware(loader_fw
);
375 release_firmware(firmware_fw
);
380 static int whiteheat_firmware_attach(struct usb_serial
*serial
)
382 /* We want this device to fail to have a driver assigned to it */
387 /*****************************************************************************
388 * Connect Tech's White Heat serial driver functions
389 *****************************************************************************/
390 static int whiteheat_attach(struct usb_serial
*serial
)
392 struct usb_serial_port
*command_port
;
393 struct whiteheat_command_private
*command_info
;
394 struct usb_serial_port
*port
;
395 struct whiteheat_private
*info
;
396 struct whiteheat_hw_info
*hw_info
;
406 struct whiteheat_urb_wrap
*wrap
;
407 struct list_head
*tmp
;
409 command_port
= serial
->port
[COMMAND_PORT
];
411 pipe
= usb_sndbulkpipe(serial
->dev
,
412 command_port
->bulk_out_endpointAddress
);
413 command
= kmalloc(2, GFP_KERNEL
);
415 goto no_command_buffer
;
416 command
[0] = WHITEHEAT_GET_HW_INFO
;
419 result
= kmalloc(sizeof(*hw_info
) + 1, GFP_KERNEL
);
421 goto no_result_buffer
;
423 * When the module is reloaded the firmware is still there and
424 * the endpoints are still in the usb core unchanged. This is the
425 * unlinking bug in disguise. Same for the call below.
427 usb_clear_halt(serial
->dev
, pipe
);
428 ret
= usb_bulk_msg(serial
->dev
, pipe
, command
, 2,
429 &alen
, COMMAND_TIMEOUT_MS
);
431 dev_err(&serial
->dev
->dev
, "%s: Couldn't send command [%d]\n",
432 serial
->type
->description
, ret
);
434 } else if (alen
!= 2) {
435 dev_err(&serial
->dev
->dev
, "%s: Send command incomplete [%d]\n",
436 serial
->type
->description
, alen
);
440 pipe
= usb_rcvbulkpipe(serial
->dev
,
441 command_port
->bulk_in_endpointAddress
);
442 /* See the comment on the usb_clear_halt() above */
443 usb_clear_halt(serial
->dev
, pipe
);
444 ret
= usb_bulk_msg(serial
->dev
, pipe
, result
,
445 sizeof(*hw_info
) + 1, &alen
, COMMAND_TIMEOUT_MS
);
447 dev_err(&serial
->dev
->dev
, "%s: Couldn't get results [%d]\n",
448 serial
->type
->description
, ret
);
450 } else if (alen
!= sizeof(*hw_info
) + 1) {
451 dev_err(&serial
->dev
->dev
, "%s: Get results incomplete [%d]\n",
452 serial
->type
->description
, alen
);
454 } else if (result
[0] != command
[0]) {
455 dev_err(&serial
->dev
->dev
, "%s: Command failed [%d]\n",
456 serial
->type
->description
, result
[0]);
460 hw_info
= (struct whiteheat_hw_info
*)&result
[1];
462 dev_info(&serial
->dev
->dev
, "%s: Driver %s: Firmware v%d.%02d\n",
463 serial
->type
->description
, DRIVER_VERSION
,
464 hw_info
->sw_major_rev
, hw_info
->sw_minor_rev
);
466 for (i
= 0; i
< serial
->num_ports
; i
++) {
467 port
= serial
->port
[i
];
469 info
= kmalloc(sizeof(struct whiteheat_private
), GFP_KERNEL
);
472 "%s: Out of memory for port structures\n",
473 serial
->type
->description
);
477 spin_lock_init(&info
->lock
);
478 mutex_init(&info
->deathwarrant
);
481 INIT_WORK(&info
->rx_work
, rx_data_softint
);
484 INIT_LIST_HEAD(&info
->rx_urbs_free
);
485 INIT_LIST_HEAD(&info
->rx_urbs_submitted
);
486 INIT_LIST_HEAD(&info
->rx_urb_q
);
487 INIT_LIST_HEAD(&info
->tx_urbs_free
);
488 INIT_LIST_HEAD(&info
->tx_urbs_submitted
);
490 for (j
= 0; j
< urb_pool_size
; j
++) {
491 urb
= usb_alloc_urb(0, GFP_KERNEL
);
493 dev_err(&port
->dev
, "No free urbs available\n");
496 buf_size
= port
->read_urb
->transfer_buffer_length
;
497 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
498 if (!urb
->transfer_buffer
) {
500 "Couldn't allocate urb buffer\n");
503 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
506 "Couldn't allocate urb wrapper\n");
509 usb_fill_bulk_urb(urb
, serial
->dev
,
510 usb_rcvbulkpipe(serial
->dev
,
511 port
->bulk_in_endpointAddress
),
512 urb
->transfer_buffer
, buf_size
,
513 whiteheat_read_callback
, port
);
515 list_add(&wrap
->list
, &info
->rx_urbs_free
);
517 urb
= usb_alloc_urb(0, GFP_KERNEL
);
519 dev_err(&port
->dev
, "No free urbs available\n");
522 buf_size
= port
->write_urb
->transfer_buffer_length
;
523 urb
->transfer_buffer
= kmalloc(buf_size
, GFP_KERNEL
);
524 if (!urb
->transfer_buffer
) {
526 "Couldn't allocate urb buffer\n");
529 wrap
= kmalloc(sizeof(*wrap
), GFP_KERNEL
);
532 "Couldn't allocate urb wrapper\n");
535 usb_fill_bulk_urb(urb
, serial
->dev
,
536 usb_sndbulkpipe(serial
->dev
,
537 port
->bulk_out_endpointAddress
),
538 urb
->transfer_buffer
, buf_size
,
539 whiteheat_write_callback
, port
);
541 list_add(&wrap
->list
, &info
->tx_urbs_free
);
544 usb_set_serial_port_data(port
, info
);
547 command_info
= kmalloc(sizeof(struct whiteheat_command_private
),
549 if (command_info
== NULL
) {
550 dev_err(&serial
->dev
->dev
,
551 "%s: Out of memory for port structures\n",
552 serial
->type
->description
);
553 goto no_command_private
;
556 mutex_init(&command_info
->mutex
);
557 command_info
->port_running
= 0;
558 init_waitqueue_head(&command_info
->wait_command
);
559 usb_set_serial_port_data(command_port
, command_info
);
560 command_port
->write_urb
->complete
= command_port_write_callback
;
561 command_port
->read_urb
->complete
= command_port_read_callback
;
568 /* Firmware likely not running */
569 dev_err(&serial
->dev
->dev
,
570 "%s: Unable to retrieve firmware version, try replugging\n",
571 serial
->type
->description
);
572 dev_err(&serial
->dev
->dev
,
573 "%s: If the firmware is not running (status led not blinking)\n",
574 serial
->type
->description
);
575 dev_err(&serial
->dev
->dev
,
576 "%s: please contact support@connecttech.com\n",
577 serial
->type
->description
);
582 for (i
= serial
->num_ports
- 1; i
>= 0; i
--) {
583 port
= serial
->port
[i
];
584 info
= usb_get_serial_port_data(port
);
585 for (j
= urb_pool_size
- 1; j
>= 0; j
--) {
586 tmp
= list_first(&info
->tx_urbs_free
);
588 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
592 kfree(urb
->transfer_buffer
);
596 tmp
= list_first(&info
->rx_urbs_free
);
598 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
602 kfree(urb
->transfer_buffer
);
620 static void whiteheat_shutdown(struct usb_serial
*serial
)
622 struct usb_serial_port
*command_port
;
623 struct usb_serial_port
*port
;
624 struct whiteheat_private
*info
;
625 struct whiteheat_urb_wrap
*wrap
;
627 struct list_head
*tmp
;
628 struct list_head
*tmp2
;
633 /* free up our private data for our command port */
634 command_port
= serial
->port
[COMMAND_PORT
];
635 kfree(usb_get_serial_port_data(command_port
));
637 for (i
= 0; i
< serial
->num_ports
; i
++) {
638 port
= serial
->port
[i
];
639 info
= usb_get_serial_port_data(port
);
640 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
642 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
645 kfree(urb
->transfer_buffer
);
648 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_free
) {
650 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
653 kfree(urb
->transfer_buffer
);
662 static int whiteheat_open(struct tty_struct
*tty
,
663 struct usb_serial_port
*port
, struct file
*filp
)
667 dbg("%s - port %d", __func__
, port
->number
);
669 retval
= start_command_port(port
->serial
);
674 tty
->low_latency
= 1;
676 /* send an open port command */
677 retval
= firm_open(port
);
679 stop_command_port(port
->serial
);
683 retval
= firm_purge(port
, WHITEHEAT_PURGE_RX
| WHITEHEAT_PURGE_TX
);
686 stop_command_port(port
->serial
);
691 firm_setup_port(tty
);
693 /* Work around HCD bugs */
694 usb_clear_halt(port
->serial
->dev
, port
->read_urb
->pipe
);
695 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
697 /* Start reading from the device */
698 retval
= start_port_read(port
);
701 "%s - failed submitting read urb, error %d\n",
704 stop_command_port(port
->serial
);
709 dbg("%s - exit, retval = %d", __func__
, retval
);
714 static void whiteheat_close(struct usb_serial_port
*port
)
716 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
717 struct whiteheat_urb_wrap
*wrap
;
719 struct list_head
*tmp
;
720 struct list_head
*tmp2
;
722 dbg("%s - port %d", __func__
, port
->number
);
724 firm_report_tx_done(port
);
727 /* shutdown our bulk reads and writes */
728 mutex_lock(&info
->deathwarrant
);
729 spin_lock_irq(&info
->lock
);
730 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
731 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
734 spin_unlock_irq(&info
->lock
);
736 spin_lock_irq(&info
->lock
);
737 list_add(tmp
, &info
->rx_urbs_free
);
739 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
)
740 list_move(tmp
, &info
->rx_urbs_free
);
741 list_for_each_safe(tmp
, tmp2
, &info
->tx_urbs_submitted
) {
742 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
745 spin_unlock_irq(&info
->lock
);
747 spin_lock_irq(&info
->lock
);
748 list_add(tmp
, &info
->tx_urbs_free
);
750 spin_unlock_irq(&info
->lock
);
751 mutex_unlock(&info
->deathwarrant
);
752 stop_command_port(port
->serial
);
756 static int whiteheat_write(struct tty_struct
*tty
,
757 struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
759 struct usb_serial
*serial
= port
->serial
;
760 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
761 struct whiteheat_urb_wrap
*wrap
;
767 struct list_head
*tmp
;
769 dbg("%s - port %d", __func__
, port
->number
);
772 dbg("%s - write request of 0 bytes", __func__
);
777 spin_lock_irqsave(&info
->lock
, flags
);
778 if (list_empty(&info
->tx_urbs_free
)) {
779 spin_unlock_irqrestore(&info
->lock
, flags
);
782 tmp
= list_first(&info
->tx_urbs_free
);
784 spin_unlock_irqrestore(&info
->lock
, flags
);
786 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
788 bytes
= (count
> port
->bulk_out_size
) ?
789 port
->bulk_out_size
: count
;
790 memcpy(urb
->transfer_buffer
, buf
+ sent
, bytes
);
792 usb_serial_debug_data(debug
, &port
->dev
,
793 __func__
, bytes
, urb
->transfer_buffer
);
795 urb
->dev
= serial
->dev
;
796 urb
->transfer_buffer_length
= bytes
;
797 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
800 "%s - failed submitting write urb, error %d\n",
803 spin_lock_irqsave(&info
->lock
, flags
);
804 list_add(tmp
, &info
->tx_urbs_free
);
805 spin_unlock_irqrestore(&info
->lock
, flags
);
810 spin_lock_irqsave(&info
->lock
, flags
);
811 list_add(tmp
, &info
->tx_urbs_submitted
);
812 spin_unlock_irqrestore(&info
->lock
, flags
);
819 static int whiteheat_write_room(struct tty_struct
*tty
)
821 struct usb_serial_port
*port
= tty
->driver_data
;
822 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
823 struct list_head
*tmp
;
827 dbg("%s - port %d", __func__
, port
->number
);
829 spin_lock_irqsave(&info
->lock
, flags
);
830 list_for_each(tmp
, &info
->tx_urbs_free
)
832 spin_unlock_irqrestore(&info
->lock
, flags
);
833 room
*= port
->bulk_out_size
;
835 dbg("%s - returns %d", __func__
, room
);
839 static int whiteheat_tiocmget(struct tty_struct
*tty
, struct file
*file
)
841 struct usb_serial_port
*port
= tty
->driver_data
;
842 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
843 unsigned int modem_signals
= 0;
845 dbg("%s - port %d", __func__
, port
->number
);
847 firm_get_dtr_rts(port
);
848 if (info
->mcr
& UART_MCR_DTR
)
849 modem_signals
|= TIOCM_DTR
;
850 if (info
->mcr
& UART_MCR_RTS
)
851 modem_signals
|= TIOCM_RTS
;
853 return modem_signals
;
856 static int whiteheat_tiocmset(struct tty_struct
*tty
, struct file
*file
,
857 unsigned int set
, unsigned int clear
)
859 struct usb_serial_port
*port
= tty
->driver_data
;
860 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
862 dbg("%s - port %d", __func__
, port
->number
);
865 info
->mcr
|= UART_MCR_RTS
;
867 info
->mcr
|= UART_MCR_DTR
;
869 if (clear
& TIOCM_RTS
)
870 info
->mcr
&= ~UART_MCR_RTS
;
871 if (clear
& TIOCM_DTR
)
872 info
->mcr
&= ~UART_MCR_DTR
;
874 firm_set_dtr(port
, info
->mcr
& UART_MCR_DTR
);
875 firm_set_rts(port
, info
->mcr
& UART_MCR_RTS
);
880 static int whiteheat_ioctl(struct tty_struct
*tty
, struct file
*file
,
881 unsigned int cmd
, unsigned long arg
)
883 struct usb_serial_port
*port
= tty
->driver_data
;
884 struct serial_struct serstruct
;
885 void __user
*user_arg
= (void __user
*)arg
;
887 dbg("%s - port %d, cmd 0x%.4x", __func__
, port
->number
, cmd
);
891 memset(&serstruct
, 0, sizeof(serstruct
));
892 serstruct
.type
= PORT_16654
;
893 serstruct
.line
= port
->serial
->minor
;
894 serstruct
.port
= port
->number
;
895 serstruct
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
896 serstruct
.xmit_fifo_size
= port
->bulk_out_size
;
897 serstruct
.custom_divisor
= 0;
898 serstruct
.baud_base
= 460800;
899 serstruct
.close_delay
= CLOSING_DELAY
;
900 serstruct
.closing_wait
= CLOSING_DELAY
;
902 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
913 static void whiteheat_set_termios(struct tty_struct
*tty
,
914 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
916 firm_setup_port(tty
);
919 static void whiteheat_break_ctl(struct tty_struct
*tty
, int break_state
)
921 struct usb_serial_port
*port
= tty
->driver_data
;
922 firm_set_break(port
, break_state
);
926 static int whiteheat_chars_in_buffer(struct tty_struct
*tty
)
928 struct usb_serial_port
*port
= tty
->driver_data
;
929 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
930 struct list_head
*tmp
;
931 struct whiteheat_urb_wrap
*wrap
;
935 dbg("%s - port %d", __func__
, port
->number
);
937 spin_lock_irqsave(&info
->lock
, flags
);
938 list_for_each(tmp
, &info
->tx_urbs_submitted
) {
939 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
940 chars
+= wrap
->urb
->transfer_buffer_length
;
942 spin_unlock_irqrestore(&info
->lock
, flags
);
944 dbg("%s - returns %d", __func__
, chars
);
949 static void whiteheat_throttle(struct tty_struct
*tty
)
951 struct usb_serial_port
*port
= tty
->driver_data
;
952 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
955 dbg("%s - port %d", __func__
, port
->number
);
957 spin_lock_irqsave(&info
->lock
, flags
);
958 info
->flags
|= THROTTLED
;
959 spin_unlock_irqrestore(&info
->lock
, flags
);
965 static void whiteheat_unthrottle(struct tty_struct
*tty
)
967 struct usb_serial_port
*port
= tty
->driver_data
;
968 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
969 int actually_throttled
;
972 dbg("%s - port %d", __func__
, port
->number
);
974 spin_lock_irqsave(&info
->lock
, flags
);
975 actually_throttled
= info
->flags
& ACTUALLY_THROTTLED
;
976 info
->flags
&= ~(THROTTLED
| ACTUALLY_THROTTLED
);
977 spin_unlock_irqrestore(&info
->lock
, flags
);
979 if (actually_throttled
)
980 rx_data_softint(&info
->rx_work
);
986 /*****************************************************************************
987 * Connect Tech's White Heat callback routines
988 *****************************************************************************/
989 static void command_port_write_callback(struct urb
*urb
)
991 int status
= urb
->status
;
996 dbg("nonzero urb status: %d", status
);
1002 static void command_port_read_callback(struct urb
*urb
)
1004 struct usb_serial_port
*command_port
= urb
->context
;
1005 struct whiteheat_command_private
*command_info
;
1006 int status
= urb
->status
;
1007 unsigned char *data
= urb
->transfer_buffer
;
1010 dbg("%s", __func__
);
1012 command_info
= usb_get_serial_port_data(command_port
);
1013 if (!command_info
) {
1014 dbg("%s - command_info is NULL, exiting.", __func__
);
1018 dbg("%s - nonzero urb status: %d", __func__
, status
);
1019 if (status
!= -ENOENT
)
1020 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
1021 wake_up(&command_info
->wait_command
);
1025 usb_serial_debug_data(debug
, &command_port
->dev
,
1026 __func__
, urb
->actual_length
, data
);
1028 if (data
[0] == WHITEHEAT_CMD_COMPLETE
) {
1029 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
1030 wake_up(&command_info
->wait_command
);
1031 } else if (data
[0] == WHITEHEAT_CMD_FAILURE
) {
1032 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
1033 wake_up(&command_info
->wait_command
);
1034 } else if (data
[0] == WHITEHEAT_EVENT
) {
1035 /* These are unsolicited reports from the firmware, hence no
1036 waiting command to wakeup */
1037 dbg("%s - event received", __func__
);
1038 } else if (data
[0] == WHITEHEAT_GET_DTR_RTS
) {
1039 memcpy(command_info
->result_buffer
, &data
[1],
1040 urb
->actual_length
- 1);
1041 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
1042 wake_up(&command_info
->wait_command
);
1044 dbg("%s - bad reply from firmware", __func__
);
1046 /* Continue trying to always read */
1047 command_port
->read_urb
->dev
= command_port
->serial
->dev
;
1048 result
= usb_submit_urb(command_port
->read_urb
, GFP_ATOMIC
);
1050 dbg("%s - failed resubmitting read urb, error %d",
1055 static void whiteheat_read_callback(struct urb
*urb
)
1057 struct usb_serial_port
*port
= urb
->context
;
1058 struct whiteheat_urb_wrap
*wrap
;
1059 unsigned char *data
= urb
->transfer_buffer
;
1060 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1061 int status
= urb
->status
;
1063 dbg("%s - port %d", __func__
, port
->number
);
1065 spin_lock(&info
->lock
);
1066 wrap
= urb_to_wrap(urb
, &info
->rx_urbs_submitted
);
1068 spin_unlock(&info
->lock
);
1069 dev_err(&port
->dev
, "%s - Not my urb!\n", __func__
);
1072 list_del(&wrap
->list
);
1073 spin_unlock(&info
->lock
);
1076 dbg("%s - nonzero read bulk status received: %d",
1078 spin_lock(&info
->lock
);
1079 list_add(&wrap
->list
, &info
->rx_urbs_free
);
1080 spin_unlock(&info
->lock
);
1084 usb_serial_debug_data(debug
, &port
->dev
,
1085 __func__
, urb
->actual_length
, data
);
1087 spin_lock(&info
->lock
);
1088 list_add_tail(&wrap
->list
, &info
->rx_urb_q
);
1089 if (info
->flags
& THROTTLED
) {
1090 info
->flags
|= ACTUALLY_THROTTLED
;
1091 spin_unlock(&info
->lock
);
1094 spin_unlock(&info
->lock
);
1096 schedule_work(&info
->rx_work
);
1100 static void whiteheat_write_callback(struct urb
*urb
)
1102 struct usb_serial_port
*port
= urb
->context
;
1103 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1104 struct whiteheat_urb_wrap
*wrap
;
1105 int status
= urb
->status
;
1107 dbg("%s - port %d", __func__
, port
->number
);
1109 spin_lock(&info
->lock
);
1110 wrap
= urb_to_wrap(urb
, &info
->tx_urbs_submitted
);
1112 spin_unlock(&info
->lock
);
1113 dev_err(&port
->dev
, "%s - Not my urb!\n", __func__
);
1116 list_move(&wrap
->list
, &info
->tx_urbs_free
);
1117 spin_unlock(&info
->lock
);
1120 dbg("%s - nonzero write bulk status received: %d",
1125 usb_serial_port_softint(port
);
1129 /*****************************************************************************
1130 * Connect Tech's White Heat firmware interface
1131 *****************************************************************************/
1132 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
,
1133 __u8
*data
, __u8 datasize
)
1135 struct usb_serial_port
*command_port
;
1136 struct whiteheat_command_private
*command_info
;
1137 struct whiteheat_private
*info
;
1138 __u8
*transfer_buffer
;
1142 dbg("%s - command %d", __func__
, command
);
1144 command_port
= port
->serial
->port
[COMMAND_PORT
];
1145 command_info
= usb_get_serial_port_data(command_port
);
1146 mutex_lock(&command_info
->mutex
);
1147 command_info
->command_finished
= false;
1149 transfer_buffer
= (__u8
*)command_port
->write_urb
->transfer_buffer
;
1150 transfer_buffer
[0] = command
;
1151 memcpy(&transfer_buffer
[1], data
, datasize
);
1152 command_port
->write_urb
->transfer_buffer_length
= datasize
+ 1;
1153 command_port
->write_urb
->dev
= port
->serial
->dev
;
1154 retval
= usb_submit_urb(command_port
->write_urb
, GFP_NOIO
);
1156 dbg("%s - submit urb failed", __func__
);
1160 /* wait for the command to complete */
1161 t
= wait_event_timeout(command_info
->wait_command
,
1162 (bool)command_info
->command_finished
, COMMAND_TIMEOUT
);
1164 usb_kill_urb(command_port
->write_urb
);
1166 if (command_info
->command_finished
== false) {
1167 dbg("%s - command timed out.", __func__
);
1168 retval
= -ETIMEDOUT
;
1172 if (command_info
->command_finished
== WHITEHEAT_CMD_FAILURE
) {
1173 dbg("%s - command failed.", __func__
);
1178 if (command_info
->command_finished
== WHITEHEAT_CMD_COMPLETE
) {
1179 dbg("%s - command completed.", __func__
);
1181 case WHITEHEAT_GET_DTR_RTS
:
1182 info
= usb_get_serial_port_data(port
);
1183 memcpy(&info
->mcr
, command_info
->result_buffer
,
1184 sizeof(struct whiteheat_dr_info
));
1189 mutex_unlock(&command_info
->mutex
);
1194 static int firm_open(struct usb_serial_port
*port
)
1196 struct whiteheat_simple open_command
;
1198 open_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1199 return firm_send_command(port
, WHITEHEAT_OPEN
,
1200 (__u8
*)&open_command
, sizeof(open_command
));
1204 static int firm_close(struct usb_serial_port
*port
)
1206 struct whiteheat_simple close_command
;
1208 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1209 return firm_send_command(port
, WHITEHEAT_CLOSE
,
1210 (__u8
*)&close_command
, sizeof(close_command
));
1214 static int firm_setup_port(struct tty_struct
*tty
)
1216 struct usb_serial_port
*port
= tty
->driver_data
;
1217 struct whiteheat_port_settings port_settings
;
1218 unsigned int cflag
= tty
->termios
->c_cflag
;
1220 port_settings
.port
= port
->number
+ 1;
1222 /* get the byte size */
1223 switch (cflag
& CSIZE
) {
1224 case CS5
: port_settings
.bits
= 5; break;
1225 case CS6
: port_settings
.bits
= 6; break;
1226 case CS7
: port_settings
.bits
= 7; break;
1228 case CS8
: port_settings
.bits
= 8; break;
1230 dbg("%s - data bits = %d", __func__
, port_settings
.bits
);
1232 /* determine the parity */
1236 port_settings
.parity
= WHITEHEAT_PAR_MARK
;
1238 port_settings
.parity
= WHITEHEAT_PAR_SPACE
;
1241 port_settings
.parity
= WHITEHEAT_PAR_ODD
;
1243 port_settings
.parity
= WHITEHEAT_PAR_EVEN
;
1245 port_settings
.parity
= WHITEHEAT_PAR_NONE
;
1246 dbg("%s - parity = %c", __func__
, port_settings
.parity
);
1248 /* figure out the stop bits requested */
1250 port_settings
.stop
= 2;
1252 port_settings
.stop
= 1;
1253 dbg("%s - stop bits = %d", __func__
, port_settings
.stop
);
1255 /* figure out the flow control settings */
1256 if (cflag
& CRTSCTS
)
1257 port_settings
.hflow
= (WHITEHEAT_HFLOW_CTS
|
1258 WHITEHEAT_HFLOW_RTS
);
1260 port_settings
.hflow
= WHITEHEAT_HFLOW_NONE
;
1261 dbg("%s - hardware flow control = %s %s %s %s", __func__
,
1262 (port_settings
.hflow
& WHITEHEAT_HFLOW_CTS
) ? "CTS" : "",
1263 (port_settings
.hflow
& WHITEHEAT_HFLOW_RTS
) ? "RTS" : "",
1264 (port_settings
.hflow
& WHITEHEAT_HFLOW_DSR
) ? "DSR" : "",
1265 (port_settings
.hflow
& WHITEHEAT_HFLOW_DTR
) ? "DTR" : "");
1267 /* determine software flow control */
1269 port_settings
.sflow
= WHITEHEAT_SFLOW_RXTX
;
1271 port_settings
.sflow
= WHITEHEAT_SFLOW_NONE
;
1272 dbg("%s - software flow control = %c", __func__
, port_settings
.sflow
);
1274 port_settings
.xon
= START_CHAR(tty
);
1275 port_settings
.xoff
= STOP_CHAR(tty
);
1276 dbg("%s - XON = %2x, XOFF = %2x",
1277 __func__
, port_settings
.xon
, port_settings
.xoff
);
1279 /* get the baud rate wanted */
1280 port_settings
.baud
= tty_get_baud_rate(tty
);
1281 dbg("%s - baud rate = %d", __func__
, port_settings
.baud
);
1283 /* fixme: should set validated settings */
1284 tty_encode_baud_rate(tty
, port_settings
.baud
, port_settings
.baud
);
1285 /* handle any settings that aren't specified in the tty structure */
1286 port_settings
.lloop
= 0;
1288 /* now send the message to the device */
1289 return firm_send_command(port
, WHITEHEAT_SETUP_PORT
,
1290 (__u8
*)&port_settings
, sizeof(port_settings
));
1294 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
)
1296 struct whiteheat_set_rdb rts_command
;
1298 rts_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1299 rts_command
.state
= onoff
;
1300 return firm_send_command(port
, WHITEHEAT_SET_RTS
,
1301 (__u8
*)&rts_command
, sizeof(rts_command
));
1305 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
)
1307 struct whiteheat_set_rdb dtr_command
;
1309 dtr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1310 dtr_command
.state
= onoff
;
1311 return firm_send_command(port
, WHITEHEAT_SET_DTR
,
1312 (__u8
*)&dtr_command
, sizeof(dtr_command
));
1316 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
)
1318 struct whiteheat_set_rdb break_command
;
1320 break_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1321 break_command
.state
= onoff
;
1322 return firm_send_command(port
, WHITEHEAT_SET_BREAK
,
1323 (__u8
*)&break_command
, sizeof(break_command
));
1327 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
)
1329 struct whiteheat_purge purge_command
;
1331 purge_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1332 purge_command
.what
= rxtx
;
1333 return firm_send_command(port
, WHITEHEAT_PURGE
,
1334 (__u8
*)&purge_command
, sizeof(purge_command
));
1338 static int firm_get_dtr_rts(struct usb_serial_port
*port
)
1340 struct whiteheat_simple get_dr_command
;
1342 get_dr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1343 return firm_send_command(port
, WHITEHEAT_GET_DTR_RTS
,
1344 (__u8
*)&get_dr_command
, sizeof(get_dr_command
));
1348 static int firm_report_tx_done(struct usb_serial_port
*port
)
1350 struct whiteheat_simple close_command
;
1352 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
1353 return firm_send_command(port
, WHITEHEAT_REPORT_TX_DONE
,
1354 (__u8
*)&close_command
, sizeof(close_command
));
1358 /*****************************************************************************
1359 * Connect Tech's White Heat utility functions
1360 *****************************************************************************/
1361 static int start_command_port(struct usb_serial
*serial
)
1363 struct usb_serial_port
*command_port
;
1364 struct whiteheat_command_private
*command_info
;
1367 command_port
= serial
->port
[COMMAND_PORT
];
1368 command_info
= usb_get_serial_port_data(command_port
);
1369 mutex_lock(&command_info
->mutex
);
1370 if (!command_info
->port_running
) {
1371 /* Work around HCD bugs */
1372 usb_clear_halt(serial
->dev
, command_port
->read_urb
->pipe
);
1374 command_port
->read_urb
->dev
= serial
->dev
;
1375 retval
= usb_submit_urb(command_port
->read_urb
, GFP_KERNEL
);
1377 dev_err(&serial
->dev
->dev
,
1378 "%s - failed submitting read urb, error %d\n",
1383 command_info
->port_running
++;
1386 mutex_unlock(&command_info
->mutex
);
1391 static void stop_command_port(struct usb_serial
*serial
)
1393 struct usb_serial_port
*command_port
;
1394 struct whiteheat_command_private
*command_info
;
1396 command_port
= serial
->port
[COMMAND_PORT
];
1397 command_info
= usb_get_serial_port_data(command_port
);
1398 mutex_lock(&command_info
->mutex
);
1399 command_info
->port_running
--;
1400 if (!command_info
->port_running
)
1401 usb_kill_urb(command_port
->read_urb
);
1402 mutex_unlock(&command_info
->mutex
);
1406 static int start_port_read(struct usb_serial_port
*port
)
1408 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
1409 struct whiteheat_urb_wrap
*wrap
;
1412 unsigned long flags
;
1413 struct list_head
*tmp
;
1414 struct list_head
*tmp2
;
1416 spin_lock_irqsave(&info
->lock
, flags
);
1418 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_free
) {
1420 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1422 urb
->dev
= port
->serial
->dev
;
1423 spin_unlock_irqrestore(&info
->lock
, flags
);
1424 retval
= usb_submit_urb(urb
, GFP_KERNEL
);
1426 spin_lock_irqsave(&info
->lock
, flags
);
1427 list_add(tmp
, &info
->rx_urbs_free
);
1428 list_for_each_safe(tmp
, tmp2
, &info
->rx_urbs_submitted
) {
1429 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1432 spin_unlock_irqrestore(&info
->lock
, flags
);
1434 spin_lock_irqsave(&info
->lock
, flags
);
1435 list_add(tmp
, &info
->rx_urbs_free
);
1439 spin_lock_irqsave(&info
->lock
, flags
);
1440 list_add(tmp
, &info
->rx_urbs_submitted
);
1443 spin_unlock_irqrestore(&info
->lock
, flags
);
1449 static struct whiteheat_urb_wrap
*urb_to_wrap(struct urb
*urb
,
1450 struct list_head
*head
)
1452 struct whiteheat_urb_wrap
*wrap
;
1453 struct list_head
*tmp
;
1455 list_for_each(tmp
, head
) {
1456 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1457 if (wrap
->urb
== urb
)
1465 static struct list_head
*list_first(struct list_head
*head
)
1471 static void rx_data_softint(struct work_struct
*work
)
1473 struct whiteheat_private
*info
=
1474 container_of(work
, struct whiteheat_private
, rx_work
);
1475 struct usb_serial_port
*port
= info
->port
;
1476 struct tty_struct
*tty
= tty_port_tty_get(&port
->port
);
1477 struct whiteheat_urb_wrap
*wrap
;
1479 unsigned long flags
;
1480 struct list_head
*tmp
;
1481 struct list_head
*tmp2
;
1485 spin_lock_irqsave(&info
->lock
, flags
);
1486 if (info
->flags
& THROTTLED
) {
1487 spin_unlock_irqrestore(&info
->lock
, flags
);
1491 list_for_each_safe(tmp
, tmp2
, &info
->rx_urb_q
) {
1493 spin_unlock_irqrestore(&info
->lock
, flags
);
1495 wrap
= list_entry(tmp
, struct whiteheat_urb_wrap
, list
);
1498 if (tty
&& urb
->actual_length
) {
1499 int len
= tty_buffer_request_room(tty
,
1500 urb
->actual_length
);
1501 /* This stuff can go away now I suspect */
1502 if (unlikely(len
< urb
->actual_length
)) {
1503 spin_lock_irqsave(&info
->lock
, flags
);
1504 list_add(tmp
, &info
->rx_urb_q
);
1505 spin_unlock_irqrestore(&info
->lock
, flags
);
1506 tty_flip_buffer_push(tty
);
1507 schedule_work(&info
->rx_work
);
1510 tty_insert_flip_string(tty
, urb
->transfer_buffer
, len
);
1514 urb
->dev
= port
->serial
->dev
;
1515 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1518 "%s - failed resubmitting read urb, error %d\n",
1520 spin_lock_irqsave(&info
->lock
, flags
);
1521 list_add(tmp
, &info
->rx_urbs_free
);
1525 spin_lock_irqsave(&info
->lock
, flags
);
1526 list_add(tmp
, &info
->rx_urbs_submitted
);
1528 spin_unlock_irqrestore(&info
->lock
, flags
);
1531 tty_flip_buffer_push(tty
);
1537 /*****************************************************************************
1538 * Connect Tech's White Heat module functions
1539 *****************************************************************************/
1540 static int __init
whiteheat_init(void)
1543 retval
= usb_serial_register(&whiteheat_fake_device
);
1545 goto failed_fake_register
;
1546 retval
= usb_serial_register(&whiteheat_device
);
1548 goto failed_device_register
;
1549 retval
= usb_register(&whiteheat_driver
);
1551 goto failed_usb_register
;
1552 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
1555 failed_usb_register
:
1556 usb_serial_deregister(&whiteheat_device
);
1557 failed_device_register
:
1558 usb_serial_deregister(&whiteheat_fake_device
);
1559 failed_fake_register
:
1564 static void __exit
whiteheat_exit(void)
1566 usb_deregister(&whiteheat_driver
);
1567 usb_serial_deregister(&whiteheat_fake_device
);
1568 usb_serial_deregister(&whiteheat_device
);
1572 module_init(whiteheat_init
);
1573 module_exit(whiteheat_exit
);
1575 MODULE_AUTHOR(DRIVER_AUTHOR
);
1576 MODULE_DESCRIPTION(DRIVER_DESC
);
1577 MODULE_LICENSE("GPL");
1579 MODULE_FIRMWARE("whiteheat.fw");
1580 MODULE_FIRMWARE("whiteheat_loader.fw");
1582 module_param(urb_pool_size
, int, 0);
1583 MODULE_PARM_DESC(urb_pool_size
, "Number of urbs to use for buffering");
1585 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1586 MODULE_PARM_DESC(debug
, "Debug enabled or not");