2 * Driver for Quatech Inc USB2.0 to serial adaptors. Largely unrelated to the
3 * serqt_usb driver, based on a re-write of the vendor supplied serqt_usb2 code,
4 * which is unrelated to the serqt_usb2 in the staging kernel
7 #include <linux/errno.h>
8 #include <linux/init.h>
9 #include <linux/slab.h>
10 #include <linux/tty.h>
11 #include <linux/tty_driver.h>
12 #include <linux/tty_flip.h>
13 #include <linux/module.h>
14 #include <linux/serial.h>
15 #include <linux/usb.h>
16 #include <linux/usb/serial.h>
17 #include <linux/uaccess.h>
21 /* Version Information */
22 #define DRIVER_VERSION "v2.00"
23 #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
24 #define DRIVER_DESC "Quatech USB 2.0 to Serial Driver"
26 /* vendor and device IDs */
27 #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
28 #define QUATECH_SSU2_100 0xC120 /* RS232 single port */
29 #define QUATECH_DSU2_100 0xC140 /* RS232 dual port */
30 #define QUATECH_DSU2_400 0xC150 /* RS232/422/485 dual port */
31 #define QUATECH_QSU2_100 0xC160 /* RS232 four port */
32 #define QUATECH_QSU2_400 0xC170 /* RS232/422/485 four port */
33 #define QUATECH_ESU2_100 0xC1A0 /* RS232 eight port */
34 #define QUATECH_ESU2_400 0xC180 /* RS232/422/485 eight port */
36 /* magic numbers go here, when we find out which ones are needed */
38 #define QU2BOXPWRON 0x8000 /* magic number to turn FPGA power on */
39 #define QU2BOX232 0x40 /* RS232 mode on MEI devices */
40 #define QU2BOXSPD9600 0x60 /* set speed to 9600 baud */
41 #define QT2_FIFO_DEPTH 1024 /* size of hardware fifos */
42 #define QT2_TX_HEADER_LENGTH 5
43 /* length of the header sent to the box with each write URB */
45 /* directions for USB transfers */
46 #define USBD_TRANSFER_DIRECTION_IN 0xc0
47 #define USBD_TRANSFER_DIRECTION_OUT 0x40
49 /* special Quatech command IDs. These are pushed down the
50 USB control pipe to get the box on the end to do things */
51 #define QT_SET_GET_DEVICE 0xc2
52 #define QT_OPEN_CLOSE_CHANNEL 0xca
53 /*#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
54 #define QT_SET_ATF 0xcd*/
55 #define QT2_GET_SET_REGISTER 0xc0
56 #define QT2_GET_SET_UART 0xc1
57 #define QT2_HW_FLOW_CONTROL_MASK 0xc5
58 #define QT2_SW_FLOW_CONTROL_MASK 0xc6
59 #define QT2_SW_FLOW_CONTROL_DISABLE 0xc7
60 #define QT2_BREAK_CONTROL 0xc8
61 #define QT2_STOP_RECEIVE 0xe0
62 #define QT2_FLUSH_DEVICE 0xc4
63 #define QT2_GET_SET_QMCR 0xe1
65 /* sorts of flush we can do on */
66 #define QT2_FLUSH_RX 0x00
67 #define QT2_FLUSH_TX 0x01
69 /* port setting constants, used to set up serial port speeds, flow
70 * control and so on */
71 #define QT2_SERIAL_MCR_DTR 0x01
72 #define QT2_SERIAL_MCR_RTS 0x02
73 #define QT2_SERIAL_MCR_LOOP 0x10
75 #define QT2_SERIAL_MSR_CTS 0x10
76 #define QT2_SERIAL_MSR_CD 0x80
77 #define QT2_SERIAL_MSR_RI 0x40
78 #define QT2_SERIAL_MSR_DSR 0x20
79 #define QT2_SERIAL_MSR_MASK 0xf0
81 #define QT2_SERIAL_8_DATA 0x03
82 #define QT2_SERIAL_7_DATA 0x02
83 #define QT2_SERIAL_6_DATA 0x01
84 #define QT2_SERIAL_5_DATA 0x00
86 #define QT2_SERIAL_ODD_PARITY 0x08
87 #define QT2_SERIAL_EVEN_PARITY 0x18
88 #define QT2_SERIAL_TWO_STOPB 0x04
89 #define QT2_SERIAL_ONE_STOPB 0x00
91 #define QT2_MAX_BAUD_RATE 921600
92 #define QT2_MAX_BAUD_REMAINDER 4608
94 #define QT2_SERIAL_LSR_OE 0x02
95 #define QT2_SERIAL_LSR_PE 0x04
96 #define QT2_SERIAL_LSR_FE 0x08
97 #define QT2_SERIAL_LSR_BI 0x10
99 /* value of Line Status Register when UART has completed
100 * emptying data out on the line */
101 #define QT2_LSR_TEMT 0x40
103 /* register numbers on each UART, for use with qt2_box_[get|set]_register*/
104 #define QT2_XMT_HOLD_REGISTER 0x00
105 #define QT2_XVR_BUFFER_REGISTER 0x00
106 #define QT2_FIFO_CONTROL_REGISTER 0x02
107 #define QT2_LINE_CONTROL_REGISTER 0x03
108 #define QT2_MODEM_CONTROL_REGISTER 0x04
109 #define QT2_LINE_STATUS_REGISTER 0x05
110 #define QT2_MODEM_STATUS_REGISTER 0x06
112 /* handy macros for doing escape sequence parsing on data reads */
113 #define THISCHAR ((unsigned char *)(urb->transfer_buffer))[i]
114 #define NEXTCHAR ((unsigned char *)(urb->transfer_buffer))[i + 1]
115 #define THIRDCHAR ((unsigned char *)(urb->transfer_buffer))[i + 2]
116 #define FOURTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 3]
117 #define FIFTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 4]
119 static const struct usb_device_id quausb2_id_table
[] = {
120 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_SSU2_100
)},
121 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_DSU2_100
)},
122 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_DSU2_400
)},
123 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_QSU2_100
)},
124 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_QSU2_400
)},
125 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_ESU2_100
)},
126 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_ESU2_400
)},
127 {} /* Terminating entry */
130 MODULE_DEVICE_TABLE(usb
, quausb2_id_table
);
132 /* custom structures we need go here */
133 static struct usb_driver quausb2_usb_driver
= {
134 .name
= "quatech-usb2-serial",
135 .probe
= usb_serial_probe
,
136 .disconnect
= usb_serial_disconnect
,
137 .id_table
= quausb2_id_table
,
142 * quatech2_port: Structure in which to keep all the messy stuff that this
143 * driver needs alongside the usb_serial_port structure
144 * @read_urb_busy: Flag indicating that port->read_urb is in use
145 * @close_pending: flag indicating that this port is in the process of
146 * being closed (and so no new reads / writes should be started).
147 * @shadowLSR: Last received state of the line status register, holds the
148 * value of the line status flags from the port
149 * @shadowMSR: Last received state of the modem status register, holds
150 * the value of the modem status received from the port
151 * @rcv_flush: Flag indicating that a receive flush has occured on
153 * @xmit_flush: Flag indicating that a transmit flush has been processed by
155 * @tx_pending_bytes: Number of bytes waiting to be sent. This total
156 * includes the size (excluding header) of URBs that have been submitted but
157 * have not yet been sent to to the device, and bytes that have been sent out
158 * of the port but not yet reported sent by the "xmit_empty" messages (which
159 * indicate the number of bytes sent each time they are recieved, despite the
161 * - Starts at zero when port is initialised.
162 * - is incremented by the size of the data to be written (no headers)
163 * each time a write urb is dispatched.
164 * - is decremented each time a "transmit empty" message is received
165 * by the driver in the data stream.
166 * @lock: Mutex to lock access to this structure when we need to ensure that
167 * races don't occur to access bits of it.
168 * @open_count: The number of uses of the port currently having
169 * it open, i.e. the reference count.
171 struct quatech2_port
{
179 int tx_pending_bytes
;
180 struct mutex modelock
;
183 char active
; /* someone has this device open */
184 unsigned char *xfer_to_tty_buffer
;
185 wait_queue_head_t wait
;
186 __u8 shadowLCR
; /* last LCR value received */
187 __u8 shadowMCR
; /* last MCR value received */
189 struct semaphore pend_xmit_sem
; /* locks this structure */
194 * Structure to hold device-wide internal status information
195 * @param ReadBulkStopped The last bulk read attempt ended in tears
196 * @param open_ports The number of serial ports currently in use on the box
197 * @param current_port Pointer to the serial port structure of the port which
198 * the read stream is currently directed to. Escape sequences in the read
199 * stream will change this around as data arrives from different ports on the
201 * @buffer_size: The max size buffer each URB can take, used to set the size of
202 * the buffers allocated for writing to each port on the device (we need to
203 * store this because it is known only to the endpoint, but used each time a
204 * port is opened and a new buffer is allocated.
206 struct quatech2_dev
{
207 bool ReadBulkStopped
;
209 struct usb_serial_port
*current_port
;
213 /* structure which holds line and modem status flags */
214 struct qt2_status_data
{
219 /* Function prototypes */
220 static int qt2_boxpoweron(struct usb_serial
*serial
);
221 static int qt2_boxsetQMCR(struct usb_serial
*serial
, __u16 Uart_Number
,
223 static int port_paranoia_check(struct usb_serial_port
*port
,
224 const char *function
);
225 static int serial_paranoia_check(struct usb_serial
*serial
,
226 const char *function
);
227 static inline struct quatech2_port
*qt2_get_port_private(struct usb_serial_port
229 static inline void qt2_set_port_private(struct usb_serial_port
*port
,
230 struct quatech2_port
*data
);
231 static inline struct quatech2_dev
*qt2_get_dev_private(struct usb_serial
233 static inline void qt2_set_dev_private(struct usb_serial
*serial
,
234 struct quatech2_dev
*data
);
235 static int qt2_openboxchannel(struct usb_serial
*serial
, __u16
236 Uart_Number
, struct qt2_status_data
*pDeviceData
);
237 static int qt2_closeboxchannel(struct usb_serial
*serial
, __u16
239 static int qt2_conf_uart(struct usb_serial
*serial
, unsigned short Uart_Number
,
240 unsigned short divisor
, unsigned char LCR
);
241 static void qt2_read_bulk_callback(struct urb
*urb
);
242 static void qt2_write_bulk_callback(struct urb
*urb
);
243 static void qt2_process_line_status(struct usb_serial_port
*port
,
244 unsigned char LineStatus
);
245 static void qt2_process_modem_status(struct usb_serial_port
*port
,
246 unsigned char ModemStatus
);
247 static void qt2_process_xmit_empty(struct usb_serial_port
*port
,
248 unsigned char fourth_char
, unsigned char fifth_char
);
249 static void qt2_process_port_change(struct usb_serial_port
*port
,
250 unsigned char New_Current_Port
);
251 static void qt2_process_rcv_flush(struct usb_serial_port
*port
);
252 static void qt2_process_xmit_flush(struct usb_serial_port
*port
);
253 static void qt2_process_rx_char(struct usb_serial_port
*port
,
255 static int qt2_box_get_register(struct usb_serial
*serial
,
256 unsigned char uart_number
, unsigned short register_num
,
258 static int qt2_box_set_register(struct usb_serial
*serial
,
259 unsigned short Uart_Number
, unsigned short Register_Num
,
260 unsigned short Value
);
261 static int qt2_boxsetuart(struct usb_serial
*serial
, unsigned short Uart_Number
,
262 unsigned short default_divisor
, unsigned char default_LCR
);
263 static int qt2_boxsethw_flowctl(struct usb_serial
*serial
,
264 unsigned int UartNumber
, bool bSet
);
265 static int qt2_boxsetsw_flowctl(struct usb_serial
*serial
, __u16 UartNumber
,
266 unsigned char stop_char
, unsigned char start_char
);
267 static int qt2_boxunsetsw_flowctl(struct usb_serial
*serial
, __u16 UartNumber
);
268 static int qt2_boxstoprx(struct usb_serial
*serial
, unsigned short uart_number
,
269 unsigned short stop
);
271 /* implementation functions, roughly in order of use, are here */
272 static int qt2_calc_num_ports(struct usb_serial
*serial
)
276 switch (serial
->dev
->descriptor
.idProduct
) {
277 case QUATECH_SSU2_100
:
281 case QUATECH_DSU2_400
:
283 case QUATECH_DSU2_100
:
287 case QUATECH_QSU2_400
:
289 case QUATECH_QSU2_100
:
293 case QUATECH_ESU2_400
:
295 case QUATECH_ESU2_100
:
305 static int qt2_attach(struct usb_serial
*serial
)
307 struct usb_serial_port
*port
;
308 struct quatech2_port
*qt2_port
; /* port-specific private data pointer */
309 struct quatech2_dev
*qt2_dev
; /* dev-specific private data pointer */
311 /* stuff for storing endpoint addresses now */
312 struct usb_endpoint_descriptor
*endpoint
;
313 struct usb_host_interface
*iface_desc
;
314 struct usb_serial_port
*port0
; /* first port structure on device */
316 /* check how many endpoints there are on the device, for
318 dbg("%s(): Endpoints: %d bulk in, %d bulk out, %d interrupt in",
319 __func__
, serial
->num_bulk_in
,
320 serial
->num_bulk_out
, serial
->num_interrupt_in
);
321 if ((serial
->num_bulk_in
!= 1) || (serial
->num_bulk_out
!= 1)) {
322 dbg("Device has wrong number of bulk endpoints!");
325 iface_desc
= serial
->interface
->cur_altsetting
;
327 /* Set up per-device private data, storing extra data alongside
328 * struct usb_serial */
329 qt2_dev
= kzalloc(sizeof(*qt2_dev
), GFP_KERNEL
);
331 dbg("%s: kmalloc for quatech2_dev failed!",
335 qt2_dev
->open_ports
= 0; /* no ports open */
336 qt2_set_dev_private(serial
, qt2_dev
); /* store private data */
338 /* Now setup per port private data, which replaces all the things
339 * that quatech added to standard kernel structures in their driver */
340 for (i
= 0; i
< serial
->num_ports
; i
++) {
341 port
= serial
->port
[i
];
342 qt2_port
= kzalloc(sizeof(*qt2_port
), GFP_KERNEL
);
344 dbg("%s: kmalloc for quatech2_port (%d) failed!.",
348 /* initialise stuff in the structure */
349 qt2_port
->open_count
= 0; /* port is not open */
350 spin_lock_init(&qt2_port
->lock
);
351 mutex_init(&qt2_port
->modelock
);
352 qt2_set_port_private(port
, qt2_port
);
355 /* gain access to port[0]'s structure because we want to store
356 * device-level stuff in it */
357 if (serial_paranoia_check(serial
, __func__
))
359 port0
= serial
->port
[0]; /* get the first port's device structure */
361 /* print endpoint addresses so we can check them later
363 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
364 endpoint
= &iface_desc
->endpoint
[i
].desc
;
365 if ((endpoint
->bEndpointAddress
& 0x80) &&
366 ((endpoint
->bmAttributes
& 3) == 0x02)) {
367 /* we found a bulk in endpoint */
368 dbg("found bulk in at %#.2x",
369 endpoint
->bEndpointAddress
);
372 if (((endpoint
->bEndpointAddress
& 0x80) == 0x00) &&
373 ((endpoint
->bmAttributes
& 3) == 0x02)) {
374 /* we found a bulk out endpoint */
375 dbg("found bulk out at %#.2x",
376 endpoint
->bEndpointAddress
);
377 qt2_dev
->buffer_size
= endpoint
->wMaxPacketSize
;
378 /* max size of URB needs recording for the device */
380 } /* end printing endpoint addresses */
382 /* switch on power to the hardware */
383 if (qt2_boxpoweron(serial
) < 0) {
384 dbg("qt2_boxpoweron() failed");
387 /* set all ports to RS232 mode */
388 for (i
= 0; i
< serial
->num_ports
; ++i
) {
389 if (qt2_boxsetQMCR(serial
, i
, QU2BOX232
) < 0) {
390 dbg("qt2_boxsetQMCR() on port %d failed",
399 for (i
= 0; i
< serial
->num_ports
; i
++) {
400 port
= serial
->port
[i
];
401 qt2_port
= qt2_get_port_private(port
);
403 qt2_set_port_private(port
, NULL
);
405 qt2_dev
= qt2_get_dev_private(serial
);
407 qt2_set_dev_private(serial
, NULL
);
409 dbg("Exit fail %s\n", __func__
);
413 static void qt2_release(struct usb_serial
*serial
)
415 struct usb_serial_port
*port
;
416 struct quatech2_port
*qt_port
;
419 dbg("enterting %s", __func__
);
421 for (i
= 0; i
< serial
->num_ports
; i
++) {
422 port
= serial
->port
[i
];
426 qt_port
= usb_get_serial_port_data(port
);
428 usb_set_serial_port_data(port
, NULL
);
431 /* This function is called once per serial port on the device, when
432 * that port is opened by a userspace application.
433 * The tty_struct and the usb_serial_port belong to this port,
434 * i.e. there are multiple ones for a multi-port device.
435 * However the usb_serial_port structure has a back-pointer
436 * to the parent usb_serial structure which belongs to the device,
437 * so we can access either the device-wide information or
438 * any other port's information (because there are also forward
439 * pointers) via that pointer.
440 * This is most helpful if the device shares resources (e.g. end
441 * points) between different ports
443 int qt2_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
445 struct usb_serial
*serial
; /* device structure */
446 struct usb_serial_port
*port0
; /* first port structure on device */
447 struct quatech2_port
*port_extra
; /* extra data for this port */
448 struct quatech2_port
*port0_extra
; /* extra data for first port */
449 struct quatech2_dev
*dev_extra
; /* extra data for the device */
450 struct qt2_status_data ChannelData
;
451 unsigned short default_divisor
= QU2BOXSPD9600
;
452 unsigned char default_LCR
= QT2_SERIAL_8_DATA
;
456 if (port_paranoia_check(port
, __func__
))
459 dbg("%s(): port %d", __func__
, port
->number
);
461 serial
= port
->serial
; /* get the parent device structure */
462 if (serial_paranoia_check(serial
, __func__
)) {
463 dbg("usb_serial struct failed sanity check");
466 dev_extra
= qt2_get_dev_private(serial
);
467 /* get the device private data */
468 if (dev_extra
== NULL
) {
469 dbg("device extra data pointer is null");
472 port0
= serial
->port
[0]; /* get the first port's device structure */
473 if (port_paranoia_check(port0
, __func__
)) {
474 dbg("port0 usb_serial_port struct failed sanity check");
478 port_extra
= qt2_get_port_private(port
);
479 port0_extra
= qt2_get_port_private(port0
);
480 if (port_extra
== NULL
|| port0_extra
== NULL
) {
481 dbg("failed to get private data for port or port0");
485 /* get the modem and line status values from the UART */
486 status
= qt2_openboxchannel(serial
, port
->number
,
489 dbg("qt2_openboxchannel on channel %d failed",
493 port_extra
->shadowLSR
= ChannelData
.line_status
&
494 (QT2_SERIAL_LSR_OE
| QT2_SERIAL_LSR_PE
|
495 QT2_SERIAL_LSR_FE
| QT2_SERIAL_LSR_BI
);
496 port_extra
->shadowMSR
= ChannelData
.modem_status
&
497 (QT2_SERIAL_MSR_CTS
| QT2_SERIAL_MSR_DSR
|
498 QT2_SERIAL_MSR_RI
| QT2_SERIAL_MSR_CD
);
500 /* port_extra->fifo_empty_flag = true;*/
501 dbg("qt2_openboxchannel on channel %d completed.",
504 /* Set Baud rate to default and turn off flow control here */
505 status
= qt2_conf_uart(serial
, port
->number
, default_divisor
,
508 dbg("qt2_conf_uart() failed on channel %d",
512 dbg("qt2_conf_uart() completed on channel %d",
516 * At this point we will need some end points to make further progress.
517 * Handlily, the correct endpoint addresses have been filled out into
518 * the usb_serial_port structure for us by the driver core, so we
519 * already have access to them.
520 * As there is only one bulk in and one bulk out end-point, these are in
521 * port[0]'s structure, and the rest are uninitialised. Handily,
522 * when we do a write to a port, we will use the same endpoint
523 * regardless of the port, with a 5-byte header added on to
524 * tell the box which port it should eventually come out of, so we only
525 * need the one set of endpoints. We will have one URB per port for
526 * writing, so that multiple ports can be writing at once.
527 * Finally we need a bulk in URB to use for background reads from the
528 * device, which will deal with uplink data from the box to host.
530 dbg("port0 bulk in endpoint is %#.2x", port0
->bulk_in_endpointAddress
);
531 dbg("port0 bulk out endpoint is %#.2x",
532 port0
->bulk_out_endpointAddress
);
534 /* set up write_urb for bulk out transfers on this port. The USB
535 * serial framework will have allocated a blank URB, buffer etc for
536 * port0 when it put the endpoints there, but not for any of the other
537 * ports on the device because there are no more endpoints. Thus we
538 * have to allocate our own URBs for ports 1-7
540 if (port
->write_urb
== NULL
) {
541 dbg("port->write_urb == NULL, allocating one");
542 port
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
543 if (!port
->write_urb
) {
544 err("Allocating write URB failed");
547 /* buffer same size as port0 */
548 port
->bulk_out_size
= dev_extra
->buffer_size
;
549 port
->bulk_out_buffer
= kmalloc(port
->bulk_out_size
,
551 if (!port
->bulk_out_buffer
) {
552 err("Couldn't allocate bulk_out_buffer");
556 if (serial
->dev
== NULL
)
557 dbg("serial->dev == NULL");
558 dbg("port->bulk_out_size is %d", port
->bulk_out_size
);
560 usb_fill_bulk_urb(port
->write_urb
, serial
->dev
,
561 usb_sndbulkpipe(serial
->dev
,
562 port0
->bulk_out_endpointAddress
),
563 port
->bulk_out_buffer
,
565 qt2_write_bulk_callback
,
567 port_extra
->tx_pending_bytes
= 0;
569 if (dev_extra
->open_ports
== 0) {
570 /* this is first port to be opened, so need the read URB
571 * initialised for bulk in transfers (this is shared amongst
572 * all the ports on the device) */
573 usb_fill_bulk_urb(port0
->read_urb
, serial
->dev
,
574 usb_rcvbulkpipe(serial
->dev
,
575 port0
->bulk_in_endpointAddress
),
576 port0
->bulk_in_buffer
,
578 qt2_read_bulk_callback
, serial
);
579 dbg("port0 bulk in URB intialised");
581 /* submit URB, i.e. start reading from device (async) */
582 dev_extra
->ReadBulkStopped
= false;
583 port_extra
->read_urb_busy
= true;
584 result
= usb_submit_urb(port
->read_urb
, GFP_KERNEL
);
587 "%s(): Error %d submitting bulk in urb",
589 port_extra
->read_urb_busy
= false;
590 dev_extra
->ReadBulkStopped
= true;
593 /* When the first port is opened, initialise the value of
594 * current_port in dev_extra to this port, so it is set
595 * to something. Once the box sends data it will send the
596 * relevant escape sequences to get it to the right port anyway
598 dev_extra
->current_port
= port
;
601 /* initialize our wait queues */
602 init_waitqueue_head(&port_extra
->wait
);
603 /* increment the count of openings of this port by one */
604 port_extra
->open_count
++;
606 /* remember to store dev_extra, port_extra and port0_extra back again at
608 qt2_set_port_private(port
, port_extra
);
609 qt2_set_port_private(serial
->port
[0], port0_extra
);
610 qt2_set_dev_private(serial
, dev_extra
);
612 dev_extra
->open_ports
++; /* one more port opened */
617 /* called when a port is closed by userspace. It won't be called, however,
618 * until calls to chars_in_buffer() reveal that the port has completed
619 * sending buffered data, and there is nothing else to do. Thus we don't have
620 * to rely on forcing data through in this function. */
621 /* Setting close_pending should keep new data from being written out,
622 * once all the data in the enpoint buffers is moved out we won't get
624 /* BoxStopReceive would keep any more data from coming from a given
625 * port, but isn't called by the vendor driver, although their comments
626 * mention it. Should it be used here to stop the inbound data
629 static void qt2_close(struct usb_serial_port
*port
)
631 /* time out value for flush loops */
633 struct quatech2_port
*port_extra
; /* extra data for this port */
634 struct usb_serial
*serial
; /* device structure */
635 struct quatech2_dev
*dev_extra
; /* extra data for the device */
636 __u8 lsr_value
= 0; /* value of Line Status Register */
637 int status
; /* result of last USB comms function */
639 dbg("%s(): port %d", __func__
, port
->number
);
640 serial
= port
->serial
; /* get the parent device structure */
641 dev_extra
= qt2_get_dev_private(serial
);
642 /* get the device private data */
643 port_extra
= qt2_get_port_private(port
); /* port private data */
645 /* we can now (and only now) stop reading data */
646 port_extra
->close_pending
= true;
647 dbg("%s(): port_extra->close_pending = true", __func__
);
648 /* although the USB side is now empty, the UART itself may
649 * still be pushing characters out over the line, so we have to
650 * wait testing the actual line status until the lines change
651 * indicating that the data is done transfering. */
652 jift
= jiffies
+ (10 * HZ
); /* 10 sec timeout */
654 status
= qt2_box_get_register(serial
, port
->number
,
655 QT2_LINE_STATUS_REGISTER
, &lsr_value
);
657 dbg("%s(): qt2_box_get_register failed", __func__
);
660 if ((lsr_value
& QT2_LSR_TEMT
)) {
661 dbg("UART done sending");
665 } while (jiffies
<= jift
);
667 status
= qt2_closeboxchannel(serial
, port
->number
);
669 dbg("%s(): port %d qt2_box_open_close_channel failed",
670 __func__
, port
->number
);
671 /* to avoid leaking URBs, we should now free the write_urb for this
672 * port and set the pointer to null so that next time the port is opened
673 * a new URB is allocated. This avoids leaking URBs when the device is
675 usb_free_urb(port
->write_urb
);
676 kfree(port
->bulk_out_buffer
);
677 port
->bulk_out_buffer
= NULL
;
678 port
->bulk_out_size
= 0;
680 /* decrement the count of openings of this port by one */
681 port_extra
->open_count
--;
682 /* one less overall open as well */
683 dev_extra
->open_ports
--;
684 dbg("%s(): Exit, dev_extra->open_ports = %d", __func__
,
685 dev_extra
->open_ports
);
689 * qt2_write - write bytes from the tty layer out to the USB device.
690 * @buf: The data to be written, size at least count.
691 * @count: The number of bytes requested for transmission.
692 * @return The number of bytes actually accepted for transmission to the device.
694 static int qt2_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
695 const unsigned char *buf
, int count
)
697 struct usb_serial
*serial
; /* parent device struct */
698 __u8 header_array
[5]; /* header used to direct writes to the correct
699 port on the device */
700 struct quatech2_port
*port_extra
; /* extra data for this port */
703 serial
= port
->serial
; /* get the parent device of the port */
704 port_extra
= qt2_get_port_private(port
); /* port extra info */
707 dbg("%s(): port %d, requested to write %d bytes, %d already pending",
708 __func__
, port
->number
, count
, port_extra
->tx_pending_bytes
);
711 dbg("%s(): write request of <= 0 bytes", __func__
);
712 return 0; /* no bytes written */
715 /* check if the write urb is already in use, i.e. data already being
716 * sent to this port */
717 if ((port
->write_urb
->status
== -EINPROGRESS
)) {
718 /* Fifo hasn't been emptied since last write to this port */
719 dbg("%s(): already writing, port->write_urb->status == "
720 "-EINPROGRESS", __func__
);
721 /* schedule_work(&port->work); commented in vendor driver */
723 } else if (port_extra
->tx_pending_bytes
>= QT2_FIFO_DEPTH
) {
724 /* buffer is full (==). > should not occur, but would indicate
725 * that an overflow had occured */
726 dbg("%s(): port transmit buffer is full!", __func__
);
727 /* schedule_work(&port->work); commented in vendor driver */
731 /* We must fill the first 5 bytes of anything we sent with a transmit
732 * header which directes the data to the correct port. The maximum
733 * size we can send out in one URB is port->bulk_out_size, which caps
734 * the number of bytes of real data we can send in each write. As the
735 * semantics of write allow us to write less than we were give, we cap
736 * the maximum we will ever write to the device as 5 bytes less than
737 * one URB's worth, by reducing the value of the count argument
739 if (count
> port
->bulk_out_size
- QT2_TX_HEADER_LENGTH
) {
740 count
= port
->bulk_out_size
- QT2_TX_HEADER_LENGTH
;
741 dbg("%s(): write request bigger than urb, only accepting "
742 "%d bytes", __func__
, count
);
744 /* we must also ensure that the FIFO at the other end can cope with the
745 * URB we send it, otherwise it will have problems. As above, we can
746 * restrict the write size by just shrinking count.*/
747 if (count
> (QT2_FIFO_DEPTH
- port_extra
->tx_pending_bytes
)) {
748 count
= QT2_FIFO_DEPTH
- port_extra
->tx_pending_bytes
;
749 dbg("%s(): not enough room in buffer, only accepting %d bytes",
752 /* now build the header for transmission */
753 header_array
[0] = 0x1b;
754 header_array
[1] = 0x1b;
755 header_array
[2] = (__u8
)port
->number
;
756 header_array
[3] = (__u8
)count
;
757 header_array
[4] = (__u8
)count
>> 8;
758 /* copy header into URB */
759 memcpy(port
->write_urb
->transfer_buffer
, header_array
,
760 QT2_TX_HEADER_LENGTH
);
761 /* and actual data to write */
762 memcpy(port
->write_urb
->transfer_buffer
+ 5, buf
, count
);
764 dbg("%s(): first data byte to send = %#.2x", __func__
, *buf
);
767 usb_fill_bulk_urb(port
->write_urb
, serial
->dev
,
768 usb_sndbulkpipe(serial
->dev
,
769 port
->bulk_out_endpointAddress
),
770 port
->write_urb
->transfer_buffer
, count
+ 5,
771 (qt2_write_bulk_callback
), port
);
772 /* send the data out the bulk port */
773 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
775 /* error couldn't submit urb */
776 result
= 0; /* return 0 as nothing got written */
777 dbg("%s(): failed submitting write urb, error %d",
780 port_extra
->tx_pending_bytes
+= count
;
781 result
= count
; /* return number of bytes written, i.e. count */
782 dbg("%s(): submitted write urb, wrote %d bytes, "
783 "total pending bytes %d",
784 __func__
, result
, port_extra
->tx_pending_bytes
);
789 /* This is used by the next layer up to know how much space is available
790 * in the buffer on the device. It is used on a device closure to avoid
791 * calling close() until the buffer is reported to be empty.
792 * The returned value must never go down by more than the number of bytes
793 * written for correct behaviour further up the driver stack, i.e. if I call
794 * it, then write 6 bytes, then call again I should get 6 less, or possibly
795 * only 5 less if one was written in the meantime, etc. I should never get 7
796 * less (or any bigger number) because I only wrote 6 bytes.
798 static int qt2_write_room(struct tty_struct
*tty
)
800 struct usb_serial_port
*port
= tty
->driver_data
;
801 /* parent usb_serial_port pointer */
802 struct quatech2_port
*port_extra
; /* extra data for this port */
804 port_extra
= qt2_get_port_private(port
);
806 if (port_extra
->close_pending
== true) {
807 dbg("%s(): port_extra->close_pending == true", __func__
);
810 /* Q: how many bytes would a write() call actually succeed in writing
811 * if it happened now?
812 * A: one QT2_FIFO_DEPTH, less the number of bytes waiting to be sent
813 * out of the port, unless this is more than the size of the
814 * write_urb output buffer less the header, which is the maximum
815 * size write we can do.
817 * Most of the implementation of this is done when writes to the device
818 * are started or terminate. When we send a write to the device, we
819 * reduce the free space count by the size of the dispatched write.
820 * When a "transmit empty" message comes back up the USB read stream,
821 * we decrement the count by the number of bytes reported sent, thus
822 * keeping track of the difference between sent and recieved bytes.
825 room
= (QT2_FIFO_DEPTH
- port_extra
->tx_pending_bytes
);
827 if (room
> port
->bulk_out_size
- QT2_TX_HEADER_LENGTH
)
828 room
= port
->bulk_out_size
- QT2_TX_HEADER_LENGTH
;
829 /* if more than the URB can hold, then cap to that limit */
831 dbg("%s(): port %d: write room is %d", __func__
, port
->number
, room
);
835 static int qt2_chars_in_buffer(struct tty_struct
*tty
)
837 struct usb_serial_port
*port
= tty
->driver_data
;
838 /* parent usb_serial_port pointer */
839 struct quatech2_port
*port_extra
; /* extra data for this port */
840 port_extra
= qt2_get_port_private(port
);
842 dbg("%s(): port %d: chars_in_buffer = %d", __func__
,
843 port
->number
, port_extra
->tx_pending_bytes
);
844 return port_extra
->tx_pending_bytes
;
847 /* called when userspace does an ioctl() on the device. Note that
848 * TIOCMGET and TIOCMSET are filtered off to their own methods before they get
849 * here, so we don't have to handle them.
851 static int qt2_ioctl(struct tty_struct
*tty
, struct file
*file
,
852 unsigned int cmd
, unsigned long arg
)
854 struct usb_serial_port
*port
= tty
->driver_data
;
855 struct usb_serial
*serial
= port
->serial
;
856 __u8 mcr_value
; /* Modem Control Register value */
857 __u8 msr_value
; /* Modem Status Register value */
858 unsigned short prev_msr_value
; /* Previous value of Modem Status
859 * Register used to implement waiting for a line status change to
861 struct quatech2_port
*port_extra
; /* extra data for this port */
862 DECLARE_WAITQUEUE(wait
, current
);
863 /* Declare a wait queue named "wait" */
866 unsigned int UartNumber
;
870 UartNumber
= tty
->index
- serial
->minor
;
871 port_extra
= qt2_get_port_private(port
);
873 dbg("%s(): port %d, UartNumber %d, tty =0x%p", __func__
,
874 port
->number
, UartNumber
, tty
);
876 if (cmd
== TIOCMBIS
|| cmd
== TIOCMBIC
) {
877 if (qt2_box_get_register(port
->serial
, UartNumber
,
878 QT2_MODEM_CONTROL_REGISTER
, &mcr_value
) < 0)
880 if (copy_from_user(&value
, (unsigned int *)arg
,
886 if (value
& TIOCM_RTS
)
887 mcr_value
|= QT2_SERIAL_MCR_RTS
;
888 if (value
& TIOCM_DTR
)
889 mcr_value
|= QT2_SERIAL_MCR_DTR
;
890 if (value
& TIOCM_LOOP
)
891 mcr_value
|= QT2_SERIAL_MCR_LOOP
;
894 if (value
& TIOCM_RTS
)
895 mcr_value
&= ~QT2_SERIAL_MCR_RTS
;
896 if (value
& TIOCM_DTR
)
897 mcr_value
&= ~QT2_SERIAL_MCR_DTR
;
898 if (value
& TIOCM_LOOP
)
899 mcr_value
&= ~QT2_SERIAL_MCR_LOOP
;
903 } /* end of local switch on cmd */
904 if (qt2_box_set_register(port
->serial
, UartNumber
,
905 QT2_MODEM_CONTROL_REGISTER
, mcr_value
) < 0) {
908 port_extra
->shadowMCR
= mcr_value
;
911 } else if (cmd
== TIOCMIWAIT
) {
912 dbg("%s() port %d, cmd == TIOCMIWAIT enter",
913 __func__
, port
->number
);
914 prev_msr_value
= port_extra
->shadowMSR
& QT2_SERIAL_MSR_MASK
;
916 add_wait_queue(&port_extra
->wait
, &wait
);
917 set_current_state(TASK_INTERRUPTIBLE
);
919 dbg("%s(): port %d, cmd == TIOCMIWAIT here\n",
920 __func__
, port
->number
);
921 remove_wait_queue(&port_extra
->wait
, &wait
);
922 /* see if a signal woke us up */
923 if (signal_pending(current
))
925 msr_value
= port_extra
->shadowMSR
& QT2_SERIAL_MSR_MASK
;
926 if (msr_value
== prev_msr_value
)
927 return -EIO
; /* no change - error */
928 if ((arg
& TIOCM_RNG
&&
929 ((prev_msr_value
& QT2_SERIAL_MSR_RI
) ==
930 (msr_value
& QT2_SERIAL_MSR_RI
))) ||
932 ((prev_msr_value
& QT2_SERIAL_MSR_DSR
) ==
933 (msr_value
& QT2_SERIAL_MSR_DSR
))) ||
935 ((prev_msr_value
& QT2_SERIAL_MSR_CD
) ==
936 (msr_value
& QT2_SERIAL_MSR_CD
))) ||
938 ((prev_msr_value
& QT2_SERIAL_MSR_CTS
) ==
939 (msr_value
& QT2_SERIAL_MSR_CTS
)))) {
942 } /* end inifinite while */
944 /* any other ioctls we don't know about come here */
945 dbg("%s(): No ioctl for that one. port = %d", __func__
,
951 /* Called when the user wishes to change the port settings using the termios
952 * userspace interface */
953 static void qt2_set_termios(struct tty_struct
*tty
,
954 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
956 struct usb_serial
*serial
; /* parent serial device */
957 int baud
, divisor
, remainder
;
958 unsigned char LCR_change_to
= 0;
962 dbg("%s(): port %d", __func__
, port
->number
);
964 serial
= port
->serial
;
966 UartNumber
= port
->number
;
968 if (old_termios
&& !tty_termios_hw_change(old_termios
, tty
->termios
))
971 switch (tty
->termios
->c_cflag
) {
973 LCR_change_to
|= QT2_SERIAL_5_DATA
;
976 LCR_change_to
|= QT2_SERIAL_6_DATA
;
979 LCR_change_to
|= QT2_SERIAL_7_DATA
;
983 LCR_change_to
|= QT2_SERIAL_8_DATA
;
988 if (tty
->termios
->c_cflag
& PARENB
) {
989 if (tty
->termios
->c_cflag
& PARODD
)
990 LCR_change_to
|= QT2_SERIAL_ODD_PARITY
;
992 LCR_change_to
|= QT2_SERIAL_EVEN_PARITY
;
994 /* Because LCR_change_to is initialised to zero, we don't have to worry
995 * about the case where PARENB is not set or clearing bits, because by
996 * default all of them are cleared, turning parity off.
997 * as we don't support mark/space parity, we should clear the
998 * mark/space parity bit in c_cflag, so the caller can tell we have
999 * ignored the request */
1000 tty
->termios
->c_cflag
&= ~CMSPAR
;
1002 if (tty
->termios
->c_cflag
& CSTOPB
)
1003 LCR_change_to
|= QT2_SERIAL_TWO_STOPB
;
1005 LCR_change_to
|= QT2_SERIAL_ONE_STOPB
;
1007 /* Thats the LCR stuff, next we need to work out the divisor as the
1008 * LCR and the divisor are set together */
1009 baud
= tty_get_baud_rate(tty
);
1011 /* pick a default, any default... */
1014 dbg("%s(): got baud = %d", __func__
, baud
);
1016 divisor
= QT2_MAX_BAUD_RATE
/ baud
;
1017 remainder
= QT2_MAX_BAUD_RATE
% baud
;
1018 /* Round to nearest divisor */
1019 if (((remainder
* 2) >= baud
) && (baud
!= 110))
1021 dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = %#.2x",
1022 __func__
, divisor
, QT2_MAX_BAUD_RATE
, LCR_change_to
);
1024 status
= qt2_boxsetuart(serial
, UartNumber
, (unsigned short) divisor
,
1027 dbg("qt2_boxsetuart() failed");
1030 /* now encode the baud rate we actually set, which may be
1031 * different to the request */
1032 baud
= QT2_MAX_BAUD_RATE
/ divisor
;
1033 tty_encode_baud_rate(tty
, baud
, baud
);
1036 /* Now determine flow control */
1037 if (tty
->termios
->c_cflag
& CRTSCTS
) {
1038 dbg("%s(): Enabling HW flow control port %d", __func__
,
1040 /* Enable RTS/CTS flow control */
1041 status
= qt2_boxsethw_flowctl(serial
, UartNumber
, true);
1043 dbg("qt2_boxsethw_flowctl() failed");
1047 /* Disable RTS/CTS flow control */
1048 dbg("%s(): disabling HW flow control port %d", __func__
,
1050 status
= qt2_boxsethw_flowctl(serial
, UartNumber
, false);
1052 dbg("qt2_boxsethw_flowctl failed");
1056 /* if we are implementing XON/XOFF, set the start and stop character
1058 if (I_IXOFF(tty
) || I_IXON(tty
)) {
1059 unsigned char stop_char
= STOP_CHAR(tty
);
1060 unsigned char start_char
= START_CHAR(tty
);
1061 status
= qt2_boxsetsw_flowctl(serial
, UartNumber
, stop_char
,
1064 dbg("qt2_boxsetsw_flowctl (enabled) failed");
1066 /* disable SW flow control */
1067 status
= qt2_boxunsetsw_flowctl(serial
, UartNumber
);
1069 dbg("qt2_boxunsetsw_flowctl (disabling) failed");
1073 static int qt2_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1075 struct usb_serial_port
*port
= tty
->driver_data
;
1076 struct usb_serial
*serial
= port
->serial
;
1078 __u8 mcr_value
; /* Modem Control Register value */
1079 __u8 msr_value
; /* Modem Status Register value */
1080 unsigned int result
= 0;
1082 unsigned int UartNumber
;
1087 dbg("%s(): port %d, tty =0x%p", __func__
, port
->number
, tty
);
1088 UartNumber
= tty
->index
- serial
->minor
;
1089 dbg("UartNumber is %d", UartNumber
);
1091 status
= qt2_box_get_register(port
->serial
, UartNumber
,
1092 QT2_MODEM_CONTROL_REGISTER
, &mcr_value
);
1094 status
= qt2_box_get_register(port
->serial
, UartNumber
,
1095 QT2_MODEM_STATUS_REGISTER
, &msr_value
);
1098 result
= ((mcr_value
& QT2_SERIAL_MCR_DTR
) ? TIOCM_DTR
: 0)
1100 | ((mcr_value
& QT2_SERIAL_MCR_RTS
) ? TIOCM_RTS
: 0)
1102 | ((msr_value
& QT2_SERIAL_MSR_CTS
) ? TIOCM_CTS
: 0)
1104 | ((msr_value
& QT2_SERIAL_MSR_CD
) ? TIOCM_CAR
: 0)
1105 /*Carrier detect set */
1106 | ((msr_value
& QT2_SERIAL_MSR_RI
) ? TIOCM_RI
: 0)
1107 /* Ring indicator set */
1108 | ((msr_value
& QT2_SERIAL_MSR_DSR
) ? TIOCM_DSR
: 0);
1116 static int qt2_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1117 unsigned int set
, unsigned int clear
)
1119 struct usb_serial_port
*port
= tty
->driver_data
;
1120 struct usb_serial
*serial
= port
->serial
;
1121 __u8 mcr_value
; /* Modem Control Register value */
1123 unsigned int UartNumber
;
1128 UartNumber
= tty
->index
- serial
->minor
;
1129 dbg("%s(): port %d, UartNumber %d", __func__
, port
->number
, UartNumber
);
1131 status
= qt2_box_get_register(port
->serial
, UartNumber
,
1132 QT2_MODEM_CONTROL_REGISTER
, &mcr_value
);
1136 /* Turn off RTS, DTR and loopback, then only turn on what was asked
1138 mcr_value
&= ~(QT2_SERIAL_MCR_RTS
| QT2_SERIAL_MCR_DTR
|
1139 QT2_SERIAL_MCR_LOOP
);
1140 if (set
& TIOCM_RTS
)
1141 mcr_value
|= QT2_SERIAL_MCR_RTS
;
1142 if (set
& TIOCM_DTR
)
1143 mcr_value
|= QT2_SERIAL_MCR_DTR
;
1144 if (set
& TIOCM_LOOP
)
1145 mcr_value
|= QT2_SERIAL_MCR_LOOP
;
1147 status
= qt2_box_set_register(port
->serial
, UartNumber
,
1148 QT2_MODEM_CONTROL_REGISTER
, mcr_value
);
1155 /** qt2_break - Turn BREAK on and off on the UARTs
1157 static void qt2_break(struct tty_struct
*tty
, int break_state
)
1159 struct usb_serial_port
*port
= tty
->driver_data
; /* parent port */
1160 struct usb_serial
*serial
= port
->serial
; /* parent device */
1161 struct quatech2_port
*port_extra
; /* extra data for this port */
1163 unsigned int result
;
1165 port_extra
= qt2_get_port_private(port
);
1167 dbg("%s(): port %d: no serial object", __func__
, port
->number
);
1171 if (break_state
== -1)
1175 dbg("%s(): port %d, break_value %d", __func__
, port
->number
,
1178 mutex_lock(&port_extra
->modelock
);
1179 if (!port_extra
->open_count
) {
1180 dbg("%s(): port not open", __func__
);
1184 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1185 QT2_BREAK_CONTROL
, 0x40, break_value
,
1186 port
->number
, NULL
, 0, 300);
1188 mutex_unlock(&port_extra
->modelock
);
1189 dbg("%s(): exit port %d", __func__
, port
->number
);
1193 * qt2_throttle: - stop reading new data from the port
1195 static void qt2_throttle(struct tty_struct
*tty
)
1197 struct usb_serial_port
*port
= tty
->driver_data
;
1198 struct usb_serial
*serial
= port
->serial
;
1199 struct quatech2_port
*port_extra
; /* extra data for this port */
1200 dbg("%s(): port %d", __func__
, port
->number
);
1202 port_extra
= qt2_get_port_private(port
);
1204 dbg("%s(): enter port %d no serial object", __func__
,
1209 mutex_lock(&port_extra
->modelock
); /* lock structure */
1210 if (!port_extra
->open_count
) {
1211 dbg("%s(): port not open", __func__
);
1214 /* Send command to box to stop receiving stuff. This will stop this
1215 * particular UART from filling the endpoint - in the multiport case the
1216 * FPGA UART will handle any flow control implmented, but for the single
1217 * port it's handed differently and we just quit submitting urbs
1219 if (serial
->dev
->descriptor
.idProduct
!= QUATECH_SSU2_100
)
1220 qt2_boxstoprx(serial
, port
->number
, 1);
1222 port
->throttled
= 1;
1224 mutex_unlock(&port_extra
->modelock
);
1225 dbg("%s(): port %d: setting port->throttled", __func__
, port
->number
);
1230 * qt2_unthrottle: - start receiving data through the port again after being
1233 static void qt2_unthrottle(struct tty_struct
*tty
)
1235 struct usb_serial_port
*port
= tty
->driver_data
;
1236 struct usb_serial
*serial
= port
->serial
;
1237 struct quatech2_port
*port_extra
; /* extra data for this port */
1238 struct usb_serial_port
*port0
; /* first port structure on device */
1239 struct quatech2_dev
*dev_extra
; /* extra data for the device */
1242 dbg("%s() enter port %d no serial object!", __func__
,
1246 dbg("%s(): enter port %d", __func__
, port
->number
);
1247 dev_extra
= qt2_get_dev_private(serial
);
1248 port_extra
= qt2_get_port_private(port
);
1249 port0
= serial
->port
[0]; /* get the first port's device structure */
1251 mutex_lock(&port_extra
->modelock
);
1252 if (!port_extra
->open_count
) {
1253 dbg("%s(): port %d not open", __func__
, port
->number
);
1257 if (port
->throttled
!= 0) {
1258 dbg("%s(): port %d: unsetting port->throttled", __func__
,
1260 port
->throttled
= 0;
1261 /* Send command to box to start receiving stuff */
1262 if (serial
->dev
->descriptor
.idProduct
!= QUATECH_SSU2_100
) {
1263 qt2_boxstoprx(serial
, port
->number
, 0);
1264 } else if (dev_extra
->ReadBulkStopped
== true) {
1265 usb_fill_bulk_urb(port0
->read_urb
, serial
->dev
,
1266 usb_rcvbulkpipe(serial
->dev
,
1267 port0
->bulk_in_endpointAddress
),
1268 port0
->bulk_in_buffer
,
1269 port0
->bulk_in_size
,
1270 qt2_read_bulk_callback
,
1275 mutex_unlock(&port_extra
->modelock
);
1276 dbg("%s(): exit port %d", __func__
, port
->number
);
1280 /* internal, private helper functions for the driver */
1282 /* Power up the FPGA in the box to get it working */
1283 static int qt2_boxpoweron(struct usb_serial
*serial
)
1288 Direcion
= USBD_TRANSFER_DIRECTION_OUT
;
1289 pipe
= usb_rcvctrlpipe(serial
->dev
, 0);
1290 result
= usb_control_msg(serial
->dev
, pipe
, QT_SET_GET_DEVICE
,
1291 Direcion
, QU2BOXPWRON
, 0x00, NULL
, 0x00,
1297 * qt2_boxsetQMCR Issue a QT2_GET_SET_QMCR vendor-spcific request on the
1298 * default control pipe. If successful return the number of bytes written,
1299 * otherwise return a negative error number of the problem.
1301 static int qt2_boxsetQMCR(struct usb_serial
*serial
, __u16 Uart_Number
,
1307 PortSettings
= (__u16
)(QMCR_Value
);
1309 dbg("%s(): Port = %d, PortSettings = 0x%x", __func__
,
1310 Uart_Number
, PortSettings
);
1312 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1313 QT2_GET_SET_QMCR
, 0x40, PortSettings
,
1314 (__u16
)Uart_Number
, NULL
, 0, 5000);
1318 static int port_paranoia_check(struct usb_serial_port
*port
,
1319 const char *function
)
1322 dbg("%s - port == NULL", function
);
1325 if (!port
->serial
) {
1326 dbg("%s - port->serial == NULL\n", function
);
1332 static int serial_paranoia_check(struct usb_serial
*serial
,
1333 const char *function
)
1336 dbg("%s - serial == NULL\n", function
);
1340 if (!serial
->type
) {
1341 dbg("%s - serial->type == NULL!", function
);
1348 static inline struct quatech2_port
*qt2_get_port_private(struct usb_serial_port
1351 return (struct quatech2_port
*)usb_get_serial_port_data(port
);
1354 static inline void qt2_set_port_private(struct usb_serial_port
*port
,
1355 struct quatech2_port
*data
)
1357 usb_set_serial_port_data(port
, (void *)data
);
1360 static inline struct quatech2_dev
*qt2_get_dev_private(struct usb_serial
1363 return (struct quatech2_dev
*)usb_get_serial_data(serial
);
1365 static inline void qt2_set_dev_private(struct usb_serial
*serial
,
1366 struct quatech2_dev
*data
)
1368 usb_set_serial_data(serial
, (void *)data
);
1371 static int qt2_openboxchannel(struct usb_serial
*serial
, __u16
1372 Uart_Number
, struct qt2_status_data
*status
)
1378 length
= sizeof(struct qt2_status_data
);
1379 Direcion
= USBD_TRANSFER_DIRECTION_IN
;
1380 pipe
= usb_rcvctrlpipe(serial
->dev
, 0);
1381 result
= usb_control_msg(serial
->dev
, pipe
, QT_OPEN_CLOSE_CHANNEL
,
1382 Direcion
, 0x00, Uart_Number
, status
, length
, 5000);
1385 static int qt2_closeboxchannel(struct usb_serial
*serial
, __u16 Uart_Number
)
1390 direcion
= USBD_TRANSFER_DIRECTION_OUT
;
1391 pipe
= usb_sndctrlpipe(serial
->dev
, 0);
1392 result
= usb_control_msg(serial
->dev
, pipe
, QT_OPEN_CLOSE_CHANNEL
,
1393 direcion
, 0, Uart_Number
, NULL
, 0, 5000);
1397 /* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default
1398 * control pipe. If successful sets baud rate divisor and LCR value
1400 static int qt2_conf_uart(struct usb_serial
*serial
, unsigned short Uart_Number
,
1401 unsigned short divisor
, unsigned char LCR
)
1404 unsigned short UartNumandLCR
;
1406 UartNumandLCR
= (LCR
<< 8) + Uart_Number
;
1408 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1409 QT2_GET_SET_UART
, 0x40, divisor
, UartNumandLCR
,
1414 /** @brief Callback for asynchronous submission of read URBs on bulk in
1417 * Registered in qt2_open_port(), used to deal with incomming data
1420 static void qt2_read_bulk_callback(struct urb
*urb
)
1422 /* Get the device pointer (struct usb_serial) back out of the URB */
1423 struct usb_serial
*serial
= urb
->context
;
1424 /* get the extra struct for the device */
1425 struct quatech2_dev
*dev_extra
= qt2_get_dev_private(serial
);
1426 /* Get first port structure from the device */
1427 struct usb_serial_port
*port0
= serial
->port
[0];
1428 /* Get the currently active port structure from serial struct */
1429 struct usb_serial_port
*active
= dev_extra
->current_port
;
1430 /* get the extra struct for port 0 */
1431 struct quatech2_port
*port0_extra
= qt2_get_port_private(port0
);
1432 /* and for the currently active port */
1433 struct quatech2_port
*active_extra
= qt2_get_port_private(active
);
1434 /* When we finally get to doing some tty stuff, we will need this */
1435 struct tty_struct
*tty_st
;
1436 unsigned int RxCount
; /* the length of the data to process */
1437 unsigned int i
; /* loop counter over the data to process */
1438 int result
; /* return value cache variable */
1439 bool escapeflag
; /* flag set to true if this loop iteration is
1440 * parsing an escape sequence, rather than
1442 dbg("%s(): callback running, active port is %d", __func__
,
1446 /* read didn't go well */
1447 dev_extra
->ReadBulkStopped
= true;
1448 dbg("%s(): nonzero bulk read status received: %d",
1449 __func__
, urb
->status
);
1453 /* inline port_sofrint() here */
1454 if (port_paranoia_check(port0
, __func__
) != 0) {
1455 dbg("%s - port_paranoia_check on port0 failed, exiting\n",
1459 if (port_paranoia_check(active
, __func__
) != 0) {
1460 dbg("%s - port_paranoia_check on current_port "
1461 "failed, exiting", __func__
);
1465 /* This single callback function has to do for all the ports on
1466 * the device. Data being read up the USB can contain certain
1467 * escape sequences which are used to communicate out-of-band
1468 * information from the serial port in-band over the USB.
1469 * These escapes include sending modem and flow control line
1470 * status, and switching the port. The concept of a "Current Port"
1471 * is used, which is where data is going until a port change
1472 * escape seqence is received. This Current Port is kept between
1473 * callbacks so that when this function enters we know which the
1474 * currently active port is and can get to work right away without
1475 * the box having to send repeat escape sequences (anyway, how
1476 * would it know to do so?).
1479 if (active_extra
->close_pending
== true) {
1480 /* We are closing , stop reading */
1481 dbg("%s - (active->close_pending == true", __func__
);
1482 if (dev_extra
->open_ports
<= 0) {
1483 /* If this is the only port left open - stop the
1485 dev_extra
->ReadBulkStopped
= true;
1486 dbg("%s - (ReadBulkStopped == true;", __func__
);
1492 * RxHolding is asserted by throttle, if we assert it, we're not
1493 * receiving any more characters and let the box handle the flow
1496 if ((port0_extra
->RxHolding
== true) &&
1497 (serial
->dev
->descriptor
.idProduct
== QUATECH_SSU2_100
)) {
1498 /* single port device, input is already stopped, so we don't
1499 * need any more input data */
1500 dev_extra
->ReadBulkStopped
= true;
1503 /* finally, we are in a situation where we might consider the data
1504 * that is contained within the URB, and what to do about it.
1505 * This is likely to involved communicating up to the TTY layer, so
1506 * we will need to get hold of the tty for the port we are currently
1509 /* active is a usb_serial_port. It has a member port which is a
1510 * tty_port. From this we get a tty_struct pointer which is what we
1511 * actually wanted, and keep it on tty_st */
1512 tty_st
= tty_port_tty_get(&active
->port
);
1514 dbg("%s - bad tty pointer - exiting", __func__
);
1517 RxCount
= urb
->actual_length
; /* grab length of data handy */
1520 /* skip all this if no data to process */
1521 for (i
= 0; i
< RxCount
; ++i
) {
1522 /* Look ahead code here -works on several bytes at onc*/
1523 if ((i
<= (RxCount
- 3)) && (THISCHAR
== 0x1b)
1524 && (NEXTCHAR
== 0x1b)) {
1525 /* we are in an escape sequence, type
1526 * determined by the 3rd char */
1528 switch (THIRDCHAR
) {
1530 /* Line status change 4th byte must
1532 if (i
> (RxCount
- 4)) {
1533 dbg("Illegal escape sequences "
1534 "in received data");
1537 qt2_process_line_status(active
,
1543 /* Modem status status change 4th byte
1545 if (i
> (RxCount
- 4)) {
1546 dbg("Illegal escape sequences "
1547 "in received data");
1550 qt2_process_modem_status(active
,
1556 /* xmit hold empty 4th byte
1558 if (i
> (RxCount
- 4)) {
1559 dbg("Illegal escape sequences "
1560 "in received data");
1563 qt2_process_xmit_empty(active
,
1564 FOURTHCHAR
, FIFTHCHAR
);
1569 /* Port number change 4th byte
1571 if (i
> (RxCount
- 4)) {
1572 dbg("Illegal escape sequences "
1573 "in received data");
1576 /* Port change. If port open push
1577 * current data up to tty layer */
1578 if (active_extra
->open_count
> 0)
1579 tty_flip_buffer_push(tty_st
);
1581 dbg("Port Change: new port = %d",
1583 qt2_process_port_change(active
,
1587 /* having changed port, the pointers for
1588 * the currently active port are all out
1589 * of date and need updating */
1590 active
= dev_extra
->current_port
;
1592 qt2_get_port_private(active
);
1593 tty_st
= tty_port_tty_get(
1597 /* Recv flush 3rd byte must
1599 if (i
> (RxCount
- 3)) {
1600 dbg("Illegal escape sequences "
1601 "in received data");
1604 qt2_process_rcv_flush(active
);
1609 /* xmit flush 3rd byte must follow */
1610 if (i
> (RxCount
- 3)) {
1611 dbg("Illegal escape sequences "
1612 "in received data");
1615 qt2_process_xmit_flush(active
);
1620 dbg("No status sequence");
1621 qt2_process_rx_char(active
, THISCHAR
);
1622 qt2_process_rx_char(active
, NEXTCHAR
);
1626 qt2_process_rx_char(active
, THISCHAR
);
1630 if (escapeflag
== true)
1632 /* if we did an escape char, we don't need
1633 * to mess around pushing data through the
1634 * tty layer, and can go round again */
1636 if (tty_st
&& urb
->actual_length
) {
1637 tty_buffer_request_room(tty_st
, 1);
1638 tty_insert_flip_string(tty_st
, &(
1640 (urb
->transfer_buffer
)
1644 tty_flip_buffer_push(tty_st
);
1647 /* at this point we have complete dealing with the data for this
1648 * callback. All we have to do now is to start the async read process
1649 * back off again. */
1651 usb_fill_bulk_urb(port0
->read_urb
, serial
->dev
,
1652 usb_rcvbulkpipe(serial
->dev
, port0
->bulk_in_endpointAddress
),
1653 port0
->bulk_in_buffer
, port0
->bulk_in_size
,
1654 qt2_read_bulk_callback
, serial
);
1655 result
= usb_submit_urb(port0
->read_urb
, GFP_ATOMIC
);
1657 dbg("%s(): failed resubmitting read urb, error %d",
1660 dbg("%s() successfully resubmitted read urb", __func__
);
1661 if (tty_st
&& RxCount
) {
1662 /* if some inbound data was processed, then
1663 * we need to push that through the tty layer
1665 tty_flip_buffer_push(tty_st
);
1666 tty_schedule_flip(tty_st
);
1670 /* cribbed from serqt_usb2 driver, but not sure which work needs
1671 * scheduling - port0 or currently active port? */
1672 /* schedule_work(&port->work); */
1673 dbg("%s() completed", __func__
);
1677 /** @brief Callback for asynchronous submission of write URBs on bulk in
1680 * Registered in qt2_write(), used to deal with outgoing data
1683 static void qt2_write_bulk_callback(struct urb
*urb
)
1685 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1686 struct usb_serial
*serial
= port
->serial
;
1687 dbg("%s(): port %d", __func__
, port
->number
);
1689 dbg("%s(): bad serial pointer, exiting", __func__
);
1693 dbg("%s(): nonzero write bulk status received: %d",
1694 __func__
, urb
->status
);
1697 /*port_softint((void *) serial); commented in vendor driver */
1698 schedule_work(&port
->work
);
1699 dbg("%s(): port %d exit", __func__
, port
->number
);
1703 static void qt2_process_line_status(struct usb_serial_port
*port
,
1704 unsigned char LineStatus
)
1706 /* obtain the private structure for the port */
1707 struct quatech2_port
*port_extra
= qt2_get_port_private(port
);
1708 port_extra
->shadowLSR
= LineStatus
& (QT2_SERIAL_LSR_OE
|
1709 QT2_SERIAL_LSR_PE
| QT2_SERIAL_LSR_FE
| QT2_SERIAL_LSR_BI
);
1711 static void qt2_process_modem_status(struct usb_serial_port
*port
,
1712 unsigned char ModemStatus
)
1714 /* obtain the private structure for the port */
1715 struct quatech2_port
*port_extra
= qt2_get_port_private(port
);
1716 port_extra
->shadowMSR
= ModemStatus
;
1717 wake_up_interruptible(&port_extra
->wait
);
1718 /* this wakes up the otherwise indefinitely waiting code for
1719 * the TIOCMIWAIT ioctl, so that it can notice that
1720 * port_extra->shadowMSR has changed and the ioctl needs to return.
1724 static void qt2_process_xmit_empty(struct usb_serial_port
*port
,
1725 unsigned char fourth_char
, unsigned char fifth_char
)
1728 /* obtain the private structure for the port */
1729 struct quatech2_port
*port_extra
= qt2_get_port_private(port
);
1731 byte_count
= (int)(fifth_char
* 16);
1732 byte_count
+= (int)fourth_char
;
1733 /* byte_count indicates how many bytes the device has written out. This
1734 * message appears to occur regularly, and is used in the vendor driver
1735 * to keep track of the fill state of the port transmit buffer */
1736 port_extra
->tx_pending_bytes
-= byte_count
;
1737 /* reduce the stored data queue length by the known number of bytes
1739 dbg("port %d: %d bytes reported sent, %d still pending", port
->number
,
1740 byte_count
, port_extra
->tx_pending_bytes
);
1742 /*port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; ???*/
1745 static void qt2_process_port_change(struct usb_serial_port
*port
,
1746 unsigned char New_Current_Port
)
1748 /* obtain the parent usb serial device structure */
1749 struct usb_serial
*serial
= port
->serial
;
1750 /* obtain the private structure for the device */
1751 struct quatech2_dev
*dev_extra
= qt2_get_dev_private(serial
);
1752 dev_extra
->current_port
= serial
->port
[New_Current_Port
];
1753 /* what should I do with this? commented out in upstream
1755 /*schedule_work(&port->work);*/
1758 static void qt2_process_rcv_flush(struct usb_serial_port
*port
)
1760 /* obtain the private structure for the port */
1761 struct quatech2_port
*port_extra
= qt2_get_port_private(port
);
1762 port_extra
->rcv_flush
= true;
1764 static void qt2_process_xmit_flush(struct usb_serial_port
*port
)
1766 /* obtain the private structure for the port */
1767 struct quatech2_port
*port_extra
= qt2_get_port_private(port
);
1768 port_extra
->xmit_flush
= true;
1771 static void qt2_process_rx_char(struct usb_serial_port
*port
,
1774 /* get the tty_struct for this port */
1775 struct tty_struct
*tty
= tty_port_tty_get(&(port
->port
));
1776 /* get the URB with the data in to push */
1777 struct urb
*urb
= port
->serial
->port
[0]->read_urb
;
1779 if (tty
&& urb
->actual_length
) {
1780 tty_buffer_request_room(tty
, 1);
1781 tty_insert_flip_string(tty
, &data
, 1);
1782 /* should this be commented out here? */
1783 /*tty_flip_buffer_push(tty);*/
1787 /** @brief Retreive the value of a register from the device
1789 * Issues a GET_REGISTER vendor-spcific request over the USB control
1790 * pipe to obtain a value back from a specific register on a specific
1792 * @param serial Serial device handle to access the device through
1793 * @param uart_number Which UART the value is wanted from
1794 * @param register_num Which register to read the value from
1795 * @param pValue Pointer to somewhere to put the retrieved value
1797 static int qt2_box_get_register(struct usb_serial
*serial
,
1798 unsigned char uart_number
, unsigned short register_num
,
1802 result
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
1803 QT2_GET_SET_REGISTER
, 0xC0, register_num
,
1804 uart_number
, (void *)pValue
, sizeof(*pValue
), 300);
1808 /** qt2_box_set_register
1809 * Issue a SET_REGISTER vendor-specific request on the default control pipe
1811 static int qt2_box_set_register(struct usb_serial
*serial
,
1812 unsigned short Uart_Number
, unsigned short Register_Num
,
1813 unsigned short Value
)
1816 unsigned short reg_and_byte
;
1818 reg_and_byte
= Value
;
1819 reg_and_byte
= reg_and_byte
<< 8;
1820 reg_and_byte
= reg_and_byte
+ Register_Num
;
1822 result
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1823 QT2_GET_SET_REGISTER
, 0x40, reg_and_byte
,
1824 Uart_Number
, NULL
, 0, 300);
1828 /** qt2_boxsetuart - Issue a SET_UART vendor-spcific request on the default
1829 * control pipe. If successful sets baud rate divisor and LCR value.
1831 static int qt2_boxsetuart(struct usb_serial
*serial
, unsigned short Uart_Number
,
1832 unsigned short default_divisor
, unsigned char default_LCR
)
1834 unsigned short UartNumandLCR
;
1836 UartNumandLCR
= (default_LCR
<< 8) + Uart_Number
;
1838 return usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1839 QT2_GET_SET_UART
, 0x40, default_divisor
, UartNumandLCR
,
1843 /** qt2_boxsethw_flowctl - Turn hardware (RTS/CTS) flow control on and off for
1846 static int qt2_boxsethw_flowctl(struct usb_serial
*serial
,
1847 unsigned int UartNumber
, bool bSet
)
1851 __u16 MOUT_Value
= 0;
1854 MCR_Value
= QT2_SERIAL_MCR_RTS
;
1855 /* flow control, box will clear RTS line to prevent remote
1856 * device from transmitting more chars */
1858 /* no flow control to remote device */
1861 MOUT_Value
= MCR_Value
<< 8;
1864 MSR_Value
= QT2_SERIAL_MSR_CTS
;
1865 /* flow control on, box will inhibit tx data if CTS line is
1868 /* Box will not inhibit tx data due to CTS line */
1871 MOUT_Value
|= MSR_Value
;
1872 return usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1873 QT2_HW_FLOW_CONTROL_MASK
, 0x40, MOUT_Value
, UartNumber
,
1877 /** qt2_boxsetsw_flowctl - Turn software (XON/XOFF) flow control on for
1878 * a hardware UART, and set the XON and XOFF characters.
1880 static int qt2_boxsetsw_flowctl(struct usb_serial
*serial
, __u16 UartNumber
,
1881 unsigned char stop_char
, unsigned char start_char
)
1885 nSWflowout
= start_char
<< 8;
1886 nSWflowout
= (unsigned short)stop_char
;
1887 return usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1888 QT2_SW_FLOW_CONTROL_MASK
, 0x40, nSWflowout
, UartNumber
,
1892 /** qt2_boxunsetsw_flowctl - Turn software (XON/XOFF) flow control off for
1895 static int qt2_boxunsetsw_flowctl(struct usb_serial
*serial
, __u16 UartNumber
)
1897 return usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1898 QT2_SW_FLOW_CONTROL_DISABLE
, 0x40, 0, UartNumber
, NULL
,
1903 * qt2_boxstoprx - Start and stop reception of data by the FPGA UART in
1904 * response to requests from the tty layer
1905 * @serial: pointer to the usb_serial structure for the parent device
1906 * @uart_number: which UART on the device we are addressing
1907 * @stop: Whether to start or stop data reception. Set to 1 to stop data being
1908 * received, and to 0 to start it being received.
1910 static int qt2_boxstoprx(struct usb_serial
*serial
, unsigned short uart_number
,
1911 unsigned short stop
)
1913 return usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1914 QT2_STOP_RECEIVE
, 0x40, stop
, uart_number
, NULL
, 0, 300);
1919 * last things in file: stuff to register this driver into the generic
1920 * USB serial framework.
1923 static struct usb_serial_driver quatech2_device
= {
1925 .owner
= THIS_MODULE
,
1926 .name
= "quatech_usb2",
1928 .description
= DRIVER_DESC
,
1929 .usb_driver
= &quausb2_usb_driver
,
1930 .id_table
= quausb2_id_table
,
1935 .write_room
= qt2_write_room
,
1936 .chars_in_buffer
= qt2_chars_in_buffer
,
1937 .throttle
= qt2_throttle
,
1938 .unthrottle
= qt2_unthrottle
,
1939 .calc_num_ports
= qt2_calc_num_ports
,
1941 .set_termios
= qt2_set_termios
,
1942 .break_ctl
= qt2_break
,
1943 .tiocmget
= qt2_tiocmget
,
1944 .tiocmset
= qt2_tiocmset
,
1945 .attach
= qt2_attach
,
1946 .release
= qt2_release
,
1947 .read_bulk_callback
= qt2_read_bulk_callback
,
1948 .write_bulk_callback
= qt2_write_bulk_callback
,
1951 static int __init
quausb2_usb_init(void)
1955 dbg("%s\n", __func__
);
1957 /* register with usb-serial */
1958 retval
= usb_serial_register(&quatech2_device
);
1961 goto failed_usb_serial_register
;
1963 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
1966 /* register with usb */
1968 retval
= usb_register(&quausb2_usb_driver
);
1972 /* if we're here, usb_register() failed */
1973 usb_serial_deregister(&quatech2_device
);
1974 failed_usb_serial_register
:
1978 static void __exit
quausb2_usb_exit(void)
1980 usb_deregister(&quausb2_usb_driver
);
1981 usb_serial_deregister(&quatech2_device
);
1984 module_init(quausb2_usb_init
);
1985 module_exit(quausb2_usb_exit
);
1987 MODULE_AUTHOR(DRIVER_AUTHOR
);
1988 MODULE_DESCRIPTION(DRIVER_DESC
);
1989 MODULE_LICENSE("GPL");
1991 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1992 MODULE_PARM_DESC(debug
, "Debug enabled or not");