/* * Driver for Quatech Inc USB2.0 to serial adaptors. Largely unrelated to the * serqt_usb driver, based on a re-write of the vendor supplied serqt_usb2 code, * which is unrelated to the serqt_usb2 in the staging kernel */ #include #include #include #include #include #include #include #include #include #include #include static int debug; /* Version Information */ #define DRIVER_VERSION "v2.00" #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc" #define DRIVER_DESC "Quatech USB 2.0 to Serial Driver" /* vendor and device IDs */ #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */ #define QUATECH_SSU2_100 0xC120 /* RS232 single port */ #define QUATECH_DSU2_100 0xC140 /* RS232 dual port */ #define QUATECH_DSU2_400 0xC150 /* RS232/422/485 dual port */ #define QUATECH_QSU2_100 0xC160 /* RS232 four port */ #define QUATECH_QSU2_400 0xC170 /* RS232/422/485 four port */ #define QUATECH_ESU2_100 0xC1A0 /* RS232 eight port */ #define QUATECH_ESU2_400 0xC180 /* RS232/422/485 eight port */ /* magic numbers go here, when we find out which ones are needed */ #define QU2BOXPWRON 0x8000 /* magic number to turn FPGA power on */ #define QU2BOX232 0x40 /* RS232 mode on MEI devices */ #define QU2BOXSPD9600 0x60 /* set speed to 9600 baud */ #define QT2_FIFO_DEPTH 1024 /* size of hardware fifos */ #define QT2_TX_HEADER_LENGTH 5 /* length of the header sent to the box with each write URB */ /* directions for USB transfers */ #define USBD_TRANSFER_DIRECTION_IN 0xc0 #define USBD_TRANSFER_DIRECTION_OUT 0x40 /* special Quatech command IDs. These are pushed down the USB control pipe to get the box on the end to do things */ #define QT_SET_GET_DEVICE 0xc2 #define QT_OPEN_CLOSE_CHANNEL 0xca /*#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc #define QT_SET_ATF 0xcd*/ #define QT2_GET_SET_REGISTER 0xc0 #define QT2_GET_SET_UART 0xc1 #define QT2_HW_FLOW_CONTROL_MASK 0xc5 #define QT2_SW_FLOW_CONTROL_MASK 0xc6 #define QT2_SW_FLOW_CONTROL_DISABLE 0xc7 #define QT2_BREAK_CONTROL 0xc8 #define QT2_STOP_RECEIVE 0xe0 #define QT2_FLUSH_DEVICE 0xc4 #define QT2_GET_SET_QMCR 0xe1 /* sorts of flush we can do on */ #define QT2_FLUSH_RX 0x00 #define QT2_FLUSH_TX 0x01 /* port setting constants, used to set up serial port speeds, flow * control and so on */ #define QT2_SERIAL_MCR_DTR 0x01 #define QT2_SERIAL_MCR_RTS 0x02 #define QT2_SERIAL_MCR_LOOP 0x10 #define QT2_SERIAL_MSR_CTS 0x10 #define QT2_SERIAL_MSR_CD 0x80 #define QT2_SERIAL_MSR_RI 0x40 #define QT2_SERIAL_MSR_DSR 0x20 #define QT2_SERIAL_MSR_MASK 0xf0 #define QT2_SERIAL_8_DATA 0x03 #define QT2_SERIAL_7_DATA 0x02 #define QT2_SERIAL_6_DATA 0x01 #define QT2_SERIAL_5_DATA 0x00 #define QT2_SERIAL_ODD_PARITY 0x08 #define QT2_SERIAL_EVEN_PARITY 0x18 #define QT2_SERIAL_TWO_STOPB 0x04 #define QT2_SERIAL_ONE_STOPB 0x00 #define QT2_MAX_BAUD_RATE 921600 #define QT2_MAX_BAUD_REMAINDER 4608 #define QT2_SERIAL_LSR_OE 0x02 #define QT2_SERIAL_LSR_PE 0x04 #define QT2_SERIAL_LSR_FE 0x08 #define QT2_SERIAL_LSR_BI 0x10 /* value of Line Status Register when UART has completed * emptying data out on the line */ #define QT2_LSR_TEMT 0x40 /* register numbers on each UART, for use with qt2_box_[get|set]_register*/ #define QT2_XMT_HOLD_REGISTER 0x00 #define QT2_XVR_BUFFER_REGISTER 0x00 #define QT2_FIFO_CONTROL_REGISTER 0x02 #define QT2_LINE_CONTROL_REGISTER 0x03 #define QT2_MODEM_CONTROL_REGISTER 0x04 #define QT2_LINE_STATUS_REGISTER 0x05 #define QT2_MODEM_STATUS_REGISTER 0x06 /* handy macros for doing escape sequence parsing on data reads */ #define THISCHAR ((unsigned char *)(urb->transfer_buffer))[i] #define NEXTCHAR ((unsigned char *)(urb->transfer_buffer))[i + 1] #define THIRDCHAR ((unsigned char *)(urb->transfer_buffer))[i + 2] #define FOURTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 3] #define FIFTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 4] static const struct usb_device_id quausb2_id_table[] = { {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_100)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_400)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_100)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_400)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_100)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_400)}, {} /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, quausb2_id_table); /* custom structures we need go here */ static struct usb_driver quausb2_usb_driver = { .name = "quatech-usb2-serial", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = quausb2_id_table, .no_dynamic_id = 1, }; /** * quatech2_port: Structure in which to keep all the messy stuff that this * driver needs alongside the usb_serial_port structure * @read_urb_busy: Flag indicating that port->read_urb is in use * @close_pending: flag indicating that this port is in the process of * being closed (and so no new reads / writes should be started). * @shadowLSR: Last received state of the line status register, holds the * value of the line status flags from the port * @shadowMSR: Last received state of the modem status register, holds * the value of the modem status received from the port * @rcv_flush: Flag indicating that a receive flush has occurred on * the hardware. * @xmit_flush: Flag indicating that a transmit flush has been processed by * the hardware. * @tx_pending_bytes: Number of bytes waiting to be sent. This total * includes the size (excluding header) of URBs that have been submitted but * have not yet been sent to to the device, and bytes that have been sent out * of the port but not yet reported sent by the "xmit_empty" messages (which * indicate the number of bytes sent each time they are received, despite the * misleading name). * - Starts at zero when port is initialised. * - is incremented by the size of the data to be written (no headers) * each time a write urb is dispatched. * - is decremented each time a "transmit empty" message is received * by the driver in the data stream. * @lock: Mutex to lock access to this structure when we need to ensure that * races don't occur to access bits of it. * @open_count: The number of uses of the port currently having * it open, i.e. the reference count. */ struct quatech2_port { int magic; bool read_urb_busy; bool close_pending; __u8 shadowLSR; __u8 shadowMSR; bool rcv_flush; bool xmit_flush; int tx_pending_bytes; struct mutex modelock; int open_count; char active; /* someone has this device open */ unsigned char *xfer_to_tty_buffer; wait_queue_head_t wait; __u8 shadowLCR; /* last LCR value received */ __u8 shadowMCR; /* last MCR value received */ char RxHolding; struct semaphore pend_xmit_sem; /* locks this structure */ spinlock_t lock; }; /** * Structure to hold device-wide internal status information * @param ReadBulkStopped The last bulk read attempt ended in tears * @param open_ports The number of serial ports currently in use on the box * @param current_port Pointer to the serial port structure of the port which * the read stream is currently directed to. Escape sequences in the read * stream will change this around as data arrives from different ports on the * box * @buffer_size: The max size buffer each URB can take, used to set the size of * the buffers allocated for writing to each port on the device (we need to * store this because it is known only to the endpoint, but used each time a * port is opened and a new buffer is allocated. */ struct quatech2_dev { bool ReadBulkStopped; char open_ports; struct usb_serial_port *current_port; int buffer_size; }; /* structure which holds line and modem status flags */ struct qt2_status_data { __u8 line_status; __u8 modem_status; }; /* Function prototypes */ static int qt2_boxpoweron(struct usb_serial *serial); static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number, __u8 QMCR_Value); static int port_paranoia_check(struct usb_serial_port *port, const char *function); static int serial_paranoia_check(struct usb_serial *serial, const char *function); static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port *port); static inline void qt2_set_port_private(struct usb_serial_port *port, struct quatech2_port *data); static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial *serial); static inline void qt2_set_dev_private(struct usb_serial *serial, struct quatech2_dev *data); static int qt2_openboxchannel(struct usb_serial *serial, __u16 Uart_Number, struct qt2_status_data *pDeviceData); static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number); static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, unsigned short divisor, unsigned char LCR); static void qt2_read_bulk_callback(struct urb *urb); static void qt2_write_bulk_callback(struct urb *urb); static void qt2_process_line_status(struct usb_serial_port *port, unsigned char LineStatus); static void qt2_process_modem_status(struct usb_serial_port *port, unsigned char ModemStatus); static void qt2_process_xmit_empty(struct usb_serial_port *port, unsigned char fourth_char, unsigned char fifth_char); static void qt2_process_port_change(struct usb_serial_port *port, unsigned char New_Current_Port); static void qt2_process_rcv_flush(struct usb_serial_port *port); static void qt2_process_xmit_flush(struct usb_serial_port *port); static void qt2_process_rx_char(struct usb_serial_port *port, unsigned char data); static int qt2_box_get_register(struct usb_serial *serial, unsigned char uart_number, unsigned short register_num, __u8 *pValue); static int qt2_box_set_register(struct usb_serial *serial, unsigned short Uart_Number, unsigned short Register_Num, unsigned short Value); static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number, unsigned short default_divisor, unsigned char default_LCR); static int qt2_boxsethw_flowctl(struct usb_serial *serial, unsigned int UartNumber, bool bSet); static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber, unsigned char stop_char, unsigned char start_char); static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber); static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number, unsigned short stop); /* implementation functions, roughly in order of use, are here */ static int qt2_calc_num_ports(struct usb_serial *serial) { int num_ports; int flag_as_400; switch (serial->dev->descriptor.idProduct) { case QUATECH_SSU2_100: num_ports = 1; break; case QUATECH_DSU2_400: flag_as_400 = true; case QUATECH_DSU2_100: num_ports = 2; break; case QUATECH_QSU2_400: flag_as_400 = true; case QUATECH_QSU2_100: num_ports = 4; break; case QUATECH_ESU2_400: flag_as_400 = true; case QUATECH_ESU2_100: num_ports = 8; break; default: num_ports = 1; break; } return num_ports; } static int qt2_attach(struct usb_serial *serial) { struct usb_serial_port *port; struct quatech2_port *qt2_port; /* port-specific private data pointer */ struct quatech2_dev *qt2_dev; /* dev-specific private data pointer */ int i; /* stuff for storing endpoint addresses now */ struct usb_endpoint_descriptor *endpoint; struct usb_host_interface *iface_desc; struct usb_serial_port *port0; /* first port structure on device */ /* check how many endpoints there are on the device, for * sanity's sake */ dbg("%s(): Endpoints: %d bulk in, %d bulk out, %d interrupt in", __func__, serial->num_bulk_in, serial->num_bulk_out, serial->num_interrupt_in); if ((serial->num_bulk_in != 1) || (serial->num_bulk_out != 1)) { dbg("Device has wrong number of bulk endpoints!"); return -ENODEV; } iface_desc = serial->interface->cur_altsetting; /* Set up per-device private data, storing extra data alongside * struct usb_serial */ qt2_dev = kzalloc(sizeof(*qt2_dev), GFP_KERNEL); if (!qt2_dev) { dbg("%s: kmalloc for quatech2_dev failed!", __func__); return -ENOMEM; } qt2_dev->open_ports = 0; /* no ports open */ qt2_set_dev_private(serial, qt2_dev); /* store private data */ /* Now setup per port private data, which replaces all the things * that quatech added to standard kernel structures in their driver */ for (i = 0; i < serial->num_ports; i++) { port = serial->port[i]; qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL); if (!qt2_port) { dbg("%s: kmalloc for quatech2_port (%d) failed!.", __func__, i); return -ENOMEM; } /* initialise stuff in the structure */ qt2_port->open_count = 0; /* port is not open */ spin_lock_init(&qt2_port->lock); mutex_init(&qt2_port->modelock); qt2_set_port_private(port, qt2_port); } /* gain access to port[0]'s structure because we want to store * device-level stuff in it */ if (serial_paranoia_check(serial, __func__)) return -ENODEV; port0 = serial->port[0]; /* get the first port's device structure */ /* print endpoint addresses so we can check them later * by hand */ for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { endpoint = &iface_desc->endpoint[i].desc; if ((endpoint->bEndpointAddress & 0x80) && ((endpoint->bmAttributes & 3) == 0x02)) { /* we found a bulk in endpoint */ dbg("found bulk in at %#.2x", endpoint->bEndpointAddress); } if (((endpoint->bEndpointAddress & 0x80) == 0x00) && ((endpoint->bmAttributes & 3) == 0x02)) { /* we found a bulk out endpoint */ dbg("found bulk out at %#.2x", endpoint->bEndpointAddress); qt2_dev->buffer_size = endpoint->wMaxPacketSize; /* max size of URB needs recording for the device */ } } /* end printing endpoint addresses */ /* switch on power to the hardware */ if (qt2_boxpoweron(serial) < 0) { dbg("qt2_boxpoweron() failed"); goto startup_error; } /* set all ports to RS232 mode */ for (i = 0; i < serial->num_ports; ++i) { if (qt2_boxsetQMCR(serial, i, QU2BOX232) < 0) { dbg("qt2_boxsetQMCR() on port %d failed", i); goto startup_error; } } return 0; startup_error: for (i = 0; i < serial->num_ports; i++) { port = serial->port[i]; qt2_port = qt2_get_port_private(port); kfree(qt2_port); qt2_set_port_private(port, NULL); } qt2_dev = qt2_get_dev_private(serial); kfree(qt2_dev); qt2_set_dev_private(serial, NULL); dbg("Exit fail %s\n", __func__); return -EIO; } static void qt2_release(struct usb_serial *serial) { struct usb_serial_port *port; struct quatech2_port *qt_port; int i; dbg("enterting %s", __func__); for (i = 0; i < serial->num_ports; i++) { port = serial->port[i]; if (!port) continue; qt_port = usb_get_serial_port_data(port); kfree(qt_port); usb_set_serial_port_data(port, NULL); } } /* This function is called once per serial port on the device, when * that port is opened by a userspace application. * The tty_struct and the usb_serial_port belong to this port, * i.e. there are multiple ones for a multi-port device. * However the usb_serial_port structure has a back-pointer * to the parent usb_serial structure which belongs to the device, * so we can access either the device-wide information or * any other port's information (because there are also forward * pointers) via that pointer. * This is most helpful if the device shares resources (e.g. end * points) between different ports */ int qt2_open(struct tty_struct *tty, struct usb_serial_port *port) { struct usb_serial *serial; /* device structure */ struct usb_serial_port *port0; /* first port structure on device */ struct quatech2_port *port_extra; /* extra data for this port */ struct quatech2_port *port0_extra; /* extra data for first port */ struct quatech2_dev *dev_extra; /* extra data for the device */ struct qt2_status_data ChannelData; unsigned short default_divisor = QU2BOXSPD9600; unsigned char default_LCR = QT2_SERIAL_8_DATA; int status; int result; if (port_paranoia_check(port, __func__)) return -ENODEV; dbg("%s(): port %d", __func__, port->number); serial = port->serial; /* get the parent device structure */ if (serial_paranoia_check(serial, __func__)) { dbg("usb_serial struct failed sanity check"); return -ENODEV; } dev_extra = qt2_get_dev_private(serial); /* get the device private data */ if (dev_extra == NULL) { dbg("device extra data pointer is null"); return -ENODEV; } port0 = serial->port[0]; /* get the first port's device structure */ if (port_paranoia_check(port0, __func__)) { dbg("port0 usb_serial_port struct failed sanity check"); return -ENODEV; } port_extra = qt2_get_port_private(port); port0_extra = qt2_get_port_private(port0); if (port_extra == NULL || port0_extra == NULL) { dbg("failed to get private data for port or port0"); return -ENODEV; } /* FIXME: are these needed? Does it even do anything useful? */ /* get the modem and line status values from the UART */ status = qt2_openboxchannel(serial, port->number, &ChannelData); if (status < 0) { dbg("qt2_openboxchannel on channel %d failed", port->number); return status; } port_extra->shadowLSR = ChannelData.line_status & (QT2_SERIAL_LSR_OE | QT2_SERIAL_LSR_PE | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI); port_extra->shadowMSR = ChannelData.modem_status & (QT2_SERIAL_MSR_CTS | QT2_SERIAL_MSR_DSR | QT2_SERIAL_MSR_RI | QT2_SERIAL_MSR_CD); /* port_extra->fifo_empty_flag = true;*/ dbg("qt2_openboxchannel on channel %d completed.", port->number); /* Set Baud rate to default and turn off flow control here */ status = qt2_conf_uart(serial, port->number, default_divisor, default_LCR); if (status < 0) { dbg("qt2_conf_uart() failed on channel %d", port->number); return status; } dbg("qt2_conf_uart() completed on channel %d", port->number); /* * At this point we will need some end points to make further progress. * Handlily, the correct endpoint addresses have been filled out into * the usb_serial_port structure for us by the driver core, so we * already have access to them. * As there is only one bulk in and one bulk out end-point, these are in * port[0]'s structure, and the rest are uninitialised. Handily, * when we do a write to a port, we will use the same endpoint * regardless of the port, with a 5-byte header added on to * tell the box which port it should eventually come out of, so we only * need the one set of endpoints. We will have one URB per port for * writing, so that multiple ports can be writing at once. * Finally we need a bulk in URB to use for background reads from the * device, which will deal with uplink data from the box to host. */ dbg("port0 bulk in endpoint is %#.2x", port0->bulk_in_endpointAddress); dbg("port0 bulk out endpoint is %#.2x", port0->bulk_out_endpointAddress); /* set up write_urb for bulk out transfers on this port. The USB * serial framework will have allocated a blank URB, buffer etc for * port0 when it put the endpoints there, but not for any of the other * ports on the device because there are no more endpoints. Thus we * have to allocate our own URBs for ports 1-7 */ if (port->write_urb == NULL) { dbg("port->write_urb == NULL, allocating one"); port->write_urb = usb_alloc_urb(0, GFP_KERNEL); if (!port->write_urb) { err("Allocating write URB failed"); return -ENOMEM; } /* buffer same size as port0 */ port->bulk_out_size = dev_extra->buffer_size; port->bulk_out_buffer = kmalloc(port->bulk_out_size, GFP_KERNEL); if (!port->bulk_out_buffer) { err("Couldn't allocate bulk_out_buffer"); return -ENOMEM; } } if (serial->dev == NULL) dbg("serial->dev == NULL"); dbg("port->bulk_out_size is %d", port->bulk_out_size); usb_fill_bulk_urb(port->write_urb, serial->dev, usb_sndbulkpipe(serial->dev, port0->bulk_out_endpointAddress), port->bulk_out_buffer, port->bulk_out_size, qt2_write_bulk_callback, port); port_extra->tx_pending_bytes = 0; if (dev_extra->open_ports == 0) { /* this is first port to be opened, so need the read URB * initialised for bulk in transfers (this is shared amongst * all the ports on the device) */ usb_fill_bulk_urb(port0->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress), port0->bulk_in_buffer, port0->bulk_in_size, qt2_read_bulk_callback, serial); dbg("port0 bulk in URB initialised"); /* submit URB, i.e. start reading from device (async) */ dev_extra->ReadBulkStopped = false; port_extra->read_urb_busy = true; result = usb_submit_urb(port->read_urb, GFP_KERNEL); if (result) { dev_err(&port->dev, "%s(): Error %d submitting bulk in urb", __func__, result); port_extra->read_urb_busy = false; dev_extra->ReadBulkStopped = true; } /* When the first port is opened, initialise the value of * current_port in dev_extra to this port, so it is set * to something. Once the box sends data it will send the * relevant escape sequences to get it to the right port anyway */ dev_extra->current_port = port; } /* initialize our wait queues */ init_waitqueue_head(&port_extra->wait); /* increment the count of openings of this port by one */ port_extra->open_count++; /* remember to store dev_extra, port_extra and port0_extra back again at * end !*/ qt2_set_port_private(port, port_extra); qt2_set_port_private(serial->port[0], port0_extra); qt2_set_dev_private(serial, dev_extra); dev_extra->open_ports++; /* one more port opened */ return 0; } /* called when a port is closed by userspace. It won't be called, however, * until calls to chars_in_buffer() reveal that the port has completed * sending buffered data, and there is nothing else to do. Thus we don't have * to rely on forcing data through in this function. */ /* Setting close_pending should keep new data from being written out, * once all the data in the enpoint buffers is moved out we won't get * any more. */ /* BoxStopReceive would keep any more data from coming from a given * port, but isn't called by the vendor driver, although their comments * mention it. Should it be used here to stop the inbound data * flow? */ static void qt2_close(struct usb_serial_port *port) { /* time out value for flush loops */ unsigned long jift; struct quatech2_port *port_extra; /* extra data for this port */ struct usb_serial *serial; /* device structure */ struct quatech2_dev *dev_extra; /* extra data for the device */ __u8 lsr_value = 0; /* value of Line Status Register */ int status; /* result of last USB comms function */ dbg("%s(): port %d", __func__, port->number); serial = port->serial; /* get the parent device structure */ dev_extra = qt2_get_dev_private(serial); /* get the device private data */ port_extra = qt2_get_port_private(port); /* port private data */ /* we can now (and only now) stop reading data */ port_extra->close_pending = true; dbg("%s(): port_extra->close_pending = true", __func__); /* although the USB side is now empty, the UART itself may * still be pushing characters out over the line, so we have to * wait testing the actual line status until the lines change * indicating that the data is done transferring. */ /* FIXME: slow this polling down so it doesn't run the USB bus flat out * if it actually has to spend any time in this loop (which it normally * doesn't because the buffer is nearly empty) */ jift = jiffies + (10 * HZ); /* 10 sec timeout */ do { status = qt2_box_get_register(serial, port->number, QT2_LINE_STATUS_REGISTER, &lsr_value); if (status < 0) { dbg("%s(): qt2_box_get_register failed", __func__); break; } if ((lsr_value & QT2_LSR_TEMT)) { dbg("UART done sending"); break; } schedule(); } while (jiffies <= jift); status = qt2_closeboxchannel(serial, port->number); if (status < 0) dbg("%s(): port %d qt2_box_open_close_channel failed", __func__, port->number); /* to avoid leaking URBs, we should now free the write_urb for this * port and set the pointer to null so that next time the port is opened * a new URB is allocated. This avoids leaking URBs when the device is * removed */ usb_free_urb(port->write_urb); kfree(port->bulk_out_buffer); port->bulk_out_buffer = NULL; port->bulk_out_size = 0; /* decrement the count of openings of this port by one */ port_extra->open_count--; /* one less overall open as well */ dev_extra->open_ports--; dbg("%s(): Exit, dev_extra->open_ports = %d", __func__, dev_extra->open_ports); } /** * qt2_write - write bytes from the tty layer out to the USB device. * @buf: The data to be written, size at least count. * @count: The number of bytes requested for transmission. * @return The number of bytes actually accepted for transmission to the device. */ static int qt2_write(struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count) { struct usb_serial *serial; /* parent device struct */ __u8 header_array[5]; /* header used to direct writes to the correct port on the device */ struct quatech2_port *port_extra; /* extra data for this port */ int result; serial = port->serial; /* get the parent device of the port */ port_extra = qt2_get_port_private(port); /* port extra info */ if (serial == NULL) return -ENODEV; dbg("%s(): port %d, requested to write %d bytes, %d already pending", __func__, port->number, count, port_extra->tx_pending_bytes); if (count <= 0) { dbg("%s(): write request of <= 0 bytes", __func__); return 0; /* no bytes written */ } /* check if the write urb is already in use, i.e. data already being * sent to this port */ if ((port->write_urb->status == -EINPROGRESS)) { /* Fifo hasn't been emptied since last write to this port */ dbg("%s(): already writing, port->write_urb->status == " "-EINPROGRESS", __func__); /* schedule_work(&port->work); commented in vendor driver */ return 0; } else if (port_extra->tx_pending_bytes >= QT2_FIFO_DEPTH) { /* buffer is full (==). > should not occur, but would indicate * that an overflow had occurred */ dbg("%s(): port transmit buffer is full!", __func__); /* schedule_work(&port->work); commented in vendor driver */ return 0; } /* We must fill the first 5 bytes of anything we sent with a transmit * header which directes the data to the correct port. The maximum * size we can send out in one URB is port->bulk_out_size, which caps * the number of bytes of real data we can send in each write. As the * semantics of write allow us to write less than we were give, we cap * the maximum we will ever write to the device as 5 bytes less than * one URB's worth, by reducing the value of the count argument * appropriately*/ if (count > port->bulk_out_size - QT2_TX_HEADER_LENGTH) { count = port->bulk_out_size - QT2_TX_HEADER_LENGTH; dbg("%s(): write request bigger than urb, only accepting " "%d bytes", __func__, count); } /* we must also ensure that the FIFO at the other end can cope with the * URB we send it, otherwise it will have problems. As above, we can * restrict the write size by just shrinking count.*/ if (count > (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes)) { count = QT2_FIFO_DEPTH - port_extra->tx_pending_bytes; dbg("%s(): not enough room in buffer, only accepting %d bytes", __func__, count); } /* now build the header for transmission */ header_array[0] = 0x1b; header_array[1] = 0x1b; header_array[2] = (__u8)port->number; header_array[3] = (__u8)count; header_array[4] = (__u8)count >> 8; /* copy header into URB */ memcpy(port->write_urb->transfer_buffer, header_array, QT2_TX_HEADER_LENGTH); /* and actual data to write */ memcpy(port->write_urb->transfer_buffer + 5, buf, count); dbg("%s(): first data byte to send = %#.2x", __func__, *buf); /* set up our urb */ usb_fill_bulk_urb(port->write_urb, serial->dev, usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress), port->write_urb->transfer_buffer, count + 5, (qt2_write_bulk_callback), port); /* send the data out the bulk port */ result = usb_submit_urb(port->write_urb, GFP_ATOMIC); if (result) { /* error couldn't submit urb */ result = 0; /* return 0 as nothing got written */ dbg("%s(): failed submitting write urb, error %d", __func__, result); } else { port_extra->tx_pending_bytes += count; result = count; /* return number of bytes written, i.e. count */ dbg("%s(): submitted write urb, wrote %d bytes, " "total pending bytes %d", __func__, result, port_extra->tx_pending_bytes); } return result; } /* This is used by the next layer up to know how much space is available * in the buffer on the device. It is used on a device closure to avoid * calling close() until the buffer is reported to be empty. * The returned value must never go down by more than the number of bytes * written for correct behaviour further up the driver stack, i.e. if I call * it, then write 6 bytes, then call again I should get 6 less, or possibly * only 5 less if one was written in the meantime, etc. I should never get 7 * less (or any bigger number) because I only wrote 6 bytes. */ static int qt2_write_room(struct tty_struct *tty) { struct usb_serial_port *port = tty->driver_data; /* parent usb_serial_port pointer */ struct quatech2_port *port_extra; /* extra data for this port */ int room = 0; port_extra = qt2_get_port_private(port); if (port_extra->close_pending == true) { dbg("%s(): port_extra->close_pending == true", __func__); return -ENODEV; } /* Q: how many bytes would a write() call actually succeed in writing * if it happened now? * A: one QT2_FIFO_DEPTH, less the number of bytes waiting to be sent * out of the port, unless this is more than the size of the * write_urb output buffer less the header, which is the maximum * size write we can do. * Most of the implementation of this is done when writes to the device * are started or terminate. When we send a write to the device, we * reduce the free space count by the size of the dispatched write. * When a "transmit empty" message comes back up the USB read stream, * we decrement the count by the number of bytes reported sent, thus * keeping track of the difference between sent and received bytes. */ room = (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes); /* space in FIFO */ if (room > port->bulk_out_size - QT2_TX_HEADER_LENGTH) room = port->bulk_out_size - QT2_TX_HEADER_LENGTH; /* if more than the URB can hold, then cap to that limit */ dbg("%s(): port %d: write room is %d", __func__, port->number, room); return room; } static int qt2_chars_in_buffer(struct tty_struct *tty) { struct usb_serial_port *port = tty->driver_data; /* parent usb_serial_port pointer */ struct quatech2_port *port_extra; /* extra data for this port */ port_extra = qt2_get_port_private(port); dbg("%s(): port %d: chars_in_buffer = %d", __func__, port->number, port_extra->tx_pending_bytes); return port_extra->tx_pending_bytes; } /* called when userspace does an ioctl() on the device. Note that * TIOCMGET and TIOCMSET are filtered off to their own methods before they get * here, so we don't have to handle them. */ static int qt2_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg) { struct usb_serial_port *port = tty->driver_data; struct usb_serial *serial = port->serial; __u8 mcr_value; /* Modem Control Register value */ __u8 msr_value; /* Modem Status Register value */ unsigned short prev_msr_value; /* Previous value of Modem Status * Register used to implement waiting for a line status change to * occur */ struct quatech2_port *port_extra; /* extra data for this port */ DECLARE_WAITQUEUE(wait, current); /* Declare a wait queue named "wait" */ unsigned int value; unsigned int UartNumber; if (serial == NULL) return -ENODEV; UartNumber = tty->index - serial->minor; port_extra = qt2_get_port_private(port); dbg("%s(): port %d, UartNumber %d, tty =0x%p", __func__, port->number, UartNumber, tty); if (cmd == TIOCMBIS || cmd == TIOCMBIC) { if (qt2_box_get_register(port->serial, UartNumber, QT2_MODEM_CONTROL_REGISTER, &mcr_value) < 0) return -ESPIPE; if (copy_from_user(&value, (unsigned int *)arg, sizeof(value))) return -EFAULT; switch (cmd) { case TIOCMBIS: if (value & TIOCM_RTS) mcr_value |= QT2_SERIAL_MCR_RTS; if (value & TIOCM_DTR) mcr_value |= QT2_SERIAL_MCR_DTR; if (value & TIOCM_LOOP) mcr_value |= QT2_SERIAL_MCR_LOOP; break; case TIOCMBIC: if (value & TIOCM_RTS) mcr_value &= ~QT2_SERIAL_MCR_RTS; if (value & TIOCM_DTR) mcr_value &= ~QT2_SERIAL_MCR_DTR; if (value & TIOCM_LOOP) mcr_value &= ~QT2_SERIAL_MCR_LOOP; break; default: break; } /* end of local switch on cmd */ if (qt2_box_set_register(port->serial, UartNumber, QT2_MODEM_CONTROL_REGISTER, mcr_value) < 0) { return -ESPIPE; } else { port_extra->shadowMCR = mcr_value; return 0; } } else if (cmd == TIOCMIWAIT) { dbg("%s() port %d, cmd == TIOCMIWAIT enter", __func__, port->number); prev_msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK; barrier(); __set_current_state(TASK_INTERRUPTIBLE); while (1) { add_wait_queue(&port_extra->wait, &wait); schedule(); dbg("%s(): port %d, cmd == TIOCMIWAIT here\n", __func__, port->number); remove_wait_queue(&port_extra->wait, &wait); /* see if a signal woke us up */ if (signal_pending(current)) return -ERESTARTSYS; set_current_state(TASK_INTERRUPTIBLE); msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK; if (msr_value == prev_msr_value) { __set_current_state(TASK_RUNNING); return -EIO; /* no change - error */ } if ((arg & TIOCM_RNG && ((prev_msr_value & QT2_SERIAL_MSR_RI) == (msr_value & QT2_SERIAL_MSR_RI))) || (arg & TIOCM_DSR && ((prev_msr_value & QT2_SERIAL_MSR_DSR) == (msr_value & QT2_SERIAL_MSR_DSR))) || (arg & TIOCM_CD && ((prev_msr_value & QT2_SERIAL_MSR_CD) == (msr_value & QT2_SERIAL_MSR_CD))) || (arg & TIOCM_CTS && ((prev_msr_value & QT2_SERIAL_MSR_CTS) == (msr_value & QT2_SERIAL_MSR_CTS)))) { __set_current_state(TASK_RUNNING); return 0; } } /* end inifinite while */ /* FIXME: This while loop needs a way to break out if the device * is disconnected while a process is waiting for the MSR to * change, because once it's disconnected, it isn't going to * change state ... */ } else { /* any other ioctls we don't know about come here */ dbg("%s(): No ioctl for that one. port = %d", __func__, port->number); return -ENOIOCTLCMD; } } /* Called when the user wishes to change the port settings using the termios * userspace interface */ static void qt2_set_termios(struct tty_struct *tty, struct usb_serial_port *port, struct ktermios *old_termios) { struct usb_serial *serial; /* parent serial device */ int baud, divisor, remainder; unsigned char LCR_change_to = 0; int status; __u16 UartNumber; dbg("%s(): port %d", __func__, port->number); serial = port->serial; UartNumber = port->number; if (old_termios && !tty_termios_hw_change(old_termios, tty->termios)) return; switch (tty->termios->c_cflag) { case CS5: LCR_change_to |= QT2_SERIAL_5_DATA; break; case CS6: LCR_change_to |= QT2_SERIAL_6_DATA; break; case CS7: LCR_change_to |= QT2_SERIAL_7_DATA; break; default: case CS8: LCR_change_to |= QT2_SERIAL_8_DATA; break; } /* Parity stuff */ if (tty->termios->c_cflag & PARENB) { if (tty->termios->c_cflag & PARODD) LCR_change_to |= QT2_SERIAL_ODD_PARITY; else LCR_change_to |= QT2_SERIAL_EVEN_PARITY; } /* Because LCR_change_to is initialised to zero, we don't have to worry * about the case where PARENB is not set or clearing bits, because by * default all of them are cleared, turning parity off. * as we don't support mark/space parity, we should clear the * mark/space parity bit in c_cflag, so the caller can tell we have * ignored the request */ tty->termios->c_cflag &= ~CMSPAR; if (tty->termios->c_cflag & CSTOPB) LCR_change_to |= QT2_SERIAL_TWO_STOPB; else LCR_change_to |= QT2_SERIAL_ONE_STOPB; /* Thats the LCR stuff, next we need to work out the divisor as the * LCR and the divisor are set together */ baud = tty_get_baud_rate(tty); if (!baud) { /* pick a default, any default... */ baud = 9600; } dbg("%s(): got baud = %d", __func__, baud); divisor = QT2_MAX_BAUD_RATE / baud; remainder = QT2_MAX_BAUD_RATE % baud; /* Round to nearest divisor */ if (((remainder * 2) >= baud) && (baud != 110)) divisor++; dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = %#.2x", __func__, divisor, QT2_MAX_BAUD_RATE, LCR_change_to); status = qt2_boxsetuart(serial, UartNumber, (unsigned short) divisor, LCR_change_to); if (status < 0) { dbg("qt2_boxsetuart() failed"); return; } else { /* now encode the baud rate we actually set, which may be * different to the request */ baud = QT2_MAX_BAUD_RATE / divisor; tty_encode_baud_rate(tty, baud, baud); } /* Now determine flow control */ if (tty->termios->c_cflag & CRTSCTS) { dbg("%s(): Enabling HW flow control port %d", __func__, port->number); /* Enable RTS/CTS flow control */ status = qt2_boxsethw_flowctl(serial, UartNumber, true); if (status < 0) { dbg("qt2_boxsethw_flowctl() failed"); return; } } else { /* Disable RTS/CTS flow control */ dbg("%s(): disabling HW flow control port %d", __func__, port->number); status = qt2_boxsethw_flowctl(serial, UartNumber, false); if (status < 0) { dbg("qt2_boxsethw_flowctl failed"); return; } } /* if we are implementing XON/XOFF, set the start and stop character * in the device */ if (I_IXOFF(tty) || I_IXON(tty)) { unsigned char stop_char = STOP_CHAR(tty); unsigned char start_char = START_CHAR(tty); status = qt2_boxsetsw_flowctl(serial, UartNumber, stop_char, start_char); if (status < 0) dbg("qt2_boxsetsw_flowctl (enabled) failed"); } else { /* disable SW flow control */ status = qt2_boxunsetsw_flowctl(serial, UartNumber); if (status < 0) dbg("qt2_boxunsetsw_flowctl (disabling) failed"); } } static int qt2_tiocmget(struct tty_struct *tty) { struct usb_serial_port *port = tty->driver_data; struct usb_serial *serial = port->serial; __u8 mcr_value; /* Modem Control Register value */ __u8 msr_value; /* Modem Status Register value */ unsigned int result = 0; int status; unsigned int UartNumber; if (serial == NULL) return -ENODEV; dbg("%s(): port %d, tty =0x%p", __func__, port->number, tty); UartNumber = tty->index - serial->minor; dbg("UartNumber is %d", UartNumber); status = qt2_box_get_register(port->serial, UartNumber, QT2_MODEM_CONTROL_REGISTER, &mcr_value); if (status >= 0) { status = qt2_box_get_register(port->serial, UartNumber, QT2_MODEM_STATUS_REGISTER, &msr_value); } if (status >= 0) { result = ((mcr_value & QT2_SERIAL_MCR_DTR) ? TIOCM_DTR : 0) /*DTR set */ | ((mcr_value & QT2_SERIAL_MCR_RTS) ? TIOCM_RTS : 0) /*RTS set */ | ((msr_value & QT2_SERIAL_MSR_CTS) ? TIOCM_CTS : 0) /* CTS set */ | ((msr_value & QT2_SERIAL_MSR_CD) ? TIOCM_CAR : 0) /*Carrier detect set */ | ((msr_value & QT2_SERIAL_MSR_RI) ? TIOCM_RI : 0) /* Ring indicator set */ | ((msr_value & QT2_SERIAL_MSR_DSR) ? TIOCM_DSR : 0); /* DSR set */ return result; } else { return -ESPIPE; } } static int qt2_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear) { struct usb_serial_port *port = tty->driver_data; struct usb_serial *serial = port->serial; __u8 mcr_value; /* Modem Control Register value */ int status; unsigned int UartNumber; if (serial == NULL) return -ENODEV; UartNumber = tty->index - serial->minor; dbg("%s(): port %d, UartNumber %d", __func__, port->number, UartNumber); status = qt2_box_get_register(port->serial, UartNumber, QT2_MODEM_CONTROL_REGISTER, &mcr_value); if (status < 0) return -ESPIPE; /* Turn off RTS, DTR and loopback, then only turn on what was asked * for */ mcr_value &= ~(QT2_SERIAL_MCR_RTS | QT2_SERIAL_MCR_DTR | QT2_SERIAL_MCR_LOOP); if (set & TIOCM_RTS) mcr_value |= QT2_SERIAL_MCR_RTS; if (set & TIOCM_DTR) mcr_value |= QT2_SERIAL_MCR_DTR; if (set & TIOCM_LOOP) mcr_value |= QT2_SERIAL_MCR_LOOP; status = qt2_box_set_register(port->serial, UartNumber, QT2_MODEM_CONTROL_REGISTER, mcr_value); if (status < 0) return -ESPIPE; else return 0; } /** qt2_break - Turn BREAK on and off on the UARTs */ static void qt2_break(struct tty_struct *tty, int break_state) { struct usb_serial_port *port = tty->driver_data; /* parent port */ struct usb_serial *serial = port->serial; /* parent device */ struct quatech2_port *port_extra; /* extra data for this port */ __u16 break_value; unsigned int result; port_extra = qt2_get_port_private(port); if (!serial) { dbg("%s(): port %d: no serial object", __func__, port->number); return; } if (break_state == -1) break_value = 1; else break_value = 0; dbg("%s(): port %d, break_value %d", __func__, port->number, break_value); mutex_lock(&port_extra->modelock); if (!port_extra->open_count) { dbg("%s(): port not open", __func__); goto exit; } result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_BREAK_CONTROL, 0x40, break_value, port->number, NULL, 0, 300); exit: mutex_unlock(&port_extra->modelock); dbg("%s(): exit port %d", __func__, port->number); } /** * qt2_throttle: - stop reading new data from the port */ static void qt2_throttle(struct tty_struct *tty) { struct usb_serial_port *port = tty->driver_data; struct usb_serial *serial = port->serial; struct quatech2_port *port_extra; /* extra data for this port */ dbg("%s(): port %d", __func__, port->number); port_extra = qt2_get_port_private(port); if (!serial) { dbg("%s(): enter port %d no serial object", __func__, port->number); return; } mutex_lock(&port_extra->modelock); /* lock structure */ if (!port_extra->open_count) { dbg("%s(): port not open", __func__); goto exit; } /* Send command to box to stop receiving stuff. This will stop this * particular UART from filling the endpoint - in the multiport case the * FPGA UART will handle any flow control implemented, but for the single * port it's handed differently and we just quit submitting urbs */ if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) qt2_boxstoprx(serial, port->number, 1); port->throttled = 1; exit: mutex_unlock(&port_extra->modelock); dbg("%s(): port %d: setting port->throttled", __func__, port->number); return; } /** * qt2_unthrottle: - start receiving data through the port again after being * throttled */ static void qt2_unthrottle(struct tty_struct *tty) { struct usb_serial_port *port = tty->driver_data; struct usb_serial *serial = port->serial; struct quatech2_port *port_extra; /* extra data for this port */ struct usb_serial_port *port0; /* first port structure on device */ struct quatech2_dev *dev_extra; /* extra data for the device */ if (!serial) { dbg("%s() enter port %d no serial object!", __func__, port->number); return; } dbg("%s(): enter port %d", __func__, port->number); dev_extra = qt2_get_dev_private(serial); port_extra = qt2_get_port_private(port); port0 = serial->port[0]; /* get the first port's device structure */ mutex_lock(&port_extra->modelock); if (!port_extra->open_count) { dbg("%s(): port %d not open", __func__, port->number); goto exit; } if (port->throttled != 0) { dbg("%s(): port %d: unsetting port->throttled", __func__, port->number); port->throttled = 0; /* Send command to box to start receiving stuff */ if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) { qt2_boxstoprx(serial, port->number, 0); } else if (dev_extra->ReadBulkStopped == true) { usb_fill_bulk_urb(port0->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress), port0->bulk_in_buffer, port0->bulk_in_size, qt2_read_bulk_callback, serial); } } exit: mutex_unlock(&port_extra->modelock); dbg("%s(): exit port %d", __func__, port->number); return; } /* internal, private helper functions for the driver */ /* Power up the FPGA in the box to get it working */ static int qt2_boxpoweron(struct usb_serial *serial) { int result; __u8 Direcion; unsigned int pipe; Direcion = USBD_TRANSFER_DIRECTION_OUT; pipe = usb_rcvctrlpipe(serial->dev, 0); result = usb_control_msg(serial->dev, pipe, QT_SET_GET_DEVICE, Direcion, QU2BOXPWRON, 0x00, NULL, 0x00, 5000); return result; } /* * qt2_boxsetQMCR Issue a QT2_GET_SET_QMCR vendor-spcific request on the * default control pipe. If successful return the number of bytes written, * otherwise return a negative error number of the problem. */ static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number, __u8 QMCR_Value) { int result; __u16 PortSettings; PortSettings = (__u16)(QMCR_Value); dbg("%s(): Port = %d, PortSettings = 0x%x", __func__, Uart_Number, PortSettings); result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_GET_SET_QMCR, 0x40, PortSettings, (__u16)Uart_Number, NULL, 0, 5000); return result; } static int port_paranoia_check(struct usb_serial_port *port, const char *function) { if (!port) { dbg("%s - port == NULL", function); return -1; } if (!port->serial) { dbg("%s - port->serial == NULL\n", function); return -1; } return 0; } static int serial_paranoia_check(struct usb_serial *serial, const char *function) { if (!serial) { dbg("%s - serial == NULL\n", function); return -1; } if (!serial->type) { dbg("%s - serial->type == NULL!", function); return -1; } return 0; } static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port *port) { return (struct quatech2_port *)usb_get_serial_port_data(port); } static inline void qt2_set_port_private(struct usb_serial_port *port, struct quatech2_port *data) { usb_set_serial_port_data(port, (void *)data); } static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial *serial) { return (struct quatech2_dev *)usb_get_serial_data(serial); } static inline void qt2_set_dev_private(struct usb_serial *serial, struct quatech2_dev *data) { usb_set_serial_data(serial, (void *)data); } static int qt2_openboxchannel(struct usb_serial *serial, __u16 Uart_Number, struct qt2_status_data *status) { int result; __u16 length; __u8 Direcion; unsigned int pipe; length = sizeof(struct qt2_status_data); Direcion = USBD_TRANSFER_DIRECTION_IN; pipe = usb_rcvctrlpipe(serial->dev, 0); result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL, Direcion, 0x00, Uart_Number, status, length, 5000); return result; } static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number) { int result; __u8 direcion; unsigned int pipe; direcion = USBD_TRANSFER_DIRECTION_OUT; pipe = usb_sndctrlpipe(serial->dev, 0); result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL, direcion, 0, Uart_Number, NULL, 0, 5000); return result; } /* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default * control pipe. If successful sets baud rate divisor and LCR value */ static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, unsigned short divisor, unsigned char LCR) { int result; unsigned short UartNumandLCR; UartNumandLCR = (LCR << 8) + Uart_Number; result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_GET_SET_UART, 0x40, divisor, UartNumandLCR, NULL, 0, 300); return result; } /** @brief Callback for asynchronous submission of read URBs on bulk in * endpoints * * Registered in qt2_open_port(), used to deal with incomming data * from the box. */ static void qt2_read_bulk_callback(struct urb *urb) { /* Get the device pointer (struct usb_serial) back out of the URB */ struct usb_serial *serial = urb->context; /* get the extra struct for the device */ struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); /* Get first port structure from the device */ struct usb_serial_port *port0 = serial->port[0]; /* Get the currently active port structure from serial struct */ struct usb_serial_port *active = dev_extra->current_port; /* get the extra struct for port 0 */ struct quatech2_port *port0_extra = qt2_get_port_private(port0); /* and for the currently active port */ struct quatech2_port *active_extra = qt2_get_port_private(active); /* When we finally get to doing some tty stuff, we will need this */ struct tty_struct *tty_st; unsigned int RxCount; /* the length of the data to process */ unsigned int i; /* loop counter over the data to process */ int result; /* return value cache variable */ bool escapeflag; /* flag set to true if this loop iteration is * parsing an escape sequence, rather than * ordinary data */ dbg("%s(): callback running, active port is %d", __func__, active->number); if (urb->status) { /* read didn't go well */ dev_extra->ReadBulkStopped = true; dbg("%s(): nonzero bulk read status received: %d", __func__, urb->status); return; } /* inline port_sofrint() here */ if (port_paranoia_check(port0, __func__) != 0) { dbg("%s - port_paranoia_check on port0 failed, exiting\n", __func__); return; } if (port_paranoia_check(active, __func__) != 0) { dbg("%s - port_paranoia_check on current_port " "failed, exiting", __func__); return; } /* This single callback function has to do for all the ports on * the device. Data being read up the USB can contain certain * escape sequences which are used to communicate out-of-band * information from the serial port in-band over the USB. * These escapes include sending modem and flow control line * status, and switching the port. The concept of a "Current Port" * is used, which is where data is going until a port change * escape seqence is received. This Current Port is kept between * callbacks so that when this function enters we know which the * currently active port is and can get to work right away without * the box having to send repeat escape sequences (anyway, how * would it know to do so?). */ if (active_extra->close_pending == true) { /* We are closing , stop reading */ dbg("%s - (active->close_pending == true", __func__); if (dev_extra->open_ports <= 0) { /* If this is the only port left open - stop the * bulk read */ dev_extra->ReadBulkStopped = true; dbg("%s - (ReadBulkStopped == true;", __func__); return; } } /* * RxHolding is asserted by throttle, if we assert it, we're not * receiving any more characters and let the box handle the flow * control */ if ((port0_extra->RxHolding == true) && (serial->dev->descriptor.idProduct == QUATECH_SSU2_100)) { /* single port device, input is already stopped, so we don't * need any more input data */ dev_extra->ReadBulkStopped = true; return; } /* finally, we are in a situation where we might consider the data * that is contained within the URB, and what to do about it. * This is likely to involved communicating up to the TTY layer, so * we will need to get hold of the tty for the port we are currently * dealing with */ /* active is a usb_serial_port. It has a member port which is a * tty_port. From this we get a tty_struct pointer which is what we * actually wanted, and keep it on tty_st */ tty_st = tty_port_tty_get(&active->port); if (!tty_st) { dbg("%s - bad tty pointer - exiting", __func__); return; } RxCount = urb->actual_length; /* grab length of data handy */ if (RxCount) { /* skip all this if no data to process */ for (i = 0; i < RxCount ; ++i) { /* Look ahead code here -works on several bytes at onc*/ if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b) && (NEXTCHAR == 0x1b)) { /* we are in an escape sequence, type * determined by the 3rd char */ escapeflag = false; switch (THIRDCHAR) { case 0x00: /* Line status change 4th byte must * follow */ if (i > (RxCount - 4)) { dbg("Illegal escape sequences " "in received data"); break; } qt2_process_line_status(active, FOURTHCHAR); i += 3; escapeflag = true; break; case 0x01: /* Modem status status change 4th byte * must follow */ if (i > (RxCount - 4)) { dbg("Illegal escape sequences " "in received data"); break; } qt2_process_modem_status(active, FOURTHCHAR); i += 3; escapeflag = true; break; case 0x02: /* xmit hold empty 4th byte * must follow */ if (i > (RxCount - 4)) { dbg("Illegal escape sequences " "in received data"); break; } qt2_process_xmit_empty(active, FOURTHCHAR, FIFTHCHAR); i += 4; escapeflag = true; break; case 0x03: /* Port number change 4th byte * must follow */ if (i > (RxCount - 4)) { dbg("Illegal escape sequences " "in received data"); break; } /* Port change. If port open push * current data up to tty layer */ if (active_extra->open_count > 0) tty_flip_buffer_push(tty_st); dbg("Port Change: new port = %d", FOURTHCHAR); qt2_process_port_change(active, FOURTHCHAR); i += 3; escapeflag = true; /* having changed port, the pointers for * the currently active port are all out * of date and need updating */ active = dev_extra->current_port; active_extra = qt2_get_port_private(active); tty_st = tty_port_tty_get( &active->port); break; case 0x04: /* Recv flush 3rd byte must * follow */ if (i > (RxCount - 3)) { dbg("Illegal escape sequences " "in received data"); break; } qt2_process_rcv_flush(active); i += 2; escapeflag = true; break; case 0x05: /* xmit flush 3rd byte must follow */ if (i > (RxCount - 3)) { dbg("Illegal escape sequences " "in received data"); break; } qt2_process_xmit_flush(active); i += 2; escapeflag = true; break; case 0xff: dbg("No status sequence"); qt2_process_rx_char(active, THISCHAR); qt2_process_rx_char(active, NEXTCHAR); i += 2; break; default: qt2_process_rx_char(active, THISCHAR); i += 1; break; } /*end switch*/ if (escapeflag == true) continue; /* if we did an escape char, we don't need * to mess around pushing data through the * tty layer, and can go round again */ } /*endif*/ if (tty_st && urb->actual_length) { tty_buffer_request_room(tty_st, 1); tty_insert_flip_string(tty_st, &( (unsigned char *) (urb->transfer_buffer) )[i], 1); } } /*endfor*/ tty_flip_buffer_push(tty_st); } /*endif*/ /* at this point we have complete dealing with the data for this * callback. All we have to do now is to start the async read process * back off again. */ usb_fill_bulk_urb(port0->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress), port0->bulk_in_buffer, port0->bulk_in_size, qt2_read_bulk_callback, serial); result = usb_submit_urb(port0->read_urb, GFP_ATOMIC); if (result) { dbg("%s(): failed resubmitting read urb, error %d", __func__, result); } else { dbg("%s() successfully resubmitted read urb", __func__); if (tty_st && RxCount) { /* if some inbound data was processed, then * we need to push that through the tty layer */ tty_flip_buffer_push(tty_st); tty_schedule_flip(tty_st); } } /* cribbed from serqt_usb2 driver, but not sure which work needs * scheduling - port0 or currently active port? */ /* schedule_work(&port->work); */ dbg("%s() completed", __func__); return; } /** @brief Callback for asynchronous submission of write URBs on bulk in * endpoints * * Registered in qt2_write(), used to deal with outgoing data * to the box. */ static void qt2_write_bulk_callback(struct urb *urb) { struct usb_serial_port *port = (struct usb_serial_port *)urb->context; struct usb_serial *serial = port->serial; dbg("%s(): port %d", __func__, port->number); if (!serial) { dbg("%s(): bad serial pointer, exiting", __func__); return; } if (urb->status) { dbg("%s(): nonzero write bulk status received: %d", __func__, urb->status); return; } /* FIXME What is supposed to be going on here? * does this actually do anything useful, and should it? */ /*port_softint((void *) serial); commented in vendor driver */ schedule_work(&port->work); dbg("%s(): port %d exit", __func__, port->number); return; } static void qt2_process_line_status(struct usb_serial_port *port, unsigned char LineStatus) { /* obtain the private structure for the port */ struct quatech2_port *port_extra = qt2_get_port_private(port); port_extra->shadowLSR = LineStatus & (QT2_SERIAL_LSR_OE | QT2_SERIAL_LSR_PE | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI); } static void qt2_process_modem_status(struct usb_serial_port *port, unsigned char ModemStatus) { /* obtain the private structure for the port */ struct quatech2_port *port_extra = qt2_get_port_private(port); port_extra->shadowMSR = ModemStatus; wake_up_interruptible(&port_extra->wait); /* this wakes up the otherwise indefinitely waiting code for * the TIOCMIWAIT ioctl, so that it can notice that * port_extra->shadowMSR has changed and the ioctl needs to return. */ } static void qt2_process_xmit_empty(struct usb_serial_port *port, unsigned char fourth_char, unsigned char fifth_char) { int byte_count; /* obtain the private structure for the port */ struct quatech2_port *port_extra = qt2_get_port_private(port); byte_count = (int)(fifth_char * 16); byte_count += (int)fourth_char; /* byte_count indicates how many bytes the device has written out. This * message appears to occur regularly, and is used in the vendor driver * to keep track of the fill state of the port transmit buffer */ port_extra->tx_pending_bytes -= byte_count; /* reduce the stored data queue length by the known number of bytes * sent */ dbg("port %d: %d bytes reported sent, %d still pending", port->number, byte_count, port_extra->tx_pending_bytes); /*port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; ???*/ } static void qt2_process_port_change(struct usb_serial_port *port, unsigned char New_Current_Port) { /* obtain the parent usb serial device structure */ struct usb_serial *serial = port->serial; /* obtain the private structure for the device */ struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); dev_extra->current_port = serial->port[New_Current_Port]; /* what should I do with this? commented out in upstream * driver */ /*schedule_work(&port->work);*/ } static void qt2_process_rcv_flush(struct usb_serial_port *port) { /* obtain the private structure for the port */ struct quatech2_port *port_extra = qt2_get_port_private(port); port_extra->rcv_flush = true; } static void qt2_process_xmit_flush(struct usb_serial_port *port) { /* obtain the private structure for the port */ struct quatech2_port *port_extra = qt2_get_port_private(port); port_extra->xmit_flush = true; } static void qt2_process_rx_char(struct usb_serial_port *port, unsigned char data) { /* get the tty_struct for this port */ struct tty_struct *tty = tty_port_tty_get(&(port->port)); /* get the URB with the data in to push */ struct urb *urb = port->serial->port[0]->read_urb; if (tty && urb->actual_length) { tty_buffer_request_room(tty, 1); tty_insert_flip_string(tty, &data, 1); /* should this be commented out here? */ /*tty_flip_buffer_push(tty);*/ } } /** @brief Retrieve the value of a register from the device * * Issues a GET_REGISTER vendor-spcific request over the USB control * pipe to obtain a value back from a specific register on a specific * UART * @param serial Serial device handle to access the device through * @param uart_number Which UART the value is wanted from * @param register_num Which register to read the value from * @param pValue Pointer to somewhere to put the retrieved value */ static int qt2_box_get_register(struct usb_serial *serial, unsigned char uart_number, unsigned short register_num, __u8 *pValue) { int result; result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), QT2_GET_SET_REGISTER, 0xC0, register_num, uart_number, (void *)pValue, sizeof(*pValue), 300); return result; } /** qt2_box_set_register * Issue a SET_REGISTER vendor-specific request on the default control pipe */ static int qt2_box_set_register(struct usb_serial *serial, unsigned short Uart_Number, unsigned short Register_Num, unsigned short Value) { int result; unsigned short reg_and_byte; reg_and_byte = Value; reg_and_byte = reg_and_byte << 8; reg_and_byte = reg_and_byte + Register_Num; result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_GET_SET_REGISTER, 0x40, reg_and_byte, Uart_Number, NULL, 0, 300); return result; } /** qt2_boxsetuart - Issue a SET_UART vendor-spcific request on the default * control pipe. If successful sets baud rate divisor and LCR value. */ static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number, unsigned short default_divisor, unsigned char default_LCR) { unsigned short UartNumandLCR; UartNumandLCR = (default_LCR << 8) + Uart_Number; return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_GET_SET_UART, 0x40, default_divisor, UartNumandLCR, NULL, 0, 300); } /** qt2_boxsethw_flowctl - Turn hardware (RTS/CTS) flow control on and off for * a hardware UART. */ static int qt2_boxsethw_flowctl(struct usb_serial *serial, unsigned int UartNumber, bool bSet) { __u8 MCR_Value = 0; __u8 MSR_Value = 0; __u16 MOUT_Value = 0; if (bSet == true) { MCR_Value = QT2_SERIAL_MCR_RTS; /* flow control, box will clear RTS line to prevent remote * device from transmitting more chars */ } else { /* no flow control to remote device */ MCR_Value = 0; } MOUT_Value = MCR_Value << 8; if (bSet == true) { MSR_Value = QT2_SERIAL_MSR_CTS; /* flow control on, box will inhibit tx data if CTS line is * asserted */ } else { /* Box will not inhibit tx data due to CTS line */ MSR_Value = 0; } MOUT_Value |= MSR_Value; return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value, UartNumber, NULL, 0, 300); } /** qt2_boxsetsw_flowctl - Turn software (XON/XOFF) flow control on for * a hardware UART, and set the XON and XOFF characters. */ static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber, unsigned char stop_char, unsigned char start_char) { __u16 nSWflowout; nSWflowout = start_char << 8; nSWflowout = (unsigned short)stop_char; return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout, UartNumber, NULL, 0, 300); } /** qt2_boxunsetsw_flowctl - Turn software (XON/XOFF) flow control off for * a hardware UART. */ static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber) { return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber, NULL, 0, 300); } /** * qt2_boxstoprx - Start and stop reception of data by the FPGA UART in * response to requests from the tty layer * @serial: pointer to the usb_serial structure for the parent device * @uart_number: which UART on the device we are addressing * @stop: Whether to start or stop data reception. Set to 1 to stop data being * received, and to 0 to start it being received. */ static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number, unsigned short stop) { return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT2_STOP_RECEIVE, 0x40, stop, uart_number, NULL, 0, 300); } /* * last things in file: stuff to register this driver into the generic * USB serial framework. */ static struct usb_serial_driver quatech2_device = { .driver = { .owner = THIS_MODULE, .name = "quatech_usb2", }, .description = DRIVER_DESC, .usb_driver = &quausb2_usb_driver, .id_table = quausb2_id_table, .num_ports = 8, .open = qt2_open, .close = qt2_close, .write = qt2_write, .write_room = qt2_write_room, .chars_in_buffer = qt2_chars_in_buffer, .throttle = qt2_throttle, .unthrottle = qt2_unthrottle, .calc_num_ports = qt2_calc_num_ports, .ioctl = qt2_ioctl, .set_termios = qt2_set_termios, .break_ctl = qt2_break, .tiocmget = qt2_tiocmget, .tiocmset = qt2_tiocmset, .attach = qt2_attach, .release = qt2_release, .read_bulk_callback = qt2_read_bulk_callback, .write_bulk_callback = qt2_write_bulk_callback, }; static int __init quausb2_usb_init(void) { int retval; dbg("%s\n", __func__); /* register with usb-serial */ retval = usb_serial_register(&quatech2_device); if (retval) goto failed_usb_serial_register; printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" DRIVER_DESC "\n"); /* register with usb */ retval = usb_register(&quausb2_usb_driver); if (retval == 0) return 0; /* if we're here, usb_register() failed */ usb_serial_deregister(&quatech2_device); failed_usb_serial_register: return retval; } static void __exit quausb2_usb_exit(void) { usb_deregister(&quausb2_usb_driver); usb_serial_deregister(&quatech2_device); } module_init(quausb2_usb_init); module_exit(quausb2_usb_exit); MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); MODULE_LICENSE("GPL"); module_param(debug, bool, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(debug, "Debug enabled or not");