1 // SPDX-License-Identifier: GPL-2.0+
3 * USB ConnectTech WhiteHEAT driver
8 * Copyright (C) 1999 - 2001
9 * Greg Kroah-Hartman (greg@kroah.com)
11 * See Documentation/usb/usb-serial.txt for more information on using this
15 #include <linux/kernel.h>
16 #include <linux/errno.h>
17 #include <linux/slab.h>
18 #include <linux/tty.h>
19 #include <linux/tty_driver.h>
20 #include <linux/tty_flip.h>
21 #include <linux/module.h>
22 #include <linux/spinlock.h>
23 #include <linux/mutex.h>
24 #include <linux/uaccess.h>
25 #include <asm/termbits.h>
26 #include <linux/usb.h>
27 #include <linux/serial_reg.h>
28 #include <linux/serial.h>
29 #include <linux/usb/serial.h>
30 #include <linux/usb/ezusb.h>
31 #include "whiteheat.h" /* WhiteHEAT specific commands */
40 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Stuart MacDonald <stuartm@connecttech.com>"
41 #define DRIVER_DESC "USB ConnectTech WhiteHEAT driver"
43 #define CONNECT_TECH_VENDOR_ID 0x0710
44 #define CONNECT_TECH_FAKE_WHITE_HEAT_ID 0x0001
45 #define CONNECT_TECH_WHITE_HEAT_ID 0x8001
48 ID tables for whiteheat are unusual, because we want to different
49 things for different versions of the device. Eventually, this
50 will be doable from a single table. But, for now, we define two
51 separate ID tables, and then a third table that combines them
52 just for the purpose of exporting the autoloading information.
54 static const struct usb_device_id id_table_std
[] = {
55 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
56 { } /* Terminating entry */
59 static const struct usb_device_id id_table_prerenumeration
[] = {
60 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
61 { } /* Terminating entry */
64 static const struct usb_device_id id_table_combined
[] = {
65 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
66 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
67 { } /* Terminating entry */
70 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
73 /* function prototypes for the Connect Tech WhiteHEAT prerenumeration device */
74 static int whiteheat_firmware_download(struct usb_serial
*serial
,
75 const struct usb_device_id
*id
);
76 static int whiteheat_firmware_attach(struct usb_serial
*serial
);
78 /* function prototypes for the Connect Tech WhiteHEAT serial converter */
79 static int whiteheat_attach(struct usb_serial
*serial
);
80 static void whiteheat_release(struct usb_serial
*serial
);
81 static int whiteheat_port_probe(struct usb_serial_port
*port
);
82 static int whiteheat_port_remove(struct usb_serial_port
*port
);
83 static int whiteheat_open(struct tty_struct
*tty
,
84 struct usb_serial_port
*port
);
85 static void whiteheat_close(struct usb_serial_port
*port
);
86 static int whiteheat_ioctl(struct tty_struct
*tty
,
87 unsigned int cmd
, unsigned long arg
);
88 static void whiteheat_set_termios(struct tty_struct
*tty
,
89 struct usb_serial_port
*port
, struct ktermios
*old
);
90 static int whiteheat_tiocmget(struct tty_struct
*tty
);
91 static int whiteheat_tiocmset(struct tty_struct
*tty
,
92 unsigned int set
, unsigned int clear
);
93 static void whiteheat_break_ctl(struct tty_struct
*tty
, int break_state
);
95 static struct usb_serial_driver whiteheat_fake_device
= {
98 .name
= "whiteheatnofirm",
100 .description
= "Connect Tech - WhiteHEAT - (prerenumeration)",
101 .id_table
= id_table_prerenumeration
,
103 .probe
= whiteheat_firmware_download
,
104 .attach
= whiteheat_firmware_attach
,
107 static struct usb_serial_driver whiteheat_device
= {
109 .owner
= THIS_MODULE
,
112 .description
= "Connect Tech - WhiteHEAT",
113 .id_table
= id_table_std
,
117 .attach
= whiteheat_attach
,
118 .release
= whiteheat_release
,
119 .port_probe
= whiteheat_port_probe
,
120 .port_remove
= whiteheat_port_remove
,
121 .open
= whiteheat_open
,
122 .close
= whiteheat_close
,
123 .ioctl
= whiteheat_ioctl
,
124 .set_termios
= whiteheat_set_termios
,
125 .break_ctl
= whiteheat_break_ctl
,
126 .tiocmget
= whiteheat_tiocmget
,
127 .tiocmset
= whiteheat_tiocmset
,
128 .throttle
= usb_serial_generic_throttle
,
129 .unthrottle
= usb_serial_generic_unthrottle
,
132 static struct usb_serial_driver
* const serial_drivers
[] = {
133 &whiteheat_fake_device
, &whiteheat_device
, NULL
136 struct whiteheat_command_private
{
139 __u8 command_finished
;
140 wait_queue_head_t wait_command
; /* for handling sleeping whilst
141 waiting for a command to
143 __u8 result_buffer
[64];
146 struct whiteheat_private
{
147 __u8 mcr
; /* FIXME: no locking on mcr */
151 /* local function prototypes */
152 static int start_command_port(struct usb_serial
*serial
);
153 static void stop_command_port(struct usb_serial
*serial
);
154 static void command_port_write_callback(struct urb
*urb
);
155 static void command_port_read_callback(struct urb
*urb
);
157 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
,
158 __u8
*data
, __u8 datasize
);
159 static int firm_open(struct usb_serial_port
*port
);
160 static int firm_close(struct usb_serial_port
*port
);
161 static void firm_setup_port(struct tty_struct
*tty
);
162 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
);
163 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
);
164 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
);
165 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
);
166 static int firm_get_dtr_rts(struct usb_serial_port
*port
);
167 static int firm_report_tx_done(struct usb_serial_port
*port
);
170 #define COMMAND_PORT 4
171 #define COMMAND_TIMEOUT (2*HZ) /* 2 second timeout for a command */
172 #define COMMAND_TIMEOUT_MS 2000
173 #define CLOSING_DELAY (30 * HZ)
176 /*****************************************************************************
177 * Connect Tech's White Heat prerenumeration driver functions
178 *****************************************************************************/
180 /* steps to download the firmware to the WhiteHEAT device:
181 - hold the reset (by writing to the reset bit of the CPUCS register)
182 - download the VEND_AX.HEX file to the chip using VENDOR_REQUEST-ANCHOR_LOAD
183 - release the reset (by writing to the CPUCS register)
184 - download the WH.HEX file for all addresses greater than 0x1b3f using
185 VENDOR_REQUEST-ANCHOR_EXTERNAL_RAM_LOAD
187 - download the WH.HEX file for all addresses less than 0x1b40 using
188 VENDOR_REQUEST_ANCHOR_LOAD
190 - device renumerated itself and comes up as new device id with all
191 firmware download completed.
193 static int whiteheat_firmware_download(struct usb_serial
*serial
,
194 const struct usb_device_id
*id
)
198 response
= ezusb_fx1_ihex_firmware_download(serial
->dev
, "whiteheat_loader.fw");
200 response
= ezusb_fx1_ihex_firmware_download(serial
->dev
, "whiteheat.fw");
208 static int whiteheat_firmware_attach(struct usb_serial
*serial
)
210 /* We want this device to fail to have a driver assigned to it */
215 /*****************************************************************************
216 * Connect Tech's White Heat serial driver functions
217 *****************************************************************************/
219 static int whiteheat_attach(struct usb_serial
*serial
)
221 struct usb_serial_port
*command_port
;
222 struct whiteheat_command_private
*command_info
;
223 struct whiteheat_hw_info
*hw_info
;
230 command_port
= serial
->port
[COMMAND_PORT
];
232 pipe
= usb_sndbulkpipe(serial
->dev
,
233 command_port
->bulk_out_endpointAddress
);
234 command
= kmalloc(2, GFP_KERNEL
);
236 goto no_command_buffer
;
237 command
[0] = WHITEHEAT_GET_HW_INFO
;
240 result
= kmalloc(sizeof(*hw_info
) + 1, GFP_KERNEL
);
242 goto no_result_buffer
;
244 * When the module is reloaded the firmware is still there and
245 * the endpoints are still in the usb core unchanged. This is the
246 * unlinking bug in disguise. Same for the call below.
248 usb_clear_halt(serial
->dev
, pipe
);
249 ret
= usb_bulk_msg(serial
->dev
, pipe
, command
, 2,
250 &alen
, COMMAND_TIMEOUT_MS
);
252 dev_err(&serial
->dev
->dev
, "%s: Couldn't send command [%d]\n",
253 serial
->type
->description
, ret
);
255 } else if (alen
!= 2) {
256 dev_err(&serial
->dev
->dev
, "%s: Send command incomplete [%d]\n",
257 serial
->type
->description
, alen
);
261 pipe
= usb_rcvbulkpipe(serial
->dev
,
262 command_port
->bulk_in_endpointAddress
);
263 /* See the comment on the usb_clear_halt() above */
264 usb_clear_halt(serial
->dev
, pipe
);
265 ret
= usb_bulk_msg(serial
->dev
, pipe
, result
,
266 sizeof(*hw_info
) + 1, &alen
, COMMAND_TIMEOUT_MS
);
268 dev_err(&serial
->dev
->dev
, "%s: Couldn't get results [%d]\n",
269 serial
->type
->description
, ret
);
271 } else if (alen
!= sizeof(*hw_info
) + 1) {
272 dev_err(&serial
->dev
->dev
, "%s: Get results incomplete [%d]\n",
273 serial
->type
->description
, alen
);
275 } else if (result
[0] != command
[0]) {
276 dev_err(&serial
->dev
->dev
, "%s: Command failed [%d]\n",
277 serial
->type
->description
, result
[0]);
281 hw_info
= (struct whiteheat_hw_info
*)&result
[1];
283 dev_info(&serial
->dev
->dev
, "%s: Firmware v%d.%02d\n",
284 serial
->type
->description
,
285 hw_info
->sw_major_rev
, hw_info
->sw_minor_rev
);
287 command_info
= kmalloc(sizeof(struct whiteheat_command_private
),
290 goto no_command_private
;
292 mutex_init(&command_info
->mutex
);
293 command_info
->port_running
= 0;
294 init_waitqueue_head(&command_info
->wait_command
);
295 usb_set_serial_port_data(command_port
, command_info
);
296 command_port
->write_urb
->complete
= command_port_write_callback
;
297 command_port
->read_urb
->complete
= command_port_read_callback
;
304 /* Firmware likely not running */
305 dev_err(&serial
->dev
->dev
,
306 "%s: Unable to retrieve firmware version, try replugging\n",
307 serial
->type
->description
);
308 dev_err(&serial
->dev
->dev
,
309 "%s: If the firmware is not running (status led not blinking)\n",
310 serial
->type
->description
);
311 dev_err(&serial
->dev
->dev
,
312 "%s: please contact support@connecttech.com\n",
313 serial
->type
->description
);
326 static void whiteheat_release(struct usb_serial
*serial
)
328 struct usb_serial_port
*command_port
;
330 /* free up our private data for our command port */
331 command_port
= serial
->port
[COMMAND_PORT
];
332 kfree(usb_get_serial_port_data(command_port
));
335 static int whiteheat_port_probe(struct usb_serial_port
*port
)
337 struct whiteheat_private
*info
;
339 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
343 usb_set_serial_port_data(port
, info
);
348 static int whiteheat_port_remove(struct usb_serial_port
*port
)
350 struct whiteheat_private
*info
;
352 info
= usb_get_serial_port_data(port
);
358 static int whiteheat_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
362 retval
= start_command_port(port
->serial
);
366 /* send an open port command */
367 retval
= firm_open(port
);
369 stop_command_port(port
->serial
);
373 retval
= firm_purge(port
, WHITEHEAT_PURGE_RX
| WHITEHEAT_PURGE_TX
);
376 stop_command_port(port
->serial
);
381 firm_setup_port(tty
);
383 /* Work around HCD bugs */
384 usb_clear_halt(port
->serial
->dev
, port
->read_urb
->pipe
);
385 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
387 retval
= usb_serial_generic_open(tty
, port
);
390 stop_command_port(port
->serial
);
398 static void whiteheat_close(struct usb_serial_port
*port
)
400 firm_report_tx_done(port
);
403 usb_serial_generic_close(port
);
405 stop_command_port(port
->serial
);
408 static int whiteheat_tiocmget(struct tty_struct
*tty
)
410 struct usb_serial_port
*port
= tty
->driver_data
;
411 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
412 unsigned int modem_signals
= 0;
414 firm_get_dtr_rts(port
);
415 if (info
->mcr
& UART_MCR_DTR
)
416 modem_signals
|= TIOCM_DTR
;
417 if (info
->mcr
& UART_MCR_RTS
)
418 modem_signals
|= TIOCM_RTS
;
420 return modem_signals
;
423 static int whiteheat_tiocmset(struct tty_struct
*tty
,
424 unsigned int set
, unsigned int clear
)
426 struct usb_serial_port
*port
= tty
->driver_data
;
427 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
430 info
->mcr
|= UART_MCR_RTS
;
432 info
->mcr
|= UART_MCR_DTR
;
434 if (clear
& TIOCM_RTS
)
435 info
->mcr
&= ~UART_MCR_RTS
;
436 if (clear
& TIOCM_DTR
)
437 info
->mcr
&= ~UART_MCR_DTR
;
439 firm_set_dtr(port
, info
->mcr
& UART_MCR_DTR
);
440 firm_set_rts(port
, info
->mcr
& UART_MCR_RTS
);
445 static int whiteheat_ioctl(struct tty_struct
*tty
,
446 unsigned int cmd
, unsigned long arg
)
448 struct usb_serial_port
*port
= tty
->driver_data
;
449 struct serial_struct serstruct
;
450 void __user
*user_arg
= (void __user
*)arg
;
454 memset(&serstruct
, 0, sizeof(serstruct
));
455 serstruct
.type
= PORT_16654
;
456 serstruct
.line
= port
->minor
;
457 serstruct
.port
= port
->port_number
;
458 serstruct
.xmit_fifo_size
= kfifo_size(&port
->write_fifo
);
459 serstruct
.custom_divisor
= 0;
460 serstruct
.baud_base
= 460800;
461 serstruct
.close_delay
= CLOSING_DELAY
;
462 serstruct
.closing_wait
= CLOSING_DELAY
;
464 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
475 static void whiteheat_set_termios(struct tty_struct
*tty
,
476 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
478 firm_setup_port(tty
);
481 static void whiteheat_break_ctl(struct tty_struct
*tty
, int break_state
)
483 struct usb_serial_port
*port
= tty
->driver_data
;
484 firm_set_break(port
, break_state
);
488 /*****************************************************************************
489 * Connect Tech's White Heat callback routines
490 *****************************************************************************/
491 static void command_port_write_callback(struct urb
*urb
)
493 int status
= urb
->status
;
496 dev_dbg(&urb
->dev
->dev
, "nonzero urb status: %d\n", status
);
502 static void command_port_read_callback(struct urb
*urb
)
504 struct usb_serial_port
*command_port
= urb
->context
;
505 struct whiteheat_command_private
*command_info
;
506 int status
= urb
->status
;
507 unsigned char *data
= urb
->transfer_buffer
;
510 command_info
= usb_get_serial_port_data(command_port
);
512 dev_dbg(&urb
->dev
->dev
, "%s - command_info is NULL, exiting.\n", __func__
);
515 if (!urb
->actual_length
) {
516 dev_dbg(&urb
->dev
->dev
, "%s - empty response, exiting.\n", __func__
);
520 dev_dbg(&urb
->dev
->dev
, "%s - nonzero urb status: %d\n", __func__
, status
);
521 if (status
!= -ENOENT
)
522 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
523 wake_up(&command_info
->wait_command
);
527 usb_serial_debug_data(&command_port
->dev
, __func__
, urb
->actual_length
, data
);
529 if (data
[0] == WHITEHEAT_CMD_COMPLETE
) {
530 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
531 wake_up(&command_info
->wait_command
);
532 } else if (data
[0] == WHITEHEAT_CMD_FAILURE
) {
533 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
534 wake_up(&command_info
->wait_command
);
535 } else if (data
[0] == WHITEHEAT_EVENT
) {
536 /* These are unsolicited reports from the firmware, hence no
537 waiting command to wakeup */
538 dev_dbg(&urb
->dev
->dev
, "%s - event received\n", __func__
);
539 } else if ((data
[0] == WHITEHEAT_GET_DTR_RTS
) &&
540 (urb
->actual_length
- 1 <= sizeof(command_info
->result_buffer
))) {
541 memcpy(command_info
->result_buffer
, &data
[1],
542 urb
->actual_length
- 1);
543 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
544 wake_up(&command_info
->wait_command
);
546 dev_dbg(&urb
->dev
->dev
, "%s - bad reply from firmware\n", __func__
);
548 /* Continue trying to always read */
549 result
= usb_submit_urb(command_port
->read_urb
, GFP_ATOMIC
);
551 dev_dbg(&urb
->dev
->dev
, "%s - failed resubmitting read urb, error %d\n",
556 /*****************************************************************************
557 * Connect Tech's White Heat firmware interface
558 *****************************************************************************/
559 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
,
560 __u8
*data
, __u8 datasize
)
562 struct usb_serial_port
*command_port
;
563 struct whiteheat_command_private
*command_info
;
564 struct whiteheat_private
*info
;
565 struct device
*dev
= &port
->dev
;
566 __u8
*transfer_buffer
;
570 dev_dbg(dev
, "%s - command %d\n", __func__
, command
);
572 command_port
= port
->serial
->port
[COMMAND_PORT
];
573 command_info
= usb_get_serial_port_data(command_port
);
574 mutex_lock(&command_info
->mutex
);
575 command_info
->command_finished
= false;
577 transfer_buffer
= (__u8
*)command_port
->write_urb
->transfer_buffer
;
578 transfer_buffer
[0] = command
;
579 memcpy(&transfer_buffer
[1], data
, datasize
);
580 command_port
->write_urb
->transfer_buffer_length
= datasize
+ 1;
581 retval
= usb_submit_urb(command_port
->write_urb
, GFP_NOIO
);
583 dev_dbg(dev
, "%s - submit urb failed\n", __func__
);
587 /* wait for the command to complete */
588 t
= wait_event_timeout(command_info
->wait_command
,
589 (bool)command_info
->command_finished
, COMMAND_TIMEOUT
);
591 usb_kill_urb(command_port
->write_urb
);
593 if (command_info
->command_finished
== false) {
594 dev_dbg(dev
, "%s - command timed out.\n", __func__
);
599 if (command_info
->command_finished
== WHITEHEAT_CMD_FAILURE
) {
600 dev_dbg(dev
, "%s - command failed.\n", __func__
);
605 if (command_info
->command_finished
== WHITEHEAT_CMD_COMPLETE
) {
606 dev_dbg(dev
, "%s - command completed.\n", __func__
);
608 case WHITEHEAT_GET_DTR_RTS
:
609 info
= usb_get_serial_port_data(port
);
610 memcpy(&info
->mcr
, command_info
->result_buffer
,
611 sizeof(struct whiteheat_dr_info
));
616 mutex_unlock(&command_info
->mutex
);
621 static int firm_open(struct usb_serial_port
*port
)
623 struct whiteheat_simple open_command
;
625 open_command
.port
= port
->port_number
+ 1;
626 return firm_send_command(port
, WHITEHEAT_OPEN
,
627 (__u8
*)&open_command
, sizeof(open_command
));
631 static int firm_close(struct usb_serial_port
*port
)
633 struct whiteheat_simple close_command
;
635 close_command
.port
= port
->port_number
+ 1;
636 return firm_send_command(port
, WHITEHEAT_CLOSE
,
637 (__u8
*)&close_command
, sizeof(close_command
));
641 static void firm_setup_port(struct tty_struct
*tty
)
643 struct usb_serial_port
*port
= tty
->driver_data
;
644 struct device
*dev
= &port
->dev
;
645 struct whiteheat_port_settings port_settings
;
646 unsigned int cflag
= tty
->termios
.c_cflag
;
648 port_settings
.port
= port
->port_number
+ 1;
650 /* get the byte size */
651 switch (cflag
& CSIZE
) {
652 case CS5
: port_settings
.bits
= 5; break;
653 case CS6
: port_settings
.bits
= 6; break;
654 case CS7
: port_settings
.bits
= 7; break;
656 case CS8
: port_settings
.bits
= 8; break;
658 dev_dbg(dev
, "%s - data bits = %d\n", __func__
, port_settings
.bits
);
660 /* determine the parity */
664 port_settings
.parity
= WHITEHEAT_PAR_MARK
;
666 port_settings
.parity
= WHITEHEAT_PAR_SPACE
;
669 port_settings
.parity
= WHITEHEAT_PAR_ODD
;
671 port_settings
.parity
= WHITEHEAT_PAR_EVEN
;
673 port_settings
.parity
= WHITEHEAT_PAR_NONE
;
674 dev_dbg(dev
, "%s - parity = %c\n", __func__
, port_settings
.parity
);
676 /* figure out the stop bits requested */
678 port_settings
.stop
= 2;
680 port_settings
.stop
= 1;
681 dev_dbg(dev
, "%s - stop bits = %d\n", __func__
, port_settings
.stop
);
683 /* figure out the flow control settings */
685 port_settings
.hflow
= (WHITEHEAT_HFLOW_CTS
|
686 WHITEHEAT_HFLOW_RTS
);
688 port_settings
.hflow
= WHITEHEAT_HFLOW_NONE
;
689 dev_dbg(dev
, "%s - hardware flow control = %s %s %s %s\n", __func__
,
690 (port_settings
.hflow
& WHITEHEAT_HFLOW_CTS
) ? "CTS" : "",
691 (port_settings
.hflow
& WHITEHEAT_HFLOW_RTS
) ? "RTS" : "",
692 (port_settings
.hflow
& WHITEHEAT_HFLOW_DSR
) ? "DSR" : "",
693 (port_settings
.hflow
& WHITEHEAT_HFLOW_DTR
) ? "DTR" : "");
695 /* determine software flow control */
697 port_settings
.sflow
= WHITEHEAT_SFLOW_RXTX
;
699 port_settings
.sflow
= WHITEHEAT_SFLOW_NONE
;
700 dev_dbg(dev
, "%s - software flow control = %c\n", __func__
, port_settings
.sflow
);
702 port_settings
.xon
= START_CHAR(tty
);
703 port_settings
.xoff
= STOP_CHAR(tty
);
704 dev_dbg(dev
, "%s - XON = %2x, XOFF = %2x\n", __func__
, port_settings
.xon
, port_settings
.xoff
);
706 /* get the baud rate wanted */
707 port_settings
.baud
= tty_get_baud_rate(tty
);
708 dev_dbg(dev
, "%s - baud rate = %d\n", __func__
, port_settings
.baud
);
710 /* fixme: should set validated settings */
711 tty_encode_baud_rate(tty
, port_settings
.baud
, port_settings
.baud
);
712 /* handle any settings that aren't specified in the tty structure */
713 port_settings
.lloop
= 0;
715 /* now send the message to the device */
716 firm_send_command(port
, WHITEHEAT_SETUP_PORT
,
717 (__u8
*)&port_settings
, sizeof(port_settings
));
721 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
)
723 struct whiteheat_set_rdb rts_command
;
725 rts_command
.port
= port
->port_number
+ 1;
726 rts_command
.state
= onoff
;
727 return firm_send_command(port
, WHITEHEAT_SET_RTS
,
728 (__u8
*)&rts_command
, sizeof(rts_command
));
732 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
)
734 struct whiteheat_set_rdb dtr_command
;
736 dtr_command
.port
= port
->port_number
+ 1;
737 dtr_command
.state
= onoff
;
738 return firm_send_command(port
, WHITEHEAT_SET_DTR
,
739 (__u8
*)&dtr_command
, sizeof(dtr_command
));
743 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
)
745 struct whiteheat_set_rdb break_command
;
747 break_command
.port
= port
->port_number
+ 1;
748 break_command
.state
= onoff
;
749 return firm_send_command(port
, WHITEHEAT_SET_BREAK
,
750 (__u8
*)&break_command
, sizeof(break_command
));
754 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
)
756 struct whiteheat_purge purge_command
;
758 purge_command
.port
= port
->port_number
+ 1;
759 purge_command
.what
= rxtx
;
760 return firm_send_command(port
, WHITEHEAT_PURGE
,
761 (__u8
*)&purge_command
, sizeof(purge_command
));
765 static int firm_get_dtr_rts(struct usb_serial_port
*port
)
767 struct whiteheat_simple get_dr_command
;
769 get_dr_command
.port
= port
->port_number
+ 1;
770 return firm_send_command(port
, WHITEHEAT_GET_DTR_RTS
,
771 (__u8
*)&get_dr_command
, sizeof(get_dr_command
));
775 static int firm_report_tx_done(struct usb_serial_port
*port
)
777 struct whiteheat_simple close_command
;
779 close_command
.port
= port
->port_number
+ 1;
780 return firm_send_command(port
, WHITEHEAT_REPORT_TX_DONE
,
781 (__u8
*)&close_command
, sizeof(close_command
));
785 /*****************************************************************************
786 * Connect Tech's White Heat utility functions
787 *****************************************************************************/
788 static int start_command_port(struct usb_serial
*serial
)
790 struct usb_serial_port
*command_port
;
791 struct whiteheat_command_private
*command_info
;
794 command_port
= serial
->port
[COMMAND_PORT
];
795 command_info
= usb_get_serial_port_data(command_port
);
796 mutex_lock(&command_info
->mutex
);
797 if (!command_info
->port_running
) {
798 /* Work around HCD bugs */
799 usb_clear_halt(serial
->dev
, command_port
->read_urb
->pipe
);
801 retval
= usb_submit_urb(command_port
->read_urb
, GFP_KERNEL
);
803 dev_err(&serial
->dev
->dev
,
804 "%s - failed submitting read urb, error %d\n",
809 command_info
->port_running
++;
812 mutex_unlock(&command_info
->mutex
);
817 static void stop_command_port(struct usb_serial
*serial
)
819 struct usb_serial_port
*command_port
;
820 struct whiteheat_command_private
*command_info
;
822 command_port
= serial
->port
[COMMAND_PORT
];
823 command_info
= usb_get_serial_port_data(command_port
);
824 mutex_lock(&command_info
->mutex
);
825 command_info
->port_running
--;
826 if (!command_info
->port_running
)
827 usb_kill_urb(command_port
->read_urb
);
828 mutex_unlock(&command_info
->mutex
);
831 module_usb_serial_driver(serial_drivers
, id_table_combined
);
833 MODULE_AUTHOR(DRIVER_AUTHOR
);
834 MODULE_DESCRIPTION(DRIVER_DESC
);
835 MODULE_LICENSE("GPL");
837 MODULE_FIRMWARE("whiteheat.fw");
838 MODULE_FIRMWARE("whiteheat_loader.fw");