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
19 #include <linux/kernel.h>
20 #include <linux/errno.h>
21 #include <linux/init.h>
22 #include <linux/slab.h>
23 #include <linux/tty.h>
24 #include <linux/tty_driver.h>
25 #include <linux/tty_flip.h>
26 #include <linux/module.h>
27 #include <linux/spinlock.h>
28 #include <linux/mutex.h>
29 #include <linux/uaccess.h>
30 #include <asm/termbits.h>
31 #include <linux/usb.h>
32 #include <linux/serial_reg.h>
33 #include <linux/serial.h>
34 #include <linux/usb/serial.h>
35 #include <linux/firmware.h>
36 #include <linux/ihex.h>
37 #include "whiteheat.h" /* WhiteHEAT specific commands */
48 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Stuart MacDonald <stuartm@connecttech.com>"
49 #define DRIVER_DESC "USB ConnectTech WhiteHEAT driver"
51 #define CONNECT_TECH_VENDOR_ID 0x0710
52 #define CONNECT_TECH_FAKE_WHITE_HEAT_ID 0x0001
53 #define CONNECT_TECH_WHITE_HEAT_ID 0x8001
56 ID tables for whiteheat are unusual, because we want to different
57 things for different versions of the device. Eventually, this
58 will be doable from a single table. But, for now, we define two
59 separate ID tables, and then a third table that combines them
60 just for the purpose of exporting the autoloading information.
62 static const struct usb_device_id id_table_std
[] = {
63 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
64 { } /* Terminating entry */
67 static const struct usb_device_id id_table_prerenumeration
[] = {
68 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
69 { } /* Terminating entry */
72 static const struct usb_device_id id_table_combined
[] = {
73 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_WHITE_HEAT_ID
) },
74 { USB_DEVICE(CONNECT_TECH_VENDOR_ID
, CONNECT_TECH_FAKE_WHITE_HEAT_ID
) },
75 { } /* Terminating entry */
78 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
81 /* function prototypes for the Connect Tech WhiteHEAT prerenumeration device */
82 static int whiteheat_firmware_download(struct usb_serial
*serial
,
83 const struct usb_device_id
*id
);
84 static int whiteheat_firmware_attach(struct usb_serial
*serial
);
86 /* function prototypes for the Connect Tech WhiteHEAT serial converter */
87 static int whiteheat_attach(struct usb_serial
*serial
);
88 static void whiteheat_release(struct usb_serial
*serial
);
89 static int whiteheat_open(struct tty_struct
*tty
,
90 struct usb_serial_port
*port
);
91 static void whiteheat_close(struct usb_serial_port
*port
);
92 static int whiteheat_ioctl(struct tty_struct
*tty
,
93 unsigned int cmd
, unsigned long arg
);
94 static void whiteheat_set_termios(struct tty_struct
*tty
,
95 struct usb_serial_port
*port
, struct ktermios
*old
);
96 static int whiteheat_tiocmget(struct tty_struct
*tty
);
97 static int whiteheat_tiocmset(struct tty_struct
*tty
,
98 unsigned int set
, unsigned int clear
);
99 static void whiteheat_break_ctl(struct tty_struct
*tty
, int break_state
);
101 static struct usb_serial_driver whiteheat_fake_device
= {
103 .owner
= THIS_MODULE
,
104 .name
= "whiteheatnofirm",
106 .description
= "Connect Tech - WhiteHEAT - (prerenumeration)",
107 .id_table
= id_table_prerenumeration
,
109 .probe
= whiteheat_firmware_download
,
110 .attach
= whiteheat_firmware_attach
,
113 static struct usb_serial_driver whiteheat_device
= {
115 .owner
= THIS_MODULE
,
118 .description
= "Connect Tech - WhiteHEAT",
119 .id_table
= id_table_std
,
121 .attach
= whiteheat_attach
,
122 .release
= whiteheat_release
,
123 .open
= whiteheat_open
,
124 .close
= whiteheat_close
,
125 .ioctl
= whiteheat_ioctl
,
126 .set_termios
= whiteheat_set_termios
,
127 .break_ctl
= whiteheat_break_ctl
,
128 .tiocmget
= whiteheat_tiocmget
,
129 .tiocmset
= whiteheat_tiocmset
,
130 .throttle
= usb_serial_generic_throttle
,
131 .unthrottle
= usb_serial_generic_unthrottle
,
134 static struct usb_serial_driver
* const serial_drivers
[] = {
135 &whiteheat_fake_device
, &whiteheat_device
, NULL
138 struct whiteheat_command_private
{
141 __u8 command_finished
;
142 wait_queue_head_t wait_command
; /* for handling sleeping whilst
143 waiting for a command to
145 __u8 result_buffer
[64];
148 struct whiteheat_private
{
149 __u8 mcr
; /* FIXME: no locking on mcr */
153 /* local function prototypes */
154 static int start_command_port(struct usb_serial
*serial
);
155 static void stop_command_port(struct usb_serial
*serial
);
156 static void command_port_write_callback(struct urb
*urb
);
157 static void command_port_read_callback(struct urb
*urb
);
159 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
,
160 __u8
*data
, __u8 datasize
);
161 static int firm_open(struct usb_serial_port
*port
);
162 static int firm_close(struct usb_serial_port
*port
);
163 static void firm_setup_port(struct tty_struct
*tty
);
164 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
);
165 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
);
166 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
);
167 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
);
168 static int firm_get_dtr_rts(struct usb_serial_port
*port
);
169 static int firm_report_tx_done(struct usb_serial_port
*port
);
172 #define COMMAND_PORT 4
173 #define COMMAND_TIMEOUT (2*HZ) /* 2 second timeout for a command */
174 #define COMMAND_TIMEOUT_MS 2000
175 #define CLOSING_DELAY (30 * HZ)
178 /*****************************************************************************
179 * Connect Tech's White Heat prerenumeration driver functions
180 *****************************************************************************/
182 /* steps to download the firmware to the WhiteHEAT device:
183 - hold the reset (by writing to the reset bit of the CPUCS register)
184 - download the VEND_AX.HEX file to the chip using VENDOR_REQUEST-ANCHOR_LOAD
185 - release the reset (by writing to the CPUCS register)
186 - download the WH.HEX file for all addresses greater than 0x1b3f using
187 VENDOR_REQUEST-ANCHOR_EXTERNAL_RAM_LOAD
189 - download the WH.HEX file for all addresses less than 0x1b40 using
190 VENDOR_REQUEST_ANCHOR_LOAD
192 - device renumerated itself and comes up as new device id with all
193 firmware download completed.
195 static int whiteheat_firmware_download(struct usb_serial
*serial
,
196 const struct usb_device_id
*id
)
198 int response
, ret
= -ENOENT
;
199 const struct firmware
*loader_fw
= NULL
, *firmware_fw
= NULL
;
200 const struct ihex_binrec
*record
;
202 if (request_ihex_firmware(&firmware_fw
, "whiteheat.fw",
203 &serial
->dev
->dev
)) {
204 dev_err(&serial
->dev
->dev
,
205 "%s - request \"whiteheat.fw\" failed\n", __func__
);
208 if (request_ihex_firmware(&loader_fw
, "whiteheat_loader.fw",
209 &serial
->dev
->dev
)) {
210 dev_err(&serial
->dev
->dev
,
211 "%s - request \"whiteheat_loader.fw\" failed\n",
216 response
= ezusb_set_reset (serial
, 1);
218 record
= (const struct ihex_binrec
*)loader_fw
->data
;
220 response
= ezusb_writememory (serial
, be32_to_cpu(record
->addr
),
221 (unsigned char *)record
->data
,
222 be16_to_cpu(record
->len
), 0xa0);
224 dev_err(&serial
->dev
->dev
, "%s - ezusb_writememory "
225 "failed for loader (%d %04X %p %d)\n",
226 __func__
, response
, be32_to_cpu(record
->addr
),
227 record
->data
, be16_to_cpu(record
->len
));
230 record
= ihex_next_binrec(record
);
233 response
= ezusb_set_reset(serial
, 0);
235 record
= (const struct ihex_binrec
*)firmware_fw
->data
;
236 while (record
&& be32_to_cpu(record
->addr
) < 0x1b40)
237 record
= ihex_next_binrec(record
);
239 response
= ezusb_writememory (serial
, be32_to_cpu(record
->addr
),
240 (unsigned char *)record
->data
,
241 be16_to_cpu(record
->len
), 0xa3);
243 dev_err(&serial
->dev
->dev
, "%s - ezusb_writememory "
244 "failed for first firmware step "
245 "(%d %04X %p %d)\n", __func__
, response
,
246 be32_to_cpu(record
->addr
), record
->data
,
247 be16_to_cpu(record
->len
));
253 response
= ezusb_set_reset(serial
, 1);
255 record
= (const struct ihex_binrec
*)firmware_fw
->data
;
256 while (record
&& be32_to_cpu(record
->addr
) < 0x1b40) {
257 response
= ezusb_writememory (serial
, be32_to_cpu(record
->addr
),
258 (unsigned char *)record
->data
,
259 be16_to_cpu(record
->len
), 0xa0);
261 dev_err(&serial
->dev
->dev
, "%s - ezusb_writememory "
262 "failed for second firmware step "
263 "(%d %04X %p %d)\n", __func__
, response
,
264 be32_to_cpu(record
->addr
), record
->data
,
265 be16_to_cpu(record
->len
));
271 response
= ezusb_set_reset (serial
, 0);
273 release_firmware(loader_fw
);
274 release_firmware(firmware_fw
);
279 static int whiteheat_firmware_attach(struct usb_serial
*serial
)
281 /* We want this device to fail to have a driver assigned to it */
286 /*****************************************************************************
287 * Connect Tech's White Heat serial driver functions
288 *****************************************************************************/
289 static int whiteheat_attach(struct usb_serial
*serial
)
291 struct usb_serial_port
*command_port
;
292 struct whiteheat_command_private
*command_info
;
293 struct usb_serial_port
*port
;
294 struct whiteheat_private
*info
;
295 struct whiteheat_hw_info
*hw_info
;
303 command_port
= serial
->port
[COMMAND_PORT
];
305 pipe
= usb_sndbulkpipe(serial
->dev
,
306 command_port
->bulk_out_endpointAddress
);
307 command
= kmalloc(2, GFP_KERNEL
);
309 goto no_command_buffer
;
310 command
[0] = WHITEHEAT_GET_HW_INFO
;
313 result
= kmalloc(sizeof(*hw_info
) + 1, GFP_KERNEL
);
315 goto no_result_buffer
;
317 * When the module is reloaded the firmware is still there and
318 * the endpoints are still in the usb core unchanged. This is the
319 * unlinking bug in disguise. Same for the call below.
321 usb_clear_halt(serial
->dev
, pipe
);
322 ret
= usb_bulk_msg(serial
->dev
, pipe
, command
, 2,
323 &alen
, COMMAND_TIMEOUT_MS
);
325 dev_err(&serial
->dev
->dev
, "%s: Couldn't send command [%d]\n",
326 serial
->type
->description
, ret
);
328 } else if (alen
!= 2) {
329 dev_err(&serial
->dev
->dev
, "%s: Send command incomplete [%d]\n",
330 serial
->type
->description
, alen
);
334 pipe
= usb_rcvbulkpipe(serial
->dev
,
335 command_port
->bulk_in_endpointAddress
);
336 /* See the comment on the usb_clear_halt() above */
337 usb_clear_halt(serial
->dev
, pipe
);
338 ret
= usb_bulk_msg(serial
->dev
, pipe
, result
,
339 sizeof(*hw_info
) + 1, &alen
, COMMAND_TIMEOUT_MS
);
341 dev_err(&serial
->dev
->dev
, "%s: Couldn't get results [%d]\n",
342 serial
->type
->description
, ret
);
344 } else if (alen
!= sizeof(*hw_info
) + 1) {
345 dev_err(&serial
->dev
->dev
, "%s: Get results incomplete [%d]\n",
346 serial
->type
->description
, alen
);
348 } else if (result
[0] != command
[0]) {
349 dev_err(&serial
->dev
->dev
, "%s: Command failed [%d]\n",
350 serial
->type
->description
, result
[0]);
354 hw_info
= (struct whiteheat_hw_info
*)&result
[1];
356 dev_info(&serial
->dev
->dev
, "%s: Firmware v%d.%02d\n",
357 serial
->type
->description
,
358 hw_info
->sw_major_rev
, hw_info
->sw_minor_rev
);
360 for (i
= 0; i
< serial
->num_ports
; i
++) {
361 port
= serial
->port
[i
];
363 info
= kmalloc(sizeof(struct whiteheat_private
), GFP_KERNEL
);
366 "%s: Out of memory for port structures\n",
367 serial
->type
->description
);
373 usb_set_serial_port_data(port
, info
);
376 command_info
= kmalloc(sizeof(struct whiteheat_command_private
),
378 if (command_info
== NULL
) {
379 dev_err(&serial
->dev
->dev
,
380 "%s: Out of memory for port structures\n",
381 serial
->type
->description
);
382 goto no_command_private
;
385 mutex_init(&command_info
->mutex
);
386 command_info
->port_running
= 0;
387 init_waitqueue_head(&command_info
->wait_command
);
388 usb_set_serial_port_data(command_port
, command_info
);
389 command_port
->write_urb
->complete
= command_port_write_callback
;
390 command_port
->read_urb
->complete
= command_port_read_callback
;
397 /* Firmware likely not running */
398 dev_err(&serial
->dev
->dev
,
399 "%s: Unable to retrieve firmware version, try replugging\n",
400 serial
->type
->description
);
401 dev_err(&serial
->dev
->dev
,
402 "%s: If the firmware is not running (status led not blinking)\n",
403 serial
->type
->description
);
404 dev_err(&serial
->dev
->dev
,
405 "%s: please contact support@connecttech.com\n",
406 serial
->type
->description
);
411 for (i
= serial
->num_ports
- 1; i
>= 0; i
--) {
412 port
= serial
->port
[i
];
413 info
= usb_get_serial_port_data(port
);
426 static void whiteheat_release(struct usb_serial
*serial
)
428 struct usb_serial_port
*command_port
;
429 struct whiteheat_private
*info
;
432 /* free up our private data for our command port */
433 command_port
= serial
->port
[COMMAND_PORT
];
434 kfree(usb_get_serial_port_data(command_port
));
436 for (i
= 0; i
< serial
->num_ports
; i
++) {
437 info
= usb_get_serial_port_data(serial
->port
[i
]);
442 static int whiteheat_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
446 retval
= start_command_port(port
->serial
);
450 /* send an open port command */
451 retval
= firm_open(port
);
453 stop_command_port(port
->serial
);
457 retval
= firm_purge(port
, WHITEHEAT_PURGE_RX
| WHITEHEAT_PURGE_TX
);
460 stop_command_port(port
->serial
);
465 firm_setup_port(tty
);
467 /* Work around HCD bugs */
468 usb_clear_halt(port
->serial
->dev
, port
->read_urb
->pipe
);
469 usb_clear_halt(port
->serial
->dev
, port
->write_urb
->pipe
);
471 retval
= usb_serial_generic_open(tty
, port
);
474 stop_command_port(port
->serial
);
482 static void whiteheat_close(struct usb_serial_port
*port
)
484 firm_report_tx_done(port
);
487 usb_serial_generic_close(port
);
489 stop_command_port(port
->serial
);
492 static int whiteheat_tiocmget(struct tty_struct
*tty
)
494 struct usb_serial_port
*port
= tty
->driver_data
;
495 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
496 unsigned int modem_signals
= 0;
498 firm_get_dtr_rts(port
);
499 if (info
->mcr
& UART_MCR_DTR
)
500 modem_signals
|= TIOCM_DTR
;
501 if (info
->mcr
& UART_MCR_RTS
)
502 modem_signals
|= TIOCM_RTS
;
504 return modem_signals
;
507 static int whiteheat_tiocmset(struct tty_struct
*tty
,
508 unsigned int set
, unsigned int clear
)
510 struct usb_serial_port
*port
= tty
->driver_data
;
511 struct whiteheat_private
*info
= usb_get_serial_port_data(port
);
514 info
->mcr
|= UART_MCR_RTS
;
516 info
->mcr
|= UART_MCR_DTR
;
518 if (clear
& TIOCM_RTS
)
519 info
->mcr
&= ~UART_MCR_RTS
;
520 if (clear
& TIOCM_DTR
)
521 info
->mcr
&= ~UART_MCR_DTR
;
523 firm_set_dtr(port
, info
->mcr
& UART_MCR_DTR
);
524 firm_set_rts(port
, info
->mcr
& UART_MCR_RTS
);
529 static int whiteheat_ioctl(struct tty_struct
*tty
,
530 unsigned int cmd
, unsigned long arg
)
532 struct usb_serial_port
*port
= tty
->driver_data
;
533 struct serial_struct serstruct
;
534 void __user
*user_arg
= (void __user
*)arg
;
536 dbg("%s - port %d, cmd 0x%.4x", __func__
, port
->number
, cmd
);
540 memset(&serstruct
, 0, sizeof(serstruct
));
541 serstruct
.type
= PORT_16654
;
542 serstruct
.line
= port
->serial
->minor
;
543 serstruct
.port
= port
->number
;
544 serstruct
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
545 serstruct
.xmit_fifo_size
= kfifo_size(&port
->write_fifo
);
546 serstruct
.custom_divisor
= 0;
547 serstruct
.baud_base
= 460800;
548 serstruct
.close_delay
= CLOSING_DELAY
;
549 serstruct
.closing_wait
= CLOSING_DELAY
;
551 if (copy_to_user(user_arg
, &serstruct
, sizeof(serstruct
)))
562 static void whiteheat_set_termios(struct tty_struct
*tty
,
563 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
565 firm_setup_port(tty
);
568 static void whiteheat_break_ctl(struct tty_struct
*tty
, int break_state
)
570 struct usb_serial_port
*port
= tty
->driver_data
;
571 firm_set_break(port
, break_state
);
575 /*****************************************************************************
576 * Connect Tech's White Heat callback routines
577 *****************************************************************************/
578 static void command_port_write_callback(struct urb
*urb
)
580 int status
= urb
->status
;
583 dbg("nonzero urb status: %d", status
);
589 static void command_port_read_callback(struct urb
*urb
)
591 struct usb_serial_port
*command_port
= urb
->context
;
592 struct whiteheat_command_private
*command_info
;
593 int status
= urb
->status
;
594 unsigned char *data
= urb
->transfer_buffer
;
597 command_info
= usb_get_serial_port_data(command_port
);
599 dbg("%s - command_info is NULL, exiting.", __func__
);
603 dbg("%s - nonzero urb status: %d", __func__
, status
);
604 if (status
!= -ENOENT
)
605 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
606 wake_up(&command_info
->wait_command
);
610 usb_serial_debug_data(debug
, &command_port
->dev
,
611 __func__
, urb
->actual_length
, data
);
613 if (data
[0] == WHITEHEAT_CMD_COMPLETE
) {
614 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
615 wake_up(&command_info
->wait_command
);
616 } else if (data
[0] == WHITEHEAT_CMD_FAILURE
) {
617 command_info
->command_finished
= WHITEHEAT_CMD_FAILURE
;
618 wake_up(&command_info
->wait_command
);
619 } else if (data
[0] == WHITEHEAT_EVENT
) {
620 /* These are unsolicited reports from the firmware, hence no
621 waiting command to wakeup */
622 dbg("%s - event received", __func__
);
623 } else if (data
[0] == WHITEHEAT_GET_DTR_RTS
) {
624 memcpy(command_info
->result_buffer
, &data
[1],
625 urb
->actual_length
- 1);
626 command_info
->command_finished
= WHITEHEAT_CMD_COMPLETE
;
627 wake_up(&command_info
->wait_command
);
629 dbg("%s - bad reply from firmware", __func__
);
631 /* Continue trying to always read */
632 result
= usb_submit_urb(command_port
->read_urb
, GFP_ATOMIC
);
634 dbg("%s - failed resubmitting read urb, error %d",
639 /*****************************************************************************
640 * Connect Tech's White Heat firmware interface
641 *****************************************************************************/
642 static int firm_send_command(struct usb_serial_port
*port
, __u8 command
,
643 __u8
*data
, __u8 datasize
)
645 struct usb_serial_port
*command_port
;
646 struct whiteheat_command_private
*command_info
;
647 struct whiteheat_private
*info
;
648 __u8
*transfer_buffer
;
652 dbg("%s - command %d", __func__
, command
);
654 command_port
= port
->serial
->port
[COMMAND_PORT
];
655 command_info
= usb_get_serial_port_data(command_port
);
656 mutex_lock(&command_info
->mutex
);
657 command_info
->command_finished
= false;
659 transfer_buffer
= (__u8
*)command_port
->write_urb
->transfer_buffer
;
660 transfer_buffer
[0] = command
;
661 memcpy(&transfer_buffer
[1], data
, datasize
);
662 command_port
->write_urb
->transfer_buffer_length
= datasize
+ 1;
663 retval
= usb_submit_urb(command_port
->write_urb
, GFP_NOIO
);
665 dbg("%s - submit urb failed", __func__
);
669 /* wait for the command to complete */
670 t
= wait_event_timeout(command_info
->wait_command
,
671 (bool)command_info
->command_finished
, COMMAND_TIMEOUT
);
673 usb_kill_urb(command_port
->write_urb
);
675 if (command_info
->command_finished
== false) {
676 dbg("%s - command timed out.", __func__
);
681 if (command_info
->command_finished
== WHITEHEAT_CMD_FAILURE
) {
682 dbg("%s - command failed.", __func__
);
687 if (command_info
->command_finished
== WHITEHEAT_CMD_COMPLETE
) {
688 dbg("%s - command completed.", __func__
);
690 case WHITEHEAT_GET_DTR_RTS
:
691 info
= usb_get_serial_port_data(port
);
692 memcpy(&info
->mcr
, command_info
->result_buffer
,
693 sizeof(struct whiteheat_dr_info
));
698 mutex_unlock(&command_info
->mutex
);
703 static int firm_open(struct usb_serial_port
*port
)
705 struct whiteheat_simple open_command
;
707 open_command
.port
= port
->number
- port
->serial
->minor
+ 1;
708 return firm_send_command(port
, WHITEHEAT_OPEN
,
709 (__u8
*)&open_command
, sizeof(open_command
));
713 static int firm_close(struct usb_serial_port
*port
)
715 struct whiteheat_simple close_command
;
717 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
718 return firm_send_command(port
, WHITEHEAT_CLOSE
,
719 (__u8
*)&close_command
, sizeof(close_command
));
723 static void firm_setup_port(struct tty_struct
*tty
)
725 struct usb_serial_port
*port
= tty
->driver_data
;
726 struct whiteheat_port_settings port_settings
;
727 unsigned int cflag
= tty
->termios
->c_cflag
;
729 port_settings
.port
= port
->number
+ 1;
731 /* get the byte size */
732 switch (cflag
& CSIZE
) {
733 case CS5
: port_settings
.bits
= 5; break;
734 case CS6
: port_settings
.bits
= 6; break;
735 case CS7
: port_settings
.bits
= 7; break;
737 case CS8
: port_settings
.bits
= 8; break;
739 dbg("%s - data bits = %d", __func__
, port_settings
.bits
);
741 /* determine the parity */
745 port_settings
.parity
= WHITEHEAT_PAR_MARK
;
747 port_settings
.parity
= WHITEHEAT_PAR_SPACE
;
750 port_settings
.parity
= WHITEHEAT_PAR_ODD
;
752 port_settings
.parity
= WHITEHEAT_PAR_EVEN
;
754 port_settings
.parity
= WHITEHEAT_PAR_NONE
;
755 dbg("%s - parity = %c", __func__
, port_settings
.parity
);
757 /* figure out the stop bits requested */
759 port_settings
.stop
= 2;
761 port_settings
.stop
= 1;
762 dbg("%s - stop bits = %d", __func__
, port_settings
.stop
);
764 /* figure out the flow control settings */
766 port_settings
.hflow
= (WHITEHEAT_HFLOW_CTS
|
767 WHITEHEAT_HFLOW_RTS
);
769 port_settings
.hflow
= WHITEHEAT_HFLOW_NONE
;
770 dbg("%s - hardware flow control = %s %s %s %s", __func__
,
771 (port_settings
.hflow
& WHITEHEAT_HFLOW_CTS
) ? "CTS" : "",
772 (port_settings
.hflow
& WHITEHEAT_HFLOW_RTS
) ? "RTS" : "",
773 (port_settings
.hflow
& WHITEHEAT_HFLOW_DSR
) ? "DSR" : "",
774 (port_settings
.hflow
& WHITEHEAT_HFLOW_DTR
) ? "DTR" : "");
776 /* determine software flow control */
778 port_settings
.sflow
= WHITEHEAT_SFLOW_RXTX
;
780 port_settings
.sflow
= WHITEHEAT_SFLOW_NONE
;
781 dbg("%s - software flow control = %c", __func__
, port_settings
.sflow
);
783 port_settings
.xon
= START_CHAR(tty
);
784 port_settings
.xoff
= STOP_CHAR(tty
);
785 dbg("%s - XON = %2x, XOFF = %2x",
786 __func__
, port_settings
.xon
, port_settings
.xoff
);
788 /* get the baud rate wanted */
789 port_settings
.baud
= tty_get_baud_rate(tty
);
790 dbg("%s - baud rate = %d", __func__
, port_settings
.baud
);
792 /* fixme: should set validated settings */
793 tty_encode_baud_rate(tty
, port_settings
.baud
, port_settings
.baud
);
794 /* handle any settings that aren't specified in the tty structure */
795 port_settings
.lloop
= 0;
797 /* now send the message to the device */
798 firm_send_command(port
, WHITEHEAT_SETUP_PORT
,
799 (__u8
*)&port_settings
, sizeof(port_settings
));
803 static int firm_set_rts(struct usb_serial_port
*port
, __u8 onoff
)
805 struct whiteheat_set_rdb rts_command
;
807 rts_command
.port
= port
->number
- port
->serial
->minor
+ 1;
808 rts_command
.state
= onoff
;
809 return firm_send_command(port
, WHITEHEAT_SET_RTS
,
810 (__u8
*)&rts_command
, sizeof(rts_command
));
814 static int firm_set_dtr(struct usb_serial_port
*port
, __u8 onoff
)
816 struct whiteheat_set_rdb dtr_command
;
818 dtr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
819 dtr_command
.state
= onoff
;
820 return firm_send_command(port
, WHITEHEAT_SET_DTR
,
821 (__u8
*)&dtr_command
, sizeof(dtr_command
));
825 static int firm_set_break(struct usb_serial_port
*port
, __u8 onoff
)
827 struct whiteheat_set_rdb break_command
;
829 break_command
.port
= port
->number
- port
->serial
->minor
+ 1;
830 break_command
.state
= onoff
;
831 return firm_send_command(port
, WHITEHEAT_SET_BREAK
,
832 (__u8
*)&break_command
, sizeof(break_command
));
836 static int firm_purge(struct usb_serial_port
*port
, __u8 rxtx
)
838 struct whiteheat_purge purge_command
;
840 purge_command
.port
= port
->number
- port
->serial
->minor
+ 1;
841 purge_command
.what
= rxtx
;
842 return firm_send_command(port
, WHITEHEAT_PURGE
,
843 (__u8
*)&purge_command
, sizeof(purge_command
));
847 static int firm_get_dtr_rts(struct usb_serial_port
*port
)
849 struct whiteheat_simple get_dr_command
;
851 get_dr_command
.port
= port
->number
- port
->serial
->minor
+ 1;
852 return firm_send_command(port
, WHITEHEAT_GET_DTR_RTS
,
853 (__u8
*)&get_dr_command
, sizeof(get_dr_command
));
857 static int firm_report_tx_done(struct usb_serial_port
*port
)
859 struct whiteheat_simple close_command
;
861 close_command
.port
= port
->number
- port
->serial
->minor
+ 1;
862 return firm_send_command(port
, WHITEHEAT_REPORT_TX_DONE
,
863 (__u8
*)&close_command
, sizeof(close_command
));
867 /*****************************************************************************
868 * Connect Tech's White Heat utility functions
869 *****************************************************************************/
870 static int start_command_port(struct usb_serial
*serial
)
872 struct usb_serial_port
*command_port
;
873 struct whiteheat_command_private
*command_info
;
876 command_port
= serial
->port
[COMMAND_PORT
];
877 command_info
= usb_get_serial_port_data(command_port
);
878 mutex_lock(&command_info
->mutex
);
879 if (!command_info
->port_running
) {
880 /* Work around HCD bugs */
881 usb_clear_halt(serial
->dev
, command_port
->read_urb
->pipe
);
883 retval
= usb_submit_urb(command_port
->read_urb
, GFP_KERNEL
);
885 dev_err(&serial
->dev
->dev
,
886 "%s - failed submitting read urb, error %d\n",
891 command_info
->port_running
++;
894 mutex_unlock(&command_info
->mutex
);
899 static void stop_command_port(struct usb_serial
*serial
)
901 struct usb_serial_port
*command_port
;
902 struct whiteheat_command_private
*command_info
;
904 command_port
= serial
->port
[COMMAND_PORT
];
905 command_info
= usb_get_serial_port_data(command_port
);
906 mutex_lock(&command_info
->mutex
);
907 command_info
->port_running
--;
908 if (!command_info
->port_running
)
909 usb_kill_urb(command_port
->read_urb
);
910 mutex_unlock(&command_info
->mutex
);
913 module_usb_serial_driver(serial_drivers
, id_table_combined
);
915 MODULE_AUTHOR(DRIVER_AUTHOR
);
916 MODULE_DESCRIPTION(DRIVER_DESC
);
917 MODULE_LICENSE("GPL");
919 MODULE_FIRMWARE("whiteheat.fw");
920 MODULE_FIRMWARE("whiteheat_loader.fw");
922 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
923 MODULE_PARM_DESC(debug
, "Debug enabled or not");