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_box_flush(struct usb_serial *serial, unsigned char uart_number,
262 unsigned short rcv_or_xmit);
263 static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number,
264 unsigned short default_divisor, unsigned char default_LCR);
265 static int qt2_boxsethw_flowctl(struct usb_serial *serial,
266 unsigned int UartNumber, bool bSet);
267 static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber,
268 unsigned char stop_char, unsigned char start_char);
269 static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber);
270 static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number,
271 unsigned short stop);
273 /* implementation functions, roughly in order of use, are here */
274 static int qt2_calc_num_ports(struct usb_serial *serial)
278 switch (serial->dev->descriptor.idProduct) {
279 case QUATECH_SSU2_100:
283 case QUATECH_DSU2_400:
285 case QUATECH_DSU2_100:
289 case QUATECH_QSU2_400:
291 case QUATECH_QSU2_100:
295 case QUATECH_ESU2_400:
297 case QUATECH_ESU2_100:
307 static int qt2_attach(struct usb_serial *serial)
309 struct usb_serial_port *port;
310 struct quatech2_port *qt2_port; /* port-specific private data pointer */
311 struct quatech2_dev *qt2_dev; /* dev-specific private data pointer */
313 /* stuff for storing endpoint addresses now */
314 struct usb_endpoint_descriptor *endpoint;
315 struct usb_host_interface *iface_desc;
316 struct usb_serial_port *port0; /* first port structure on device */
318 /* check how many endpoints there are on the device, for
320 dbg("%s(): Endpoints: %d bulk in, %d bulk out, %d interrupt in",
321 __func__, serial->num_bulk_in,
322 serial->num_bulk_out, serial->num_interrupt_in);
323 if ((serial->num_bulk_in != 1) || (serial->num_bulk_out != 1)) {
324 dbg("Device has wrong number of bulk endpoints!");
327 iface_desc = serial->interface->cur_altsetting;
329 /* Set up per-device private data, storing extra data alongside
330 * struct usb_serial */
331 qt2_dev = kzalloc(sizeof(*qt2_dev), GFP_KERNEL);
333 dbg("%s: kmalloc for quatech2_dev failed!",
337 qt2_dev->open_ports = 0; /* no ports open */
338 qt2_set_dev_private(serial, qt2_dev); /* store private data */
340 /* Now setup per port private data, which replaces all the things
341 * that quatech added to standard kernel structures in their driver */
342 for (i = 0; i < serial->num_ports; i++) {
343 port = serial->port[i];
344 qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL);
346 dbg("%s: kmalloc for quatech2_port (%d) failed!.",
350 /* initialise stuff in the structure */
351 qt2_port->open_count = 0; /* port is not open */
352 spin_lock_init(&qt2_port->lock);
353 mutex_init(&qt2_port->modelock);
354 qt2_set_port_private(port, qt2_port);
357 /* gain access to port[0]'s structure because we want to store
358 * device-level stuff in it */
359 if (serial_paranoia_check(serial, __func__))
361 port0 = serial->port[0]; /* get the first port's device structure */
363 /* print endpoint addresses so we can check them later
365 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
366 endpoint = &iface_desc->endpoint[i].desc;
367 if ((endpoint->bEndpointAddress & 0x80) &&
368 ((endpoint->bmAttributes & 3) == 0x02)) {
369 /* we found a bulk in endpoint */
370 dbg("found bulk in at %#.2x",
371 endpoint->bEndpointAddress);
374 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
375 ((endpoint->bmAttributes & 3) == 0x02)) {
376 /* we found a bulk out endpoint */
377 dbg("found bulk out at %#.2x",
378 endpoint->bEndpointAddress);
379 qt2_dev->buffer_size = endpoint->wMaxPacketSize;
380 /* max size of URB needs recording for the device */
382 } /* end printing endpoint addresses */
384 /* switch on power to the hardware */
385 if (qt2_boxpoweron(serial) < 0) {
386 dbg("qt2_boxpoweron() failed");
389 /* set all ports to RS232 mode */
390 for (i = 0; i < serial->num_ports; ++i) {
391 if (qt2_boxsetQMCR(serial, i, QU2BOX232) < 0) {
392 dbg("qt2_boxsetQMCR() on port %d failed",
401 for (i = 0; i < serial->num_ports; i++) {
402 port = serial->port[i];
403 qt2_port = qt2_get_port_private(port);
405 qt2_set_port_private(port, NULL);
407 qt2_dev = qt2_get_dev_private(serial);
409 qt2_set_dev_private(serial, NULL);
411 dbg("Exit fail %s\n", __func__);
415 static void qt2_release(struct usb_serial *serial)
417 struct usb_serial_port *port;
418 struct quatech2_port *qt_port;
421 dbg("enterting %s", __func__);
423 for (i = 0; i < serial->num_ports; i++) {
424 port = serial->port[i];
428 qt_port = usb_get_serial_port_data(port);
430 usb_set_serial_port_data(port, NULL);
433 /* This function is called once per serial port on the device, when
434 * that port is opened by a userspace application.
435 * The tty_struct and the usb_serial_port belong to this port,
436 * i.e. there are multiple ones for a multi-port device.
437 * However the usb_serial_port structure has a back-pointer
438 * to the parent usb_serial structure which belongs to the device,
439 * so we can access either the device-wide information or
440 * any other port's information (because there are also forward
441 * pointers) via that pointer.
442 * This is most helpful if the device shares resources (e.g. end
443 * points) between different ports
445 int qt2_open(struct tty_struct *tty, struct usb_serial_port *port)
447 struct usb_serial *serial; /* device structure */
448 struct usb_serial_port *port0; /* first port structure on device */
449 struct quatech2_port *port_extra; /* extra data for this port */
450 struct quatech2_port *port0_extra; /* extra data for first port */
451 struct quatech2_dev *dev_extra; /* extra data for the device */
452 struct qt2_status_data ChannelData;
453 unsigned short default_divisor = QU2BOXSPD9600;
454 unsigned char default_LCR = QT2_SERIAL_8_DATA;
458 if (port_paranoia_check(port, __func__))
461 dbg("%s(): port %d", __func__, port->number);
463 serial = port->serial; /* get the parent device structure */
464 if (serial_paranoia_check(serial, __func__)) {
465 dbg("usb_serial struct failed sanity check");
468 dev_extra = qt2_get_dev_private(serial);
469 /* get the device private data */
470 if (dev_extra == NULL) {
471 dbg("device extra data pointer is null");
474 port0 = serial->port[0]; /* get the first port's device structure */
475 if (port_paranoia_check(port0, __func__)) {
476 dbg("port0 usb_serial_port struct failed sanity check");
480 port_extra = qt2_get_port_private(port);
481 port0_extra = qt2_get_port_private(port0);
482 if (port_extra == NULL || port0_extra == NULL) {
483 dbg("failed to get private data for port or port0");
487 /* FIXME: are these needed? Does it even do anything useful? */
488 /* get the modem and line status values from the UART */
489 status = qt2_openboxchannel(serial, port->number,
492 dbg("qt2_openboxchannel on channel %d failed",
496 port_extra->shadowLSR = ChannelData.line_status &
497 (QT2_SERIAL_LSR_OE | QT2_SERIAL_LSR_PE |
498 QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI);
499 port_extra->shadowMSR = ChannelData.modem_status &
500 (QT2_SERIAL_MSR_CTS | QT2_SERIAL_MSR_DSR |
501 QT2_SERIAL_MSR_RI | QT2_SERIAL_MSR_CD);
503 /* port_extra->fifo_empty_flag = true;*/
504 dbg("qt2_openboxchannel on channel %d completed.",
507 /* Set Baud rate to default and turn off flow control here */
508 status = qt2_conf_uart(serial, port->number, default_divisor,
511 dbg("qt2_conf_uart() failed on channel %d",
515 dbg("qt2_conf_uart() completed on channel %d",
519 * At this point we will need some end points to make further progress.
520 * Handlily, the correct endpoint addresses have been filled out into
521 * the usb_serial_port structure for us by the driver core, so we
522 * already have access to them.
523 * As there is only one bulk in and one bulk out end-point, these are in
524 * port[0]'s structure, and the rest are uninitialised. Handily,
525 * when we do a write to a port, we will use the same endpoint
526 * regardless of the port, with a 5-byte header added on to
527 * tell the box which port it should eventually come out of, so we only
528 * need the one set of endpoints. We will have one URB per port for
529 * writing, so that multiple ports can be writing at once.
530 * Finally we need a bulk in URB to use for background reads from the
531 * device, which will deal with uplink data from the box to host.
533 dbg("port0 bulk in endpoint is %#.2x", port0->bulk_in_endpointAddress);
534 dbg("port0 bulk out endpoint is %#.2x",
535 port0->bulk_out_endpointAddress);
537 /* set up write_urb for bulk out transfers on this port. The USB
538 * serial framework will have allocated a blank URB, buffer etc for
539 * port0 when it put the endpoints there, but not for any of the other
540 * ports on the device because there are no more endpoints. Thus we
541 * have to allocate our own URBs for ports 1-7
543 if (port->write_urb == NULL) {
544 dbg("port->write_urb == NULL, allocating one");
545 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
546 if (!port->write_urb) {
547 err("Allocating write URB failed");
550 /* buffer same size as port0 */
551 port->bulk_out_size = dev_extra->buffer_size;
552 port->bulk_out_buffer = kmalloc(port->bulk_out_size,
554 if (!port->bulk_out_buffer) {
555 err("Couldn't allocate bulk_out_buffer");
559 if (serial->dev == NULL)
560 dbg("serial->dev == NULL");
561 dbg("port->bulk_out_size is %d", port->bulk_out_size);
563 usb_fill_bulk_urb(port->write_urb, serial->dev,
564 usb_sndbulkpipe(serial->dev,
565 port0->bulk_out_endpointAddress),
566 port->bulk_out_buffer,
568 qt2_write_bulk_callback,
570 port_extra->tx_pending_bytes = 0;
572 if (dev_extra->open_ports == 0) {
573 /* this is first port to be opened, so need the read URB
574 * initialised for bulk in transfers (this is shared amongst
575 * all the ports on the device) */
576 usb_fill_bulk_urb(port0->read_urb, serial->dev,
577 usb_rcvbulkpipe(serial->dev,
578 port0->bulk_in_endpointAddress),
579 port0->bulk_in_buffer,
581 qt2_read_bulk_callback, serial);
582 dbg("port0 bulk in URB intialised");
584 /* submit URB, i.e. start reading from device (async) */
585 dev_extra->ReadBulkStopped = false;
586 port_extra->read_urb_busy = true;
587 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
590 "%s(): Error %d submitting bulk in urb",
592 port_extra->read_urb_busy = false;
593 dev_extra->ReadBulkStopped = true;
596 /* When the first port is opened, initialise the value of
597 * current_port in dev_extra to this port, so it is set
598 * to something. Once the box sends data it will send the
599 * relevant escape sequences to get it to the right port anyway
601 dev_extra->current_port = port;
604 /* initialize our wait queues */
605 init_waitqueue_head(&port_extra->wait);
606 /* increment the count of openings of this port by one */
607 port_extra->open_count++;
609 /* remember to store dev_extra, port_extra and port0_extra back again at
611 qt2_set_port_private(port, port_extra);
612 qt2_set_port_private(serial->port[0], port0_extra);
613 qt2_set_dev_private(serial, dev_extra);
615 dev_extra->open_ports++; /* one more port opened */
620 /* called when a port is closed by userspace. It won't be called, however,
621 * until calls to chars_in_buffer() reveal that the port has completed
622 * sending buffered data, and there is nothing else to do. Thus we don't have
623 * to rely on forcing data through in this function. */
624 /* Setting close_pending should keep new data from being written out,
625 * once all the data in the enpoint buffers is moved out we won't get
627 /* BoxStopReceive would keep any more data from coming from a given
628 * port, but isn't called by the vendor driver, although their comments
629 * mention it. Should it be used here to stop the inbound data
632 static void qt2_close(struct usb_serial_port *port)
634 /* time out value for flush loops */
636 struct quatech2_port *port_extra; /* extra data for this port */
637 struct usb_serial *serial; /* device structure */
638 struct quatech2_dev *dev_extra; /* extra data for the device */
639 __u8 lsr_value = 0; /* value of Line Status Register */
640 int status; /* result of last USB comms function */
642 dbg("%s(): port %d", __func__, port->number);
643 serial = port->serial; /* get the parent device structure */
644 dev_extra = qt2_get_dev_private(serial);
645 /* get the device private data */
646 port_extra = qt2_get_port_private(port); /* port private data */
648 /* we don't need to force flush though the hardware, so we skip using
649 * qt2_box_flush() here */
651 /* we can now (and only now) stop reading data */
652 port_extra->close_pending = true;
653 dbg("%s(): port_extra->close_pending = true", __func__);
654 /* although the USB side is now empty, the UART itself may
655 * still be pushing characters out over the line, so we have to
656 * wait testing the actual line status until the lines change
657 * indicating that the data is done transfering. */
658 /* FIXME: slow this polling down so it doesn't run the USB bus flat out
659 * if it actually has to spend any time in this loop (which it normally
660 * doesn't because the buffer is nearly empty) */
661 jift = jiffies + (10 * HZ); /* 10 sec timeout */
663 status = qt2_box_get_register(serial, port->number,
664 QT2_LINE_STATUS_REGISTER, &lsr_value);
666 dbg("%s(): qt2_box_get_register failed", __func__);
669 if ((lsr_value & QT2_LSR_TEMT)) {
670 dbg("UART done sending");
674 } while (jiffies <= jift);
676 status = qt2_closeboxchannel(serial, port->number);
678 dbg("%s(): port %d qt2_box_open_close_channel failed",
679 __func__, port->number);
680 /* to avoid leaking URBs, we should now free the write_urb for this
681 * port and set the pointer to null so that next time the port is opened
682 * a new URB is allocated. This avoids leaking URBs when the device is
684 usb_free_urb(port->write_urb);
685 kfree(port->bulk_out_buffer);
686 port->bulk_out_buffer = NULL;
687 port->bulk_out_size = 0;
689 /* decrement the count of openings of this port by one */
690 port_extra->open_count--;
691 /* one less overall open as well */
692 dev_extra->open_ports--;
693 dbg("%s(): Exit, dev_extra->open_ports = %d", __func__,
694 dev_extra->open_ports);
698 * qt2_write - write bytes from the tty layer out to the USB device.
699 * @buf: The data to be written, size at least count.
700 * @count: The number of bytes requested for transmission.
701 * @return The number of bytes actually accepted for transmission to the device.
703 static int qt2_write(struct tty_struct *tty, struct usb_serial_port *port,
704 const unsigned char *buf, int count)
706 struct usb_serial *serial; /* parent device struct */
707 __u8 header_array[5]; /* header used to direct writes to the correct
708 port on the device */
709 struct quatech2_port *port_extra; /* extra data for this port */
712 serial = port->serial; /* get the parent device of the port */
713 port_extra = qt2_get_port_private(port); /* port extra info */
716 dbg("%s(): port %d, requested to write %d bytes, %d already pending",
717 __func__, port->number, count, port_extra->tx_pending_bytes);
720 dbg("%s(): write request of <= 0 bytes", __func__);
721 return 0; /* no bytes written */
724 /* check if the write urb is already in use, i.e. data already being
725 * sent to this port */
726 if ((port->write_urb->status == -EINPROGRESS)) {
727 /* Fifo hasn't been emptied since last write to this port */
728 dbg("%s(): already writing, port->write_urb->status == "
729 "-EINPROGRESS", __func__);
730 /* schedule_work(&port->work); commented in vendor driver */
732 } else if (port_extra->tx_pending_bytes >= QT2_FIFO_DEPTH) {
733 /* buffer is full (==). > should not occur, but would indicate
734 * that an overflow had occured */
735 dbg("%s(): port transmit buffer is full!", __func__);
736 /* schedule_work(&port->work); commented in vendor driver */
740 /* We must fill the first 5 bytes of anything we sent with a transmit
741 * header which directes the data to the correct port. The maximum
742 * size we can send out in one URB is port->bulk_out_size, which caps
743 * the number of bytes of real data we can send in each write. As the
744 * semantics of write allow us to write less than we were give, we cap
745 * the maximum we will ever write to the device as 5 bytes less than
746 * one URB's worth, by reducing the value of the count argument
748 if (count > port->bulk_out_size - QT2_TX_HEADER_LENGTH) {
749 count = port->bulk_out_size - QT2_TX_HEADER_LENGTH;
750 dbg("%s(): write request bigger than urb, only accepting "
751 "%d bytes", __func__, count);
753 /* we must also ensure that the FIFO at the other end can cope with the
754 * URB we send it, otherwise it will have problems. As above, we can
755 * restrict the write size by just shrinking count.*/
756 if (count > (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes)) {
757 count = QT2_FIFO_DEPTH - port_extra->tx_pending_bytes;
758 dbg("%s(): not enough room in buffer, only accepting %d bytes",
761 /* now build the header for transmission */
762 header_array[0] = 0x1b;
763 header_array[1] = 0x1b;
764 header_array[2] = (__u8)port->number;
765 header_array[3] = (__u8)count;
766 header_array[4] = (__u8)count >> 8;
767 /* copy header into URB */
768 memcpy(port->write_urb->transfer_buffer, header_array,
769 QT2_TX_HEADER_LENGTH);
770 /* and actual data to write */
771 memcpy(port->write_urb->transfer_buffer + 5, buf, count);
773 dbg("%s(): first data byte to send = %#.2x", __func__, *buf);
776 usb_fill_bulk_urb(port->write_urb, serial->dev,
777 usb_sndbulkpipe(serial->dev,
778 port->bulk_out_endpointAddress),
779 port->write_urb->transfer_buffer, count + 5,
780 (qt2_write_bulk_callback), port);
781 /* send the data out the bulk port */
782 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
784 /* error couldn't submit urb */
785 result = 0; /* return 0 as nothing got written */
786 dbg("%s(): failed submitting write urb, error %d",
789 port_extra->tx_pending_bytes += count;
790 result = count; /* return number of bytes written, i.e. count */
791 dbg("%s(): submitted write urb, wrote %d bytes, "
792 "total pending bytes %d",
793 __func__, result, port_extra->tx_pending_bytes);
798 /* This is used by the next layer up to know how much space is available
799 * in the buffer on the device. It is used on a device closure to avoid
800 * calling close() until the buffer is reported to be empty.
801 * The returned value must never go down by more than the number of bytes
802 * written for correct behaviour further up the driver stack, i.e. if I call
803 * it, then write 6 bytes, then call again I should get 6 less, or possibly
804 * only 5 less if one was written in the meantime, etc. I should never get 7
805 * less (or any bigger number) because I only wrote 6 bytes.
807 static int qt2_write_room(struct tty_struct *tty)
809 struct usb_serial_port *port = tty->driver_data;
810 /* parent usb_serial_port pointer */
811 struct quatech2_port *port_extra; /* extra data for this port */
813 port_extra = qt2_get_port_private(port);
815 if (port_extra->close_pending == true) {
816 dbg("%s(): port_extra->close_pending == true", __func__);
819 /* Q: how many bytes would a write() call actually succeed in writing
820 * if it happened now?
821 * A: one QT2_FIFO_DEPTH, less the number of bytes waiting to be sent
822 * out of the port, unless this is more than the size of the
823 * write_urb output buffer less the header, which is the maximum
824 * size write we can do.
826 * Most of the implementation of this is done when writes to the device
827 * are started or terminate. When we send a write to the device, we
828 * reduce the free space count by the size of the dispatched write.
829 * When a "transmit empty" message comes back up the USB read stream,
830 * we decrement the count by the number of bytes reported sent, thus
831 * keeping track of the difference between sent and recieved bytes.
834 room = (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes);
836 if (room > port->bulk_out_size - QT2_TX_HEADER_LENGTH)
837 room = port->bulk_out_size - QT2_TX_HEADER_LENGTH;
838 /* if more than the URB can hold, then cap to that limit */
840 dbg("%s(): port %d: write room is %d", __func__, port->number, room);
844 static int qt2_chars_in_buffer(struct tty_struct *tty)
846 struct usb_serial_port *port = tty->driver_data;
847 /* parent usb_serial_port pointer */
848 struct quatech2_port *port_extra; /* extra data for this port */
849 port_extra = qt2_get_port_private(port);
851 dbg("%s(): port %d: chars_in_buffer = %d", __func__,
852 port->number, port_extra->tx_pending_bytes);
853 return port_extra->tx_pending_bytes;
856 /* called when userspace does an ioctl() on the device. Note that
857 * TIOCMGET and TIOCMSET are filtered off to their own methods before they get
858 * here, so we don't have to handle them.
860 static int qt2_ioctl(struct tty_struct *tty, struct file *file,
861 unsigned int cmd, unsigned long arg)
863 struct usb_serial_port *port = tty->driver_data;
864 struct usb_serial *serial = port->serial;
865 __u8 mcr_value; /* Modem Control Register value */
866 __u8 msr_value; /* Modem Status Register value */
867 unsigned short prev_msr_value; /* Previous value of Modem Status
868 * Register used to implement waiting for a line status change to
870 struct quatech2_port *port_extra; /* extra data for this port */
871 DECLARE_WAITQUEUE(wait, current);
872 /* Declare a wait queue named "wait" */
875 unsigned int UartNumber;
879 UartNumber = tty->index - serial->minor;
880 port_extra = qt2_get_port_private(port);
882 dbg("%s(): port %d, UartNumber %d, tty =0x%p", __func__,
883 port->number, UartNumber, tty);
885 if (cmd == TIOCMBIS || cmd == TIOCMBIC) {
886 if (qt2_box_get_register(port->serial, UartNumber,
887 QT2_MODEM_CONTROL_REGISTER, &mcr_value) < 0)
889 if (copy_from_user(&value, (unsigned int *)arg,
895 if (value & TIOCM_RTS)
896 mcr_value |= QT2_SERIAL_MCR_RTS;
897 if (value & TIOCM_DTR)
898 mcr_value |= QT2_SERIAL_MCR_DTR;
899 if (value & TIOCM_LOOP)
900 mcr_value |= QT2_SERIAL_MCR_LOOP;
903 if (value & TIOCM_RTS)
904 mcr_value &= ~QT2_SERIAL_MCR_RTS;
905 if (value & TIOCM_DTR)
906 mcr_value &= ~QT2_SERIAL_MCR_DTR;
907 if (value & TIOCM_LOOP)
908 mcr_value &= ~QT2_SERIAL_MCR_LOOP;
912 } /* end of local switch on cmd */
913 if (qt2_box_set_register(port->serial, UartNumber,
914 QT2_MODEM_CONTROL_REGISTER, mcr_value) < 0) {
917 port_extra->shadowMCR = mcr_value;
920 } else if (cmd == TIOCMIWAIT) {
921 dbg("%s() port %d, cmd == TIOCMIWAIT enter",
922 __func__, port->number);
923 prev_msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK;
925 add_wait_queue(&port_extra->wait, &wait);
926 set_current_state(TASK_INTERRUPTIBLE);
928 dbg("%s(): port %d, cmd == TIOCMIWAIT here\n",
929 __func__, port->number);
930 remove_wait_queue(&port_extra->wait, &wait);
931 /* see if a signal woke us up */
932 if (signal_pending(current))
934 msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK;
935 if (msr_value == prev_msr_value)
936 return -EIO; /* no change - error */
937 if ((arg & TIOCM_RNG &&
938 ((prev_msr_value & QT2_SERIAL_MSR_RI) ==
939 (msr_value & QT2_SERIAL_MSR_RI))) ||
941 ((prev_msr_value & QT2_SERIAL_MSR_DSR) ==
942 (msr_value & QT2_SERIAL_MSR_DSR))) ||
944 ((prev_msr_value & QT2_SERIAL_MSR_CD) ==
945 (msr_value & QT2_SERIAL_MSR_CD))) ||
947 ((prev_msr_value & QT2_SERIAL_MSR_CTS) ==
948 (msr_value & QT2_SERIAL_MSR_CTS)))) {
951 } /* end inifinite while */
952 /* FIXME: This while loop needs a way to break out if the device
953 * is disconnected while a process is waiting for the MSR to
954 * change, because once it's disconnected, it isn't going to
955 * change state ... */
957 /* any other ioctls we don't know about come here */
958 dbg("%s(): No ioctl for that one. port = %d", __func__,
964 /* Called when the user wishes to change the port settings using the termios
965 * userspace interface */
966 static void qt2_set_termios(struct tty_struct *tty,
967 struct usb_serial_port *port, struct ktermios *old_termios)
969 struct usb_serial *serial; /* parent serial device */
970 int baud, divisor, remainder;
971 unsigned char LCR_change_to = 0;
975 dbg("%s(): port %d", __func__, port->number);
977 serial = port->serial;
979 UartNumber = port->number;
981 if (old_termios && !tty_termios_hw_change(old_termios, tty->termios))
984 switch (tty->termios->c_cflag) {
986 LCR_change_to |= QT2_SERIAL_5_DATA;
989 LCR_change_to |= QT2_SERIAL_6_DATA;
992 LCR_change_to |= QT2_SERIAL_7_DATA;
996 LCR_change_to |= QT2_SERIAL_8_DATA;
1001 if (tty->termios->c_cflag & PARENB) {
1002 if (tty->termios->c_cflag & PARODD)
1003 LCR_change_to |= QT2_SERIAL_ODD_PARITY;
1005 LCR_change_to |= QT2_SERIAL_EVEN_PARITY;
1007 /* Because LCR_change_to is initialised to zero, we don't have to worry
1008 * about the case where PARENB is not set or clearing bits, because by
1009 * default all of them are cleared, turning parity off.
1010 * as we don't support mark/space parity, we should clear the
1011 * mark/space parity bit in c_cflag, so the caller can tell we have
1012 * ignored the request */
1013 tty->termios->c_cflag &= ~CMSPAR;
1015 if (tty->termios->c_cflag & CSTOPB)
1016 LCR_change_to |= QT2_SERIAL_TWO_STOPB;
1018 LCR_change_to |= QT2_SERIAL_ONE_STOPB;
1020 /* Thats the LCR stuff, next we need to work out the divisor as the
1021 * LCR and the divisor are set together */
1022 baud = tty_get_baud_rate(tty);
1024 /* pick a default, any default... */
1027 dbg("%s(): got baud = %d", __func__, baud);
1029 divisor = QT2_MAX_BAUD_RATE / baud;
1030 remainder = QT2_MAX_BAUD_RATE % baud;
1031 /* Round to nearest divisor */
1032 if (((remainder * 2) >= baud) && (baud != 110))
1034 dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = %#.2x",
1035 __func__, divisor, QT2_MAX_BAUD_RATE, LCR_change_to);
1037 status = qt2_boxsetuart(serial, UartNumber, (unsigned short) divisor,
1040 dbg("qt2_boxsetuart() failed");
1043 /* now encode the baud rate we actually set, which may be
1044 * different to the request */
1045 baud = QT2_MAX_BAUD_RATE / divisor;
1046 tty_encode_baud_rate(tty, baud, baud);
1049 /* Now determine flow control */
1050 if (tty->termios->c_cflag & CRTSCTS) {
1051 dbg("%s(): Enabling HW flow control port %d", __func__,
1053 /* Enable RTS/CTS flow control */
1054 status = qt2_boxsethw_flowctl(serial, UartNumber, true);
1056 dbg("qt2_boxsethw_flowctl() failed");
1060 /* Disable RTS/CTS flow control */
1061 dbg("%s(): disabling HW flow control port %d", __func__,
1063 status = qt2_boxsethw_flowctl(serial, UartNumber, false);
1065 dbg("qt2_boxsethw_flowctl failed");
1069 /* if we are implementing XON/XOFF, set the start and stop character
1071 if (I_IXOFF(tty) || I_IXON(tty)) {
1072 unsigned char stop_char = STOP_CHAR(tty);
1073 unsigned char start_char = START_CHAR(tty);
1074 status = qt2_boxsetsw_flowctl(serial, UartNumber, stop_char,
1077 dbg("qt2_boxsetsw_flowctl (enabled) failed");
1079 /* disable SW flow control */
1080 status = qt2_boxunsetsw_flowctl(serial, UartNumber);
1082 dbg("qt2_boxunsetsw_flowctl (disabling) failed");
1086 static int qt2_tiocmget(struct tty_struct *tty, struct file *file)
1088 struct usb_serial_port *port = tty->driver_data;
1089 struct usb_serial *serial = port->serial;
1091 __u8 mcr_value; /* Modem Control Register value */
1092 __u8 msr_value; /* Modem Status Register value */
1093 unsigned int result = 0;
1095 unsigned int UartNumber;
1100 dbg("%s(): port %d, tty =0x%p", __func__, port->number, tty);
1101 UartNumber = tty->index - serial->minor;
1102 dbg("UartNumber is %d", UartNumber);
1104 status = qt2_box_get_register(port->serial, UartNumber,
1105 QT2_MODEM_CONTROL_REGISTER, &mcr_value);
1107 status = qt2_box_get_register(port->serial, UartNumber,
1108 QT2_MODEM_STATUS_REGISTER, &msr_value);
1111 result = ((mcr_value & QT2_SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1113 | ((mcr_value & QT2_SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1115 | ((msr_value & QT2_SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1117 | ((msr_value & QT2_SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1118 /*Carrier detect set */
1119 | ((msr_value & QT2_SERIAL_MSR_RI) ? TIOCM_RI : 0)
1120 /* Ring indicator set */
1121 | ((msr_value & QT2_SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1129 static int qt2_tiocmset(struct tty_struct *tty, struct file *file,
1130 unsigned int set, unsigned int clear)
1132 struct usb_serial_port *port = tty->driver_data;
1133 struct usb_serial *serial = port->serial;
1134 __u8 mcr_value; /* Modem Control Register value */
1136 unsigned int UartNumber;
1141 UartNumber = tty->index - serial->minor;
1142 dbg("%s(): port %d, UartNumber %d", __func__, port->number, UartNumber);
1144 status = qt2_box_get_register(port->serial, UartNumber,
1145 QT2_MODEM_CONTROL_REGISTER, &mcr_value);
1149 /* Turn off RTS, DTR and loopback, then only turn on what was asked
1151 mcr_value &= ~(QT2_SERIAL_MCR_RTS | QT2_SERIAL_MCR_DTR |
1152 QT2_SERIAL_MCR_LOOP);
1153 if (set & TIOCM_RTS)
1154 mcr_value |= QT2_SERIAL_MCR_RTS;
1155 if (set & TIOCM_DTR)
1156 mcr_value |= QT2_SERIAL_MCR_DTR;
1157 if (set & TIOCM_LOOP)
1158 mcr_value |= QT2_SERIAL_MCR_LOOP;
1160 status = qt2_box_set_register(port->serial, UartNumber,
1161 QT2_MODEM_CONTROL_REGISTER, mcr_value);
1168 /** qt2_break - Turn BREAK on and off on the UARTs
1170 static void qt2_break(struct tty_struct *tty, int break_state)
1172 struct usb_serial_port *port = tty->driver_data; /* parent port */
1173 struct usb_serial *serial = port->serial; /* parent device */
1174 struct quatech2_port *port_extra; /* extra data for this port */
1176 unsigned int result;
1178 port_extra = qt2_get_port_private(port);
1180 dbg("%s(): port %d: no serial object", __func__, port->number);
1184 if (break_state == -1)
1188 dbg("%s(): port %d, break_value %d", __func__, port->number,
1191 mutex_lock(&port_extra->modelock);
1192 if (!port_extra->open_count) {
1193 dbg("%s(): port not open", __func__);
1197 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1198 QT2_BREAK_CONTROL, 0x40, break_value,
1199 port->number, NULL, 0, 300);
1201 mutex_unlock(&port_extra->modelock);
1202 dbg("%s(): exit port %d", __func__, port->number);
1206 * qt2_throttle: - stop reading new data from the port
1208 static void qt2_throttle(struct tty_struct *tty)
1210 struct usb_serial_port *port = tty->driver_data;
1211 struct usb_serial *serial = port->serial;
1212 struct quatech2_port *port_extra; /* extra data for this port */
1213 dbg("%s(): port %d", __func__, port->number);
1215 port_extra = qt2_get_port_private(port);
1217 dbg("%s(): enter port %d no serial object", __func__,
1222 mutex_lock(&port_extra->modelock); /* lock structure */
1223 if (!port_extra->open_count) {
1224 dbg("%s(): port not open", __func__);
1227 /* Send command to box to stop receiving stuff. This will stop this
1228 * particular UART from filling the endpoint - in the multiport case the
1229 * FPGA UART will handle any flow control implmented, but for the single
1230 * port it's handed differently and we just quit submitting urbs
1232 if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100)
1233 qt2_boxstoprx(serial, port->number, 1);
1235 port->throttled = 1;
1237 mutex_unlock(&port_extra->modelock);
1238 dbg("%s(): port %d: setting port->throttled", __func__, port->number);
1243 * qt2_unthrottle: - start receiving data through the port again after being
1246 static void qt2_unthrottle(struct tty_struct *tty)
1248 struct usb_serial_port *port = tty->driver_data;
1249 struct usb_serial *serial = port->serial;
1250 struct quatech2_port *port_extra; /* extra data for this port */
1251 struct usb_serial_port *port0; /* first port structure on device */
1252 struct quatech2_dev *dev_extra; /* extra data for the device */
1255 dbg("%s() enter port %d no serial object!", __func__,
1259 dbg("%s(): enter port %d", __func__, port->number);
1260 dev_extra = qt2_get_dev_private(serial);
1261 port_extra = qt2_get_port_private(port);
1262 port0 = serial->port[0]; /* get the first port's device structure */
1264 mutex_lock(&port_extra->modelock);
1265 if (!port_extra->open_count) {
1266 dbg("%s(): port %d not open", __func__, port->number);
1270 if (port->throttled != 0) {
1271 dbg("%s(): port %d: unsetting port->throttled", __func__,
1273 port->throttled = 0;
1274 /* Send command to box to start receiving stuff */
1275 if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) {
1276 qt2_boxstoprx(serial, port->number, 0);
1277 } else if (dev_extra->ReadBulkStopped == true) {
1278 usb_fill_bulk_urb(port0->read_urb, serial->dev,
1279 usb_rcvbulkpipe(serial->dev,
1280 port0->bulk_in_endpointAddress),
1281 port0->bulk_in_buffer,
1282 port0->bulk_in_size,
1283 qt2_read_bulk_callback,
1288 mutex_unlock(&port_extra->modelock);
1289 dbg("%s(): exit port %d", __func__, port->number);
1293 /* internal, private helper functions for the driver */
1295 /* Power up the FPGA in the box to get it working */
1296 static int qt2_boxpoweron(struct usb_serial *serial)
1301 Direcion = USBD_TRANSFER_DIRECTION_OUT;
1302 pipe = usb_rcvctrlpipe(serial->dev, 0);
1303 result = usb_control_msg(serial->dev, pipe, QT_SET_GET_DEVICE,
1304 Direcion, QU2BOXPWRON, 0x00, NULL, 0x00,
1310 * qt2_boxsetQMCR Issue a QT2_GET_SET_QMCR vendor-spcific request on the
1311 * default control pipe. If successful return the number of bytes written,
1312 * otherwise return a negative error number of the problem.
1314 static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number,
1320 PortSettings = (__u16)(QMCR_Value);
1322 dbg("%s(): Port = %d, PortSettings = 0x%x", __func__,
1323 Uart_Number, PortSettings);
1325 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1326 QT2_GET_SET_QMCR, 0x40, PortSettings,
1327 (__u16)Uart_Number, NULL, 0, 5000);
1331 static int port_paranoia_check(struct usb_serial_port *port,
1332 const char *function)
1335 dbg("%s - port == NULL", function);
1338 if (!port->serial) {
1339 dbg("%s - port->serial == NULL\n", function);
1345 static int serial_paranoia_check(struct usb_serial *serial,
1346 const char *function)
1349 dbg("%s - serial == NULL\n", function);
1353 if (!serial->type) {
1354 dbg("%s - serial->type == NULL!", function);
1361 static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port
1364 return (struct quatech2_port *)usb_get_serial_port_data(port);
1367 static inline void qt2_set_port_private(struct usb_serial_port *port,
1368 struct quatech2_port *data)
1370 usb_set_serial_port_data(port, (void *)data);
1373 static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial
1376 return (struct quatech2_dev *)usb_get_serial_data(serial);
1378 static inline void qt2_set_dev_private(struct usb_serial *serial,
1379 struct quatech2_dev *data)
1381 usb_set_serial_data(serial, (void *)data);
1384 static int qt2_openboxchannel(struct usb_serial *serial, __u16
1385 Uart_Number, struct qt2_status_data *status)
1391 length = sizeof(struct qt2_status_data);
1392 Direcion = USBD_TRANSFER_DIRECTION_IN;
1393 pipe = usb_rcvctrlpipe(serial->dev, 0);
1394 result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
1395 Direcion, 0x00, Uart_Number, status, length, 5000);
1398 static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number)
1403 direcion = USBD_TRANSFER_DIRECTION_OUT;
1404 pipe = usb_sndctrlpipe(serial->dev, 0);
1405 result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
1406 direcion, 0, Uart_Number, NULL, 0, 5000);
1410 /* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default
1411 * control pipe. If successful sets baud rate divisor and LCR value
1413 static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number,
1414 unsigned short divisor, unsigned char LCR)
1417 unsigned short UartNumandLCR;
1419 UartNumandLCR = (LCR << 8) + Uart_Number;
1421 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1422 QT2_GET_SET_UART, 0x40, divisor, UartNumandLCR,
1427 /** @brief Callback for asynchronous submission of read URBs on bulk in
1430 * Registered in qt2_open_port(), used to deal with incomming data
1433 static void qt2_read_bulk_callback(struct urb *urb)
1435 /* Get the device pointer (struct usb_serial) back out of the URB */
1436 struct usb_serial *serial = urb->context;
1437 /* get the extra struct for the device */
1438 struct quatech2_dev *dev_extra = qt2_get_dev_private(serial);
1439 /* Get first port structure from the device */
1440 struct usb_serial_port *port0 = serial->port[0];
1441 /* Get the currently active port structure from serial struct */
1442 struct usb_serial_port *active = dev_extra->current_port;
1443 /* get the extra struct for port 0 */
1444 struct quatech2_port *port0_extra = qt2_get_port_private(port0);
1445 /* and for the currently active port */
1446 struct quatech2_port *active_extra = qt2_get_port_private(active);
1447 /* When we finally get to doing some tty stuff, we will need this */
1448 struct tty_struct *tty_st;
1449 unsigned int RxCount; /* the length of the data to process */
1450 unsigned int i; /* loop counter over the data to process */
1451 int result; /* return value cache variable */
1452 bool escapeflag; /* flag set to true if this loop iteration is
1453 * parsing an escape sequence, rather than
1455 dbg("%s(): callback running, active port is %d", __func__,
1459 /* read didn't go well */
1460 dev_extra->ReadBulkStopped = true;
1461 dbg("%s(): nonzero bulk read status received: %d",
1462 __func__, urb->status);
1466 /* inline port_sofrint() here */
1467 if (port_paranoia_check(port0, __func__) != 0) {
1468 dbg("%s - port_paranoia_check on port0 failed, exiting\n",
1472 if (port_paranoia_check(active, __func__) != 0) {
1473 dbg("%s - port_paranoia_check on current_port "
1474 "failed, exiting", __func__);
1478 /* This single callback function has to do for all the ports on
1479 * the device. Data being read up the USB can contain certain
1480 * escape sequences which are used to communicate out-of-band
1481 * information from the serial port in-band over the USB.
1482 * These escapes include sending modem and flow control line
1483 * status, and switching the port. The concept of a "Current Port"
1484 * is used, which is where data is going until a port change
1485 * escape seqence is received. This Current Port is kept between
1486 * callbacks so that when this function enters we know which the
1487 * currently active port is and can get to work right away without
1488 * the box having to send repeat escape sequences (anyway, how
1489 * would it know to do so?).
1492 if (active_extra->close_pending == true) {
1493 /* We are closing , stop reading */
1494 dbg("%s - (active->close_pending == true", __func__);
1495 if (dev_extra->open_ports <= 0) {
1496 /* If this is the only port left open - stop the
1498 dev_extra->ReadBulkStopped = true;
1499 dbg("%s - (ReadBulkStopped == true;", __func__);
1505 * RxHolding is asserted by throttle, if we assert it, we're not
1506 * receiving any more characters and let the box handle the flow
1509 if ((port0_extra->RxHolding == true) &&
1510 (serial->dev->descriptor.idProduct == QUATECH_SSU2_100)) {
1511 /* single port device, input is already stopped, so we don't
1512 * need any more input data */
1513 dev_extra->ReadBulkStopped = true;
1516 /* finally, we are in a situation where we might consider the data
1517 * that is contained within the URB, and what to do about it.
1518 * This is likely to involved communicating up to the TTY layer, so
1519 * we will need to get hold of the tty for the port we are currently
1522 /* active is a usb_serial_port. It has a member port which is a
1523 * tty_port. From this we get a tty_struct pointer which is what we
1524 * actually wanted, and keep it on tty_st */
1525 tty_st = tty_port_tty_get(&active->port);
1527 dbg("%s - bad tty pointer - exiting", __func__);
1530 RxCount = urb->actual_length; /* grab length of data handy */
1533 /* skip all this if no data to process */
1534 for (i = 0; i < RxCount ; ++i) {
1535 /* Look ahead code here -works on several bytes at onc*/
1536 if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b)
1537 && (NEXTCHAR == 0x1b)) {
1538 /* we are in an escape sequence, type
1539 * determined by the 3rd char */
1541 switch (THIRDCHAR) {
1543 /* Line status change 4th byte must
1545 if (i > (RxCount - 4)) {
1546 dbg("Illegal escape sequences "
1547 "in received data");
1550 qt2_process_line_status(active,
1556 /* Modem status status change 4th byte
1558 if (i > (RxCount - 4)) {
1559 dbg("Illegal escape sequences "
1560 "in received data");
1563 qt2_process_modem_status(active,
1569 /* xmit hold empty 4th byte
1571 if (i > (RxCount - 4)) {
1572 dbg("Illegal escape sequences "
1573 "in received data");
1576 qt2_process_xmit_empty(active,
1577 FOURTHCHAR, FIFTHCHAR);
1582 /* Port number change 4th byte
1584 if (i > (RxCount - 4)) {
1585 dbg("Illegal escape sequences "
1586 "in received data");
1589 /* Port change. If port open push
1590 * current data up to tty layer */
1591 if (active_extra->open_count > 0)
1592 tty_flip_buffer_push(tty_st);
1594 dbg("Port Change: new port = %d",
1596 qt2_process_port_change(active,
1600 /* having changed port, the pointers for
1601 * the currently active port are all out
1602 * of date and need updating */
1603 active = dev_extra->current_port;
1605 qt2_get_port_private(active);
1606 tty_st = tty_port_tty_get(
1610 /* Recv flush 3rd byte must
1612 if (i > (RxCount - 3)) {
1613 dbg("Illegal escape sequences "
1614 "in received data");
1617 qt2_process_rcv_flush(active);
1622 /* xmit flush 3rd byte must follow */
1623 if (i > (RxCount - 3)) {
1624 dbg("Illegal escape sequences "
1625 "in received data");
1628 qt2_process_xmit_flush(active);
1633 dbg("No status sequence");
1634 qt2_process_rx_char(active, THISCHAR);
1635 qt2_process_rx_char(active, NEXTCHAR);
1639 qt2_process_rx_char(active, THISCHAR);
1643 if (escapeflag == true)
1645 /* if we did an escape char, we don't need
1646 * to mess around pushing data through the
1647 * tty layer, and can go round again */
1649 if (tty_st && urb->actual_length) {
1650 tty_buffer_request_room(tty_st, 1);
1651 tty_insert_flip_string(tty_st,
1652 &((unsigned char *)(urb->transfer_buffer)
1657 tty_flip_buffer_push(tty_st);
1660 /* at this point we have complete dealing with the data for this
1661 * callback. All we have to do now is to start the async read process
1662 * back off again. */
1664 usb_fill_bulk_urb(port0->read_urb, serial->dev,
1665 usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress),
1666 port0->bulk_in_buffer, port0->bulk_in_size,
1667 qt2_read_bulk_callback, serial);
1668 result = usb_submit_urb(port0->read_urb, GFP_ATOMIC);
1670 dbg("%s(): failed resubmitting read urb, error %d",
1673 dbg("%s() successfully resubmitted read urb", __func__);
1674 if (tty_st && RxCount) {
1675 /* if some inbound data was processed, then
1676 * we need to push that through the tty layer
1678 tty_flip_buffer_push(tty_st);
1679 tty_schedule_flip(tty_st);
1683 /* cribbed from serqt_usb2 driver, but not sure which work needs
1684 * scheduling - port0 or currently active port? */
1685 /* schedule_work(&port->work); */
1686 dbg("%s() completed", __func__);
1690 /** @brief Callback for asynchronous submission of write URBs on bulk in
1693 * Registered in qt2_write(), used to deal with outgoing data
1696 static void qt2_write_bulk_callback(struct urb *urb)
1698 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1699 struct usb_serial *serial = port->serial;
1700 dbg("%s(): port %d", __func__, port->number);
1702 dbg("%s(): bad serial pointer, exiting", __func__);
1706 dbg("%s(): nonzero write bulk status received: %d",
1707 __func__, urb->status);
1710 /* FIXME What is supposed to be going on here?
1711 * does this actually do anything useful, and should it?
1713 /*port_softint((void *) serial); commented in vendor driver */
1714 schedule_work(&port->work);
1715 dbg("%s(): port %d exit", __func__, port->number);
1719 static void qt2_process_line_status(struct usb_serial_port *port,
1720 unsigned char LineStatus)
1722 /* obtain the private structure for the port */
1723 struct quatech2_port *port_extra = qt2_get_port_private(port);
1724 port_extra->shadowLSR = LineStatus & (QT2_SERIAL_LSR_OE |
1725 QT2_SERIAL_LSR_PE | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI);
1727 static void qt2_process_modem_status(struct usb_serial_port *port,
1728 unsigned char ModemStatus)
1730 /* obtain the private structure for the port */
1731 struct quatech2_port *port_extra = qt2_get_port_private(port);
1732 port_extra->shadowMSR = ModemStatus;
1733 wake_up_interruptible(&port_extra->wait);
1734 /* this wakes up the otherwise indefinitely waiting code for
1735 * the TIOCMIWAIT ioctl, so that it can notice that
1736 * port_extra->shadowMSR has changed and the ioctl needs to return.
1740 static void qt2_process_xmit_empty(struct usb_serial_port *port,
1741 unsigned char fourth_char, unsigned char fifth_char)
1744 /* obtain the private structure for the port */
1745 struct quatech2_port *port_extra = qt2_get_port_private(port);
1747 byte_count = (int)(fifth_char * 16);
1748 byte_count += (int)fourth_char;
1749 /* byte_count indicates how many bytes the device has written out. This
1750 * message appears to occur regularly, and is used in the vendor driver
1751 * to keep track of the fill state of the port transmit buffer */
1752 port_extra->tx_pending_bytes -= byte_count;
1753 /* reduce the stored data queue length by the known number of bytes
1755 dbg("port %d: %d bytes reported sent, %d still pending", port->number,
1756 byte_count, port_extra->tx_pending_bytes);
1758 /*port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; ???*/
1761 static void qt2_process_port_change(struct usb_serial_port *port,
1762 unsigned char New_Current_Port)
1764 /* obtain the parent usb serial device structure */
1765 struct usb_serial *serial = port->serial;
1766 /* obtain the private structure for the device */
1767 struct quatech2_dev *dev_extra = qt2_get_dev_private(serial);
1768 dev_extra->current_port = serial->port[New_Current_Port];
1769 /* what should I do with this? commented out in upstream
1771 /*schedule_work(&port->work);*/
1774 static void qt2_process_rcv_flush(struct usb_serial_port *port)
1776 /* obtain the private structure for the port */
1777 struct quatech2_port *port_extra = qt2_get_port_private(port);
1778 port_extra->rcv_flush = true;
1780 static void qt2_process_xmit_flush(struct usb_serial_port *port)
1782 /* obtain the private structure for the port */
1783 struct quatech2_port *port_extra = qt2_get_port_private(port);
1784 port_extra->xmit_flush = true;
1787 static void qt2_process_rx_char(struct usb_serial_port *port,
1790 /* get the tty_struct for this port */
1791 struct tty_struct *tty = tty_port_tty_get(&(port->port));
1792 /* get the URB with the data in to push */
1793 struct urb *urb = port->serial->port[0]->read_urb;
1795 if (tty && urb->actual_length) {
1796 tty_buffer_request_room(tty, 1);
1797 tty_insert_flip_string(tty, &data, 1);
1798 /* should this be commented out here? */
1799 /*tty_flip_buffer_push(tty);*/
1803 /** @brief Retreive the value of a register from the device
1805 * Issues a GET_REGISTER vendor-spcific request over the USB control
1806 * pipe to obtain a value back from a specific register on a specific
1808 * @param serial Serial device handle to access the device through
1809 * @param uart_number Which UART the value is wanted from
1810 * @param register_num Which register to read the value from
1811 * @param pValue Pointer to somewhere to put the retrieved value
1813 static int qt2_box_get_register(struct usb_serial *serial,
1814 unsigned char uart_number, unsigned short register_num,
1818 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1819 QT2_GET_SET_REGISTER, 0xC0, register_num,
1820 uart_number, (void *)pValue, sizeof(*pValue), 300);
1824 /** qt2_box_set_register
1825 * Issue a SET_REGISTER vendor-specific request on the default control pipe
1827 static int qt2_box_set_register(struct usb_serial *serial,
1828 unsigned short Uart_Number, unsigned short Register_Num,
1829 unsigned short Value)
1832 unsigned short reg_and_byte;
1834 reg_and_byte = Value;
1835 reg_and_byte = reg_and_byte << 8;
1836 reg_and_byte = reg_and_byte + Register_Num;
1838 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1839 QT2_GET_SET_REGISTER, 0x40, reg_and_byte,
1840 Uart_Number, NULL, 0, 300);
1845 /** @brief Request the Tx or Rx buffers on the USB side be flushed
1847 * Tx flush: When all the currently buffered data has been sent, send an escape
1848 * sequence back up the data stream to us
1849 * Rx flush: add a flag in the data stream now so we know when it's made it's
1852 static int qt2_box_flush(struct usb_serial *serial, unsigned char uart_number,
1853 unsigned short rcv_or_xmit)
1856 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1857 QT2_FLUSH_DEVICE, 0x40, rcv_or_xmit, uart_number, NULL, 0,
1862 /** qt2_boxsetuart - Issue a SET_UART vendor-spcific request on the default
1863 * control pipe. If successful sets baud rate divisor and LCR value.
1865 static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number,
1866 unsigned short default_divisor, unsigned char default_LCR)
1868 unsigned short UartNumandLCR;
1870 UartNumandLCR = (default_LCR << 8) + Uart_Number;
1872 return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1873 QT2_GET_SET_UART, 0x40, default_divisor, UartNumandLCR,
1876 /** qt2_boxsethw_flowctl - Turn hardware (RTS/CTS) flow control on and off for
1879 static int qt2_boxsethw_flowctl(struct usb_serial *serial,
1880 unsigned int UartNumber, bool bSet)
1884 __u16 MOUT_Value = 0;
1887 MCR_Value = QT2_SERIAL_MCR_RTS;
1888 /* flow control, box will clear RTS line to prevent remote
1889 * device from transmitting more chars */
1891 /* no flow control to remote device */
1894 MOUT_Value = MCR_Value << 8;
1897 MSR_Value = QT2_SERIAL_MSR_CTS;
1898 /* flow control on, box will inhibit tx data if CTS line is
1901 /* Box will not inhibit tx data due to CTS line */
1904 MOUT_Value |= MSR_Value;
1905 return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1906 QT2_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value, UartNumber,
1910 /** qt2_boxsetsw_flowctl - Turn software (XON/XOFF) flow control on for
1911 * a hardware UART, and set the XON and XOFF characters.
1913 static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber,
1914 unsigned char stop_char, unsigned char start_char)
1918 nSWflowout = start_char << 8;
1919 nSWflowout = (unsigned short)stop_char;
1920 return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1921 QT2_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout, UartNumber,
1925 /** qt2_boxunsetsw_flowctl - Turn software (XON/XOFF) flow control off for
1928 static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber)
1930 return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1931 QT2_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber, NULL,
1936 * qt2_boxstoprx - Start and stop reception of data by the FPGA UART in
1937 * response to requests from the tty layer
1938 * @serial: pointer to the usb_serial structure for the parent device
1939 * @uart_number: which UART on the device we are addressing
1940 * @stop: Whether to start or stop data reception. Set to 1 to stop data being
1941 * received, and to 0 to start it being received.
1943 static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number,
1944 unsigned short stop)
1946 return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1947 QT2_STOP_RECEIVE, 0x40, stop, uart_number, NULL, 0, 300);
1952 * last things in file: stuff to register this driver into the generic
1953 * USB serial framework.
1956 static struct usb_serial_driver quatech2_device = {
1958 .owner = THIS_MODULE,
1959 .name = "quatech_usb2",
1961 .description = DRIVER_DESC,
1962 .usb_driver = &quausb2_usb_driver,
1963 .id_table = quausb2_id_table,
1968 .write_room = qt2_write_room,
1969 .chars_in_buffer = qt2_chars_in_buffer,
1970 .throttle = qt2_throttle,
1971 .unthrottle = qt2_unthrottle,
1972 .calc_num_ports = qt2_calc_num_ports,
1974 .set_termios = qt2_set_termios,
1975 .break_ctl = qt2_break,
1976 .tiocmget = qt2_tiocmget,
1977 .tiocmset = qt2_tiocmset,
1978 .attach = qt2_attach,
1979 .release = qt2_release,
1980 .read_bulk_callback = qt2_read_bulk_callback,
1981 .write_bulk_callback = qt2_write_bulk_callback,
1984 static int __init quausb2_usb_init(void)
1988 dbg("%s\n", __func__);
1990 /* register with usb-serial */
1991 retval = usb_serial_register(&quatech2_device);
1994 goto failed_usb_serial_register;
1996 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1999 /* register with usb */
2001 retval = usb_register(&quausb2_usb_driver);
2005 /* if we're here, usb_register() failed */
2006 usb_serial_deregister(&quatech2_device);
2007 failed_usb_serial_register:
2011 static void __exit quausb2_usb_exit(void)
2013 usb_deregister(&quausb2_usb_driver);
2014 usb_serial_deregister(&quatech2_device);
2017 module_init(quausb2_usb_init);
2018 module_exit(quausb2_usb_exit);
2020 MODULE_AUTHOR(DRIVER_AUTHOR);
2021 MODULE_DESCRIPTION(DRIVER_DESC);
2022 MODULE_LICENSE("GPL");
2024 module_param(debug, bool, S_IRUGO | S_IWUSR);
2025 MODULE_PARM_DESC(debug, "Debug enabled or not");