Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1 | /* |
| 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 |
| 5 | */ |
| 6 | |
| 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> |
| 18 | |
| 19 | static int debug; |
| 20 | |
| 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" |
| 25 | |
| 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 */ |
| 35 | |
| 36 | /* magic numbers go here, when we find out which ones are needed */ |
| 37 | |
| 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 */ |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 41 | #define QT2_FIFO_DEPTH 1024 /* size of hardware fifos */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 42 | #define QT2_TX_HEADER_LENGTH 5 |
| 43 | /* length of the header sent to the box with each write URB */ |
| 44 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 45 | /* directions for USB transfers */ |
| 46 | #define USBD_TRANSFER_DIRECTION_IN 0xc0 |
| 47 | #define USBD_TRANSFER_DIRECTION_OUT 0x40 |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 48 | |
| 49 | /* special Quatech command IDs. These are pushed down the |
| 50 | USB control pipe to get the box on the end to do things */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 51 | #define QT_SET_GET_DEVICE 0xc2 |
| 52 | #define QT_OPEN_CLOSE_CHANNEL 0xca |
| 53 | /*#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 54 | #define QT_SET_ATF 0xcd*/ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 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 |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 59 | #define QT2_SW_FLOW_CONTROL_DISABLE 0xc7 |
Soeren Moeller | 08db6c5 | 2010-03-30 20:11:12 +0000 | [diff] [blame] | 60 | #define QT2_BREAK_CONTROL 0xc8 |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 61 | #define QT2_STOP_RECEIVE 0xe0 |
| 62 | #define QT2_FLUSH_DEVICE 0xc4 |
| 63 | #define QT2_GET_SET_QMCR 0xe1 |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 64 | |
| 65 | /* sorts of flush we can do on */ |
| 66 | #define QT2_FLUSH_RX 0x00 |
| 67 | #define QT2_FLUSH_TX 0x01 |
| 68 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 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 |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 74 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 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 |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 80 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 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 |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 85 | |
Richard Ash | 560a9be | 2009-08-20 11:25:12 +0100 | [diff] [blame] | 86 | #define QT2_SERIAL_ODD_PARITY 0x08 |
| 87 | #define QT2_SERIAL_EVEN_PARITY 0x18 |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 88 | #define QT2_SERIAL_TWO_STOPB 0x04 |
| 89 | #define QT2_SERIAL_ONE_STOPB 0x00 |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 90 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 91 | #define QT2_MAX_BAUD_RATE 921600 |
| 92 | #define QT2_MAX_BAUD_REMAINDER 4608 |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 93 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 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 |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 98 | |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 99 | /* value of Line Status Register when UART has completed |
| 100 | * emptying data out on the line */ |
| 101 | #define QT2_LSR_TEMT 0x40 |
| 102 | |
| 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 |
| 111 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 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] |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 118 | |
Németh Márton | a457732 | 2010-01-10 00:18:34 +0100 | [diff] [blame] | 119 | static const struct usb_device_id quausb2_id_table[] = { |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 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 */ |
| 128 | }; |
| 129 | |
| 130 | MODULE_DEVICE_TABLE(usb, quausb2_id_table); |
| 131 | |
| 132 | /* custom structures we need go here */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 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, |
| 138 | .no_dynamic_id = 1, |
| 139 | }; |
| 140 | |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 141 | /** |
| 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 |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 146 | * being closed (and so no new reads / writes should be started). |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 147 | * @shadowLSR: Last received state of the line status register, holds the |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 148 | * value of the line status flags from the port |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 149 | * @shadowMSR: Last received state of the modem status register, holds |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 150 | * the value of the modem status received from the port |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 151 | * @rcv_flush: Flag indicating that a receive flush has occured on |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 152 | * the hardware. |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 153 | * @xmit_flush: Flag indicating that a transmit flush has been processed by |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 154 | * the hardware. |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 155 | * @tx_pending_bytes: Number of bytes waiting to be sent. This total |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 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 |
| 160 | * misleading name). |
| 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. |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 166 | * @lock: Mutex to lock access to this structure when we need to ensure that |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 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. |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 170 | */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 171 | struct quatech2_port { |
| 172 | int magic; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 173 | bool read_urb_busy; |
| 174 | bool close_pending; |
| 175 | __u8 shadowLSR; |
| 176 | __u8 shadowMSR; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 177 | bool rcv_flush; |
| 178 | bool xmit_flush; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 179 | int tx_pending_bytes; |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 180 | struct mutex modelock; |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 181 | int open_count; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 182 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 183 | char active; /* someone has this device open */ |
| 184 | unsigned char *xfer_to_tty_buffer; |
| 185 | wait_queue_head_t wait; |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 186 | __u8 shadowLCR; /* last LCR value received */ |
| 187 | __u8 shadowMCR; /* last MCR value received */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 188 | char RxHolding; |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 189 | struct semaphore pend_xmit_sem; /* locks this structure */ |
| 190 | spinlock_t lock; |
| 191 | }; |
| 192 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 193 | /** |
| 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 |
| 200 | * box |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 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. |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 205 | */ |
| 206 | struct quatech2_dev { |
| 207 | bool ReadBulkStopped; |
| 208 | char open_ports; |
| 209 | struct usb_serial_port *current_port; |
Soeren Moeller | 08db6c5 | 2010-03-30 20:11:12 +0000 | [diff] [blame] | 210 | int buffer_size; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 211 | }; |
| 212 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 213 | /* structure which holds line and modem status flags */ |
| 214 | struct qt2_status_data { |
| 215 | __u8 line_status; |
| 216 | __u8 modem_status; |
| 217 | }; |
| 218 | |
| 219 | /* Function prototypes */ |
| 220 | static int qt2_boxpoweron(struct usb_serial *serial); |
| 221 | static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number, |
| 222 | __u8 QMCR_Value); |
| 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 |
| 228 | *port); |
| 229 | static inline void qt2_set_port_private(struct usb_serial_port *port, |
| 230 | struct quatech2_port *data); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 231 | static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial |
| 232 | *serial); |
| 233 | static inline void qt2_set_dev_private(struct usb_serial *serial, |
| 234 | struct quatech2_dev *data); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 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 |
| 238 | Uart_Number); |
| 239 | static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, |
| 240 | unsigned short divisor, unsigned char LCR); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 241 | static void qt2_read_bulk_callback(struct urb *urb); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 242 | static void qt2_write_bulk_callback(struct urb *urb); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 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, |
| 254 | unsigned char data); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 255 | static int qt2_box_get_register(struct usb_serial *serial, |
| 256 | unsigned char uart_number, unsigned short register_num, |
| 257 | __u8 *pValue); |
| 258 | static int qt2_box_set_register(struct usb_serial *serial, |
| 259 | unsigned short Uart_Number, unsigned short Register_Num, |
| 260 | unsigned short Value); |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 261 | static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number, |
| 262 | unsigned short default_divisor, unsigned char default_LCR); |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 263 | static int qt2_boxsethw_flowctl(struct usb_serial *serial, |
| 264 | unsigned int UartNumber, bool bSet); |
| 265 | static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber, |
| 266 | unsigned char stop_char, unsigned char start_char); |
| 267 | static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber); |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 268 | static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number, |
| 269 | unsigned short stop); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 270 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 271 | /* implementation functions, roughly in order of use, are here */ |
| 272 | static int qt2_calc_num_ports(struct usb_serial *serial) |
| 273 | { |
| 274 | int num_ports; |
| 275 | int flag_as_400; |
| 276 | switch (serial->dev->descriptor.idProduct) { |
| 277 | case QUATECH_SSU2_100: |
| 278 | num_ports = 1; |
| 279 | break; |
| 280 | |
| 281 | case QUATECH_DSU2_400: |
| 282 | flag_as_400 = true; |
| 283 | case QUATECH_DSU2_100: |
| 284 | num_ports = 2; |
| 285 | break; |
| 286 | |
| 287 | case QUATECH_QSU2_400: |
| 288 | flag_as_400 = true; |
| 289 | case QUATECH_QSU2_100: |
| 290 | num_ports = 4; |
| 291 | break; |
| 292 | |
| 293 | case QUATECH_ESU2_400: |
| 294 | flag_as_400 = true; |
| 295 | case QUATECH_ESU2_100: |
| 296 | num_ports = 8; |
| 297 | break; |
| 298 | default: |
| 299 | num_ports = 1; |
| 300 | break; |
| 301 | } |
| 302 | return num_ports; |
| 303 | } |
| 304 | |
| 305 | static int qt2_attach(struct usb_serial *serial) |
| 306 | { |
| 307 | struct usb_serial_port *port; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 308 | struct quatech2_port *qt2_port; /* port-specific private data pointer */ |
| 309 | struct quatech2_dev *qt2_dev; /* dev-specific private data pointer */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 310 | int i; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 311 | /* stuff for storing endpoint addresses now */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 312 | struct usb_endpoint_descriptor *endpoint; |
| 313 | struct usb_host_interface *iface_desc; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 314 | struct usb_serial_port *port0; /* first port structure on device */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 315 | |
| 316 | /* check how many endpoints there are on the device, for |
| 317 | * sanity's sake */ |
| 318 | dbg("%s(): Endpoints: %d bulk in, %d bulk out, %d interrupt in", |
| 319 | __func__, serial->num_bulk_in, |
| 320 | serial->num_bulk_out, serial->num_interrupt_in); |
| 321 | if ((serial->num_bulk_in != 1) || (serial->num_bulk_out != 1)) { |
| 322 | dbg("Device has wrong number of bulk endpoints!"); |
| 323 | return -ENODEV; |
| 324 | } |
| 325 | iface_desc = serial->interface->cur_altsetting; |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 326 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 327 | /* Set up per-device private data, storing extra data alongside |
| 328 | * struct usb_serial */ |
| 329 | qt2_dev = kzalloc(sizeof(*qt2_dev), GFP_KERNEL); |
| 330 | if (!qt2_dev) { |
| 331 | dbg("%s: kmalloc for quatech2_dev failed!", |
| 332 | __func__); |
| 333 | return -ENOMEM; |
| 334 | } |
| 335 | qt2_dev->open_ports = 0; /* no ports open */ |
| 336 | qt2_set_dev_private(serial, qt2_dev); /* store private data */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 337 | |
| 338 | /* Now setup per port private data, which replaces all the things |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 339 | * that quatech added to standard kernel structures in their driver */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 340 | for (i = 0; i < serial->num_ports; i++) { |
| 341 | port = serial->port[i]; |
| 342 | qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL); |
| 343 | if (!qt2_port) { |
| 344 | dbg("%s: kmalloc for quatech2_port (%d) failed!.", |
| 345 | __func__, i); |
| 346 | return -ENOMEM; |
| 347 | } |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 348 | /* initialise stuff in the structure */ |
| 349 | qt2_port->open_count = 0; /* port is not open */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 350 | spin_lock_init(&qt2_port->lock); |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 351 | mutex_init(&qt2_port->modelock); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 352 | qt2_set_port_private(port, qt2_port); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 353 | } |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 354 | |
| 355 | /* gain access to port[0]'s structure because we want to store |
| 356 | * device-level stuff in it */ |
| 357 | if (serial_paranoia_check(serial, __func__)) |
| 358 | return -ENODEV; |
| 359 | port0 = serial->port[0]; /* get the first port's device structure */ |
| 360 | |
| 361 | /* print endpoint addresses so we can check them later |
| 362 | * by hand */ |
| 363 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { |
| 364 | endpoint = &iface_desc->endpoint[i].desc; |
| 365 | if ((endpoint->bEndpointAddress & 0x80) && |
| 366 | ((endpoint->bmAttributes & 3) == 0x02)) { |
| 367 | /* we found a bulk in endpoint */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 368 | dbg("found bulk in at %#.2x", |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 369 | endpoint->bEndpointAddress); |
| 370 | } |
| 371 | |
| 372 | if (((endpoint->bEndpointAddress & 0x80) == 0x00) && |
| 373 | ((endpoint->bmAttributes & 3) == 0x02)) { |
| 374 | /* we found a bulk out endpoint */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 375 | dbg("found bulk out at %#.2x", |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 376 | endpoint->bEndpointAddress); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 377 | qt2_dev->buffer_size = endpoint->wMaxPacketSize; |
| 378 | /* max size of URB needs recording for the device */ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 379 | } |
| 380 | } /* end printing endpoint addresses */ |
| 381 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 382 | /* switch on power to the hardware */ |
| 383 | if (qt2_boxpoweron(serial) < 0) { |
| 384 | dbg("qt2_boxpoweron() failed"); |
| 385 | goto startup_error; |
| 386 | } |
| 387 | /* set all ports to RS232 mode */ |
| 388 | for (i = 0; i < serial->num_ports; ++i) { |
| 389 | if (qt2_boxsetQMCR(serial, i, QU2BOX232) < 0) { |
| 390 | dbg("qt2_boxsetQMCR() on port %d failed", |
| 391 | i); |
| 392 | goto startup_error; |
| 393 | } |
| 394 | } |
| 395 | |
| 396 | return 0; |
| 397 | |
| 398 | startup_error: |
| 399 | for (i = 0; i < serial->num_ports; i++) { |
| 400 | port = serial->port[i]; |
| 401 | qt2_port = qt2_get_port_private(port); |
| 402 | kfree(qt2_port); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 403 | qt2_set_port_private(port, NULL); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 404 | } |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 405 | qt2_dev = qt2_get_dev_private(serial); |
| 406 | kfree(qt2_dev); |
| 407 | qt2_set_dev_private(serial, NULL); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 408 | |
| 409 | dbg("Exit fail %s\n", __func__); |
| 410 | return -EIO; |
| 411 | } |
| 412 | |
| 413 | static void qt2_release(struct usb_serial *serial) |
| 414 | { |
| 415 | struct usb_serial_port *port; |
| 416 | struct quatech2_port *qt_port; |
| 417 | int i; |
| 418 | |
| 419 | dbg("enterting %s", __func__); |
| 420 | |
| 421 | for (i = 0; i < serial->num_ports; i++) { |
| 422 | port = serial->port[i]; |
| 423 | if (!port) |
| 424 | continue; |
| 425 | |
| 426 | qt_port = usb_get_serial_port_data(port); |
| 427 | kfree(qt_port); |
| 428 | usb_set_serial_port_data(port, NULL); |
| 429 | } |
| 430 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 431 | /* This function is called once per serial port on the device, when |
| 432 | * that port is opened by a userspace application. |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 433 | * The tty_struct and the usb_serial_port belong to this port, |
| 434 | * i.e. there are multiple ones for a multi-port device. |
| 435 | * However the usb_serial_port structure has a back-pointer |
| 436 | * to the parent usb_serial structure which belongs to the device, |
| 437 | * so we can access either the device-wide information or |
| 438 | * any other port's information (because there are also forward |
| 439 | * pointers) via that pointer. |
| 440 | * This is most helpful if the device shares resources (e.g. end |
| 441 | * points) between different ports |
| 442 | */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 443 | int qt2_open(struct tty_struct *tty, struct usb_serial_port *port) |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 444 | { |
| 445 | struct usb_serial *serial; /* device structure */ |
| 446 | struct usb_serial_port *port0; /* first port structure on device */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 447 | struct quatech2_port *port_extra; /* extra data for this port */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 448 | struct quatech2_port *port0_extra; /* extra data for first port */ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 449 | struct quatech2_dev *dev_extra; /* extra data for the device */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 450 | struct qt2_status_data ChannelData; |
| 451 | unsigned short default_divisor = QU2BOXSPD9600; |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 452 | unsigned char default_LCR = QT2_SERIAL_8_DATA; |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 453 | int status; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 454 | int result; |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 455 | |
| 456 | if (port_paranoia_check(port, __func__)) |
| 457 | return -ENODEV; |
| 458 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 459 | dbg("%s(): port %d", __func__, port->number); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 460 | |
| 461 | serial = port->serial; /* get the parent device structure */ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 462 | if (serial_paranoia_check(serial, __func__)) { |
| 463 | dbg("usb_serial struct failed sanity check"); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 464 | return -ENODEV; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 465 | } |
| 466 | dev_extra = qt2_get_dev_private(serial); |
| 467 | /* get the device private data */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 468 | if (dev_extra == NULL) { |
| 469 | dbg("device extra data pointer is null"); |
| 470 | return -ENODEV; |
| 471 | } |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 472 | port0 = serial->port[0]; /* get the first port's device structure */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 473 | if (port_paranoia_check(port0, __func__)) { |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 474 | dbg("port0 usb_serial_port struct failed sanity check"); |
| 475 | return -ENODEV; |
| 476 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 477 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 478 | port_extra = qt2_get_port_private(port); |
| 479 | port0_extra = qt2_get_port_private(port0); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 480 | if (port_extra == NULL || port0_extra == NULL) { |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 481 | dbg("failed to get private data for port or port0"); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 482 | return -ENODEV; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 483 | } |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 484 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 485 | /* FIXME: are these needed? Does it even do anything useful? */ |
| 486 | /* get the modem and line status values from the UART */ |
| 487 | status = qt2_openboxchannel(serial, port->number, |
| 488 | &ChannelData); |
| 489 | if (status < 0) { |
| 490 | dbg("qt2_openboxchannel on channel %d failed", |
| 491 | port->number); |
| 492 | return status; |
| 493 | } |
| 494 | port_extra->shadowLSR = ChannelData.line_status & |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 495 | (QT2_SERIAL_LSR_OE | QT2_SERIAL_LSR_PE | |
| 496 | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 497 | port_extra->shadowMSR = ChannelData.modem_status & |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 498 | (QT2_SERIAL_MSR_CTS | QT2_SERIAL_MSR_DSR | |
| 499 | QT2_SERIAL_MSR_RI | QT2_SERIAL_MSR_CD); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 500 | |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 501 | /* port_extra->fifo_empty_flag = true;*/ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 502 | dbg("qt2_openboxchannel on channel %d completed.", |
| 503 | port->number); |
| 504 | |
| 505 | /* Set Baud rate to default and turn off flow control here */ |
| 506 | status = qt2_conf_uart(serial, port->number, default_divisor, |
| 507 | default_LCR); |
| 508 | if (status < 0) { |
| 509 | dbg("qt2_conf_uart() failed on channel %d", |
| 510 | port->number); |
| 511 | return status; |
| 512 | } |
| 513 | dbg("qt2_conf_uart() completed on channel %d", |
| 514 | port->number); |
| 515 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 516 | /* |
| 517 | * At this point we will need some end points to make further progress. |
| 518 | * Handlily, the correct endpoint addresses have been filled out into |
| 519 | * the usb_serial_port structure for us by the driver core, so we |
| 520 | * already have access to them. |
| 521 | * As there is only one bulk in and one bulk out end-point, these are in |
| 522 | * port[0]'s structure, and the rest are uninitialised. Handily, |
| 523 | * when we do a write to a port, we will use the same endpoint |
| 524 | * regardless of the port, with a 5-byte header added on to |
| 525 | * tell the box which port it should eventually come out of, so we only |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 526 | * need the one set of endpoints. We will have one URB per port for |
| 527 | * writing, so that multiple ports can be writing at once. |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 528 | * Finally we need a bulk in URB to use for background reads from the |
| 529 | * device, which will deal with uplink data from the box to host. |
| 530 | */ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 531 | dbg("port0 bulk in endpoint is %#.2x", port0->bulk_in_endpointAddress); |
| 532 | dbg("port0 bulk out endpoint is %#.2x", |
| 533 | port0->bulk_out_endpointAddress); |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 534 | |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 535 | /* set up write_urb for bulk out transfers on this port. The USB |
| 536 | * serial framework will have allocated a blank URB, buffer etc for |
| 537 | * port0 when it put the endpoints there, but not for any of the other |
| 538 | * ports on the device because there are no more endpoints. Thus we |
| 539 | * have to allocate our own URBs for ports 1-7 |
| 540 | */ |
| 541 | if (port->write_urb == NULL) { |
| 542 | dbg("port->write_urb == NULL, allocating one"); |
| 543 | port->write_urb = usb_alloc_urb(0, GFP_KERNEL); |
| 544 | if (!port->write_urb) { |
| 545 | err("Allocating write URB failed"); |
| 546 | return -ENOMEM; |
| 547 | } |
| 548 | /* buffer same size as port0 */ |
| 549 | port->bulk_out_size = dev_extra->buffer_size; |
| 550 | port->bulk_out_buffer = kmalloc(port->bulk_out_size, |
| 551 | GFP_KERNEL); |
| 552 | if (!port->bulk_out_buffer) { |
| 553 | err("Couldn't allocate bulk_out_buffer"); |
| 554 | return -ENOMEM; |
| 555 | } |
| 556 | } |
| 557 | if (serial->dev == NULL) |
| 558 | dbg("serial->dev == NULL"); |
| 559 | dbg("port->bulk_out_size is %d", port->bulk_out_size); |
| 560 | |
| 561 | usb_fill_bulk_urb(port->write_urb, serial->dev, |
| 562 | usb_sndbulkpipe(serial->dev, |
| 563 | port0->bulk_out_endpointAddress), |
| 564 | port->bulk_out_buffer, |
| 565 | port->bulk_out_size, |
| 566 | qt2_write_bulk_callback, |
| 567 | port); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 568 | port_extra->tx_pending_bytes = 0; |
| 569 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 570 | if (dev_extra->open_ports == 0) { |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 571 | /* this is first port to be opened, so need the read URB |
| 572 | * initialised for bulk in transfers (this is shared amongst |
| 573 | * all the ports on the device) */ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 574 | usb_fill_bulk_urb(port0->read_urb, serial->dev, |
| 575 | usb_rcvbulkpipe(serial->dev, |
| 576 | port0->bulk_in_endpointAddress), |
| 577 | port0->bulk_in_buffer, |
| 578 | port0->bulk_in_size, |
| 579 | qt2_read_bulk_callback, serial); |
Uwe Kleine-König | 9b0131c | 2010-09-01 15:40:25 +0200 | [diff] [blame] | 580 | dbg("port0 bulk in URB initialised"); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 581 | |
| 582 | /* submit URB, i.e. start reading from device (async) */ |
| 583 | dev_extra->ReadBulkStopped = false; |
| 584 | port_extra->read_urb_busy = true; |
| 585 | result = usb_submit_urb(port->read_urb, GFP_KERNEL); |
| 586 | if (result) { |
| 587 | dev_err(&port->dev, |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 588 | "%s(): Error %d submitting bulk in urb", |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 589 | __func__, result); |
| 590 | port_extra->read_urb_busy = false; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 591 | dev_extra->ReadBulkStopped = true; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 592 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 593 | |
| 594 | /* When the first port is opened, initialise the value of |
| 595 | * current_port in dev_extra to this port, so it is set |
| 596 | * to something. Once the box sends data it will send the |
| 597 | * relevant escape sequences to get it to the right port anyway |
| 598 | */ |
| 599 | dev_extra->current_port = port; |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 600 | } |
| 601 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 602 | /* initialize our wait queues */ |
| 603 | init_waitqueue_head(&port_extra->wait); |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 604 | /* increment the count of openings of this port by one */ |
| 605 | port_extra->open_count++; |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 606 | |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 607 | /* remember to store dev_extra, port_extra and port0_extra back again at |
| 608 | * end !*/ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 609 | qt2_set_port_private(port, port_extra); |
| 610 | qt2_set_port_private(serial->port[0], port0_extra); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 611 | qt2_set_dev_private(serial, dev_extra); |
| 612 | |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 613 | dev_extra->open_ports++; /* one more port opened */ |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 614 | |
| 615 | return 0; |
| 616 | } |
| 617 | |
Richard Ash | 2feb633 | 2009-08-17 10:43:49 +0100 | [diff] [blame] | 618 | /* called when a port is closed by userspace. It won't be called, however, |
| 619 | * until calls to chars_in_buffer() reveal that the port has completed |
| 620 | * sending buffered data, and there is nothing else to do. Thus we don't have |
| 621 | * to rely on forcing data through in this function. */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 622 | /* Setting close_pending should keep new data from being written out, |
| 623 | * once all the data in the enpoint buffers is moved out we won't get |
| 624 | * any more. */ |
| 625 | /* BoxStopReceive would keep any more data from coming from a given |
| 626 | * port, but isn't called by the vendor driver, although their comments |
| 627 | * mention it. Should it be used here to stop the inbound data |
| 628 | * flow? |
| 629 | */ |
| 630 | static void qt2_close(struct usb_serial_port *port) |
| 631 | { |
| 632 | /* time out value for flush loops */ |
| 633 | unsigned long jift; |
| 634 | struct quatech2_port *port_extra; /* extra data for this port */ |
| 635 | struct usb_serial *serial; /* device structure */ |
| 636 | struct quatech2_dev *dev_extra; /* extra data for the device */ |
| 637 | __u8 lsr_value = 0; /* value of Line Status Register */ |
| 638 | int status; /* result of last USB comms function */ |
| 639 | |
| 640 | dbg("%s(): port %d", __func__, port->number); |
| 641 | serial = port->serial; /* get the parent device structure */ |
| 642 | dev_extra = qt2_get_dev_private(serial); |
| 643 | /* get the device private data */ |
| 644 | port_extra = qt2_get_port_private(port); /* port private data */ |
| 645 | |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 646 | /* we can now (and only now) stop reading data */ |
| 647 | port_extra->close_pending = true; |
| 648 | dbg("%s(): port_extra->close_pending = true", __func__); |
| 649 | /* although the USB side is now empty, the UART itself may |
| 650 | * still be pushing characters out over the line, so we have to |
| 651 | * wait testing the actual line status until the lines change |
| 652 | * indicating that the data is done transfering. */ |
Richard Ash | 2feb633 | 2009-08-17 10:43:49 +0100 | [diff] [blame] | 653 | /* FIXME: slow this polling down so it doesn't run the USB bus flat out |
| 654 | * if it actually has to spend any time in this loop (which it normally |
| 655 | * doesn't because the buffer is nearly empty) */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 656 | jift = jiffies + (10 * HZ); /* 10 sec timeout */ |
| 657 | do { |
| 658 | status = qt2_box_get_register(serial, port->number, |
| 659 | QT2_LINE_STATUS_REGISTER, &lsr_value); |
| 660 | if (status < 0) { |
| 661 | dbg("%s(): qt2_box_get_register failed", __func__); |
| 662 | break; |
| 663 | } |
| 664 | if ((lsr_value & QT2_LSR_TEMT)) { |
| 665 | dbg("UART done sending"); |
| 666 | break; |
| 667 | } |
| 668 | schedule(); |
| 669 | } while (jiffies <= jift); |
| 670 | |
| 671 | status = qt2_closeboxchannel(serial, port->number); |
| 672 | if (status < 0) |
| 673 | dbg("%s(): port %d qt2_box_open_close_channel failed", |
| 674 | __func__, port->number); |
| 675 | /* to avoid leaking URBs, we should now free the write_urb for this |
| 676 | * port and set the pointer to null so that next time the port is opened |
| 677 | * a new URB is allocated. This avoids leaking URBs when the device is |
| 678 | * removed */ |
| 679 | usb_free_urb(port->write_urb); |
| 680 | kfree(port->bulk_out_buffer); |
| 681 | port->bulk_out_buffer = NULL; |
| 682 | port->bulk_out_size = 0; |
| 683 | |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 684 | /* decrement the count of openings of this port by one */ |
| 685 | port_extra->open_count--; |
| 686 | /* one less overall open as well */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 687 | dev_extra->open_ports--; |
| 688 | dbg("%s(): Exit, dev_extra->open_ports = %d", __func__, |
| 689 | dev_extra->open_ports); |
| 690 | } |
| 691 | |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 692 | /** |
| 693 | * qt2_write - write bytes from the tty layer out to the USB device. |
| 694 | * @buf: The data to be written, size at least count. |
| 695 | * @count: The number of bytes requested for transmission. |
| 696 | * @return The number of bytes actually accepted for transmission to the device. |
| 697 | */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 698 | static int qt2_write(struct tty_struct *tty, struct usb_serial_port *port, |
| 699 | const unsigned char *buf, int count) |
| 700 | { |
| 701 | struct usb_serial *serial; /* parent device struct */ |
| 702 | __u8 header_array[5]; /* header used to direct writes to the correct |
| 703 | port on the device */ |
| 704 | struct quatech2_port *port_extra; /* extra data for this port */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 705 | int result; |
| 706 | |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 707 | serial = port->serial; /* get the parent device of the port */ |
| 708 | port_extra = qt2_get_port_private(port); /* port extra info */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 709 | if (serial == NULL) |
| 710 | return -ENODEV; |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 711 | dbg("%s(): port %d, requested to write %d bytes, %d already pending", |
| 712 | __func__, port->number, count, port_extra->tx_pending_bytes); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 713 | |
| 714 | if (count <= 0) { |
| 715 | dbg("%s(): write request of <= 0 bytes", __func__); |
| 716 | return 0; /* no bytes written */ |
| 717 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 718 | |
| 719 | /* check if the write urb is already in use, i.e. data already being |
| 720 | * sent to this port */ |
| 721 | if ((port->write_urb->status == -EINPROGRESS)) { |
| 722 | /* Fifo hasn't been emptied since last write to this port */ |
| 723 | dbg("%s(): already writing, port->write_urb->status == " |
| 724 | "-EINPROGRESS", __func__); |
| 725 | /* schedule_work(&port->work); commented in vendor driver */ |
| 726 | return 0; |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 727 | } else if (port_extra->tx_pending_bytes >= QT2_FIFO_DEPTH) { |
| 728 | /* buffer is full (==). > should not occur, but would indicate |
| 729 | * that an overflow had occured */ |
| 730 | dbg("%s(): port transmit buffer is full!", __func__); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 731 | /* schedule_work(&port->work); commented in vendor driver */ |
| 732 | return 0; |
| 733 | } |
| 734 | |
| 735 | /* We must fill the first 5 bytes of anything we sent with a transmit |
| 736 | * header which directes the data to the correct port. The maximum |
| 737 | * size we can send out in one URB is port->bulk_out_size, which caps |
| 738 | * the number of bytes of real data we can send in each write. As the |
| 739 | * semantics of write allow us to write less than we were give, we cap |
| 740 | * the maximum we will ever write to the device as 5 bytes less than |
| 741 | * one URB's worth, by reducing the value of the count argument |
| 742 | * appropriately*/ |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 743 | if (count > port->bulk_out_size - QT2_TX_HEADER_LENGTH) { |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 744 | count = port->bulk_out_size - QT2_TX_HEADER_LENGTH; |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 745 | dbg("%s(): write request bigger than urb, only accepting " |
| 746 | "%d bytes", __func__, count); |
| 747 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 748 | /* we must also ensure that the FIFO at the other end can cope with the |
| 749 | * URB we send it, otherwise it will have problems. As above, we can |
| 750 | * restrict the write size by just shrinking count.*/ |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 751 | if (count > (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes)) { |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 752 | count = QT2_FIFO_DEPTH - port_extra->tx_pending_bytes; |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 753 | dbg("%s(): not enough room in buffer, only accepting %d bytes", |
| 754 | __func__, count); |
| 755 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 756 | /* now build the header for transmission */ |
| 757 | header_array[0] = 0x1b; |
| 758 | header_array[1] = 0x1b; |
| 759 | header_array[2] = (__u8)port->number; |
| 760 | header_array[3] = (__u8)count; |
| 761 | header_array[4] = (__u8)count >> 8; |
| 762 | /* copy header into URB */ |
| 763 | memcpy(port->write_urb->transfer_buffer, header_array, |
| 764 | QT2_TX_HEADER_LENGTH); |
| 765 | /* and actual data to write */ |
| 766 | memcpy(port->write_urb->transfer_buffer + 5, buf, count); |
| 767 | |
| 768 | dbg("%s(): first data byte to send = %#.2x", __func__, *buf); |
| 769 | |
| 770 | /* set up our urb */ |
| 771 | usb_fill_bulk_urb(port->write_urb, serial->dev, |
| 772 | usb_sndbulkpipe(serial->dev, |
| 773 | port->bulk_out_endpointAddress), |
| 774 | port->write_urb->transfer_buffer, count + 5, |
| 775 | (qt2_write_bulk_callback), port); |
| 776 | /* send the data out the bulk port */ |
| 777 | result = usb_submit_urb(port->write_urb, GFP_ATOMIC); |
| 778 | if (result) { |
| 779 | /* error couldn't submit urb */ |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 780 | result = 0; /* return 0 as nothing got written */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 781 | dbg("%s(): failed submitting write urb, error %d", |
| 782 | __func__, result); |
| 783 | } else { |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 784 | port_extra->tx_pending_bytes += count; |
| 785 | result = count; /* return number of bytes written, i.e. count */ |
| 786 | dbg("%s(): submitted write urb, wrote %d bytes, " |
| 787 | "total pending bytes %d", |
| 788 | __func__, result, port_extra->tx_pending_bytes); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 789 | } |
| 790 | return result; |
| 791 | } |
| 792 | |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 793 | /* This is used by the next layer up to know how much space is available |
| 794 | * in the buffer on the device. It is used on a device closure to avoid |
| 795 | * calling close() until the buffer is reported to be empty. |
| 796 | * The returned value must never go down by more than the number of bytes |
| 797 | * written for correct behaviour further up the driver stack, i.e. if I call |
| 798 | * it, then write 6 bytes, then call again I should get 6 less, or possibly |
| 799 | * only 5 less if one was written in the meantime, etc. I should never get 7 |
| 800 | * less (or any bigger number) because I only wrote 6 bytes. |
| 801 | */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 802 | static int qt2_write_room(struct tty_struct *tty) |
| 803 | { |
| 804 | struct usb_serial_port *port = tty->driver_data; |
| 805 | /* parent usb_serial_port pointer */ |
| 806 | struct quatech2_port *port_extra; /* extra data for this port */ |
| 807 | int room = 0; |
| 808 | port_extra = qt2_get_port_private(port); |
| 809 | |
| 810 | if (port_extra->close_pending == true) { |
| 811 | dbg("%s(): port_extra->close_pending == true", __func__); |
| 812 | return -ENODEV; |
| 813 | } |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 814 | /* Q: how many bytes would a write() call actually succeed in writing |
| 815 | * if it happened now? |
| 816 | * A: one QT2_FIFO_DEPTH, less the number of bytes waiting to be sent |
| 817 | * out of the port, unless this is more than the size of the |
| 818 | * write_urb output buffer less the header, which is the maximum |
| 819 | * size write we can do. |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 820 | |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 821 | * Most of the implementation of this is done when writes to the device |
| 822 | * are started or terminate. When we send a write to the device, we |
| 823 | * reduce the free space count by the size of the dispatched write. |
| 824 | * When a "transmit empty" message comes back up the USB read stream, |
| 825 | * we decrement the count by the number of bytes reported sent, thus |
| 826 | * keeping track of the difference between sent and recieved bytes. |
| 827 | */ |
| 828 | |
| 829 | room = (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes); |
| 830 | /* space in FIFO */ |
| 831 | if (room > port->bulk_out_size - QT2_TX_HEADER_LENGTH) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 832 | room = port->bulk_out_size - QT2_TX_HEADER_LENGTH; |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 833 | /* if more than the URB can hold, then cap to that limit */ |
| 834 | |
| 835 | dbg("%s(): port %d: write room is %d", __func__, port->number, room); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 836 | return room; |
| 837 | } |
| 838 | |
| 839 | static int qt2_chars_in_buffer(struct tty_struct *tty) |
| 840 | { |
| 841 | struct usb_serial_port *port = tty->driver_data; |
| 842 | /* parent usb_serial_port pointer */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 843 | struct quatech2_port *port_extra; /* extra data for this port */ |
| 844 | port_extra = qt2_get_port_private(port); |
| 845 | |
Richard Ash | 2feb633 | 2009-08-17 10:43:49 +0100 | [diff] [blame] | 846 | dbg("%s(): port %d: chars_in_buffer = %d", __func__, |
| 847 | port->number, port_extra->tx_pending_bytes); |
| 848 | return port_extra->tx_pending_bytes; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 849 | } |
| 850 | |
Richard Ash | dbe2481 | 2009-08-17 10:39:58 +0100 | [diff] [blame] | 851 | /* called when userspace does an ioctl() on the device. Note that |
| 852 | * TIOCMGET and TIOCMSET are filtered off to their own methods before they get |
| 853 | * here, so we don't have to handle them. |
| 854 | */ |
Alan Cox | 00a0d0d | 2011-02-14 16:27:06 +0000 | [diff] [blame^] | 855 | static int qt2_ioctl(struct tty_struct *tty, |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 856 | unsigned int cmd, unsigned long arg) |
| 857 | { |
| 858 | struct usb_serial_port *port = tty->driver_data; |
| 859 | struct usb_serial *serial = port->serial; |
| 860 | __u8 mcr_value; /* Modem Control Register value */ |
| 861 | __u8 msr_value; /* Modem Status Register value */ |
| 862 | unsigned short prev_msr_value; /* Previous value of Modem Status |
| 863 | * Register used to implement waiting for a line status change to |
| 864 | * occur */ |
| 865 | struct quatech2_port *port_extra; /* extra data for this port */ |
| 866 | DECLARE_WAITQUEUE(wait, current); |
| 867 | /* Declare a wait queue named "wait" */ |
| 868 | |
| 869 | unsigned int value; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 870 | unsigned int UartNumber; |
| 871 | |
| 872 | if (serial == NULL) |
| 873 | return -ENODEV; |
| 874 | UartNumber = tty->index - serial->minor; |
| 875 | port_extra = qt2_get_port_private(port); |
| 876 | |
| 877 | dbg("%s(): port %d, UartNumber %d, tty =0x%p", __func__, |
| 878 | port->number, UartNumber, tty); |
| 879 | |
Richard Ash | dbe2481 | 2009-08-17 10:39:58 +0100 | [diff] [blame] | 880 | if (cmd == TIOCMBIS || cmd == TIOCMBIC) { |
| 881 | if (qt2_box_get_register(port->serial, UartNumber, |
| 882 | QT2_MODEM_CONTROL_REGISTER, &mcr_value) < 0) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 883 | return -ESPIPE; |
| 884 | if (copy_from_user(&value, (unsigned int *)arg, |
Richard Ash | dbe2481 | 2009-08-17 10:39:58 +0100 | [diff] [blame] | 885 | sizeof(value))) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 886 | return -EFAULT; |
| 887 | |
| 888 | switch (cmd) { |
| 889 | case TIOCMBIS: |
| 890 | if (value & TIOCM_RTS) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 891 | mcr_value |= QT2_SERIAL_MCR_RTS; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 892 | if (value & TIOCM_DTR) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 893 | mcr_value |= QT2_SERIAL_MCR_DTR; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 894 | if (value & TIOCM_LOOP) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 895 | mcr_value |= QT2_SERIAL_MCR_LOOP; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 896 | break; |
| 897 | case TIOCMBIC: |
| 898 | if (value & TIOCM_RTS) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 899 | mcr_value &= ~QT2_SERIAL_MCR_RTS; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 900 | if (value & TIOCM_DTR) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 901 | mcr_value &= ~QT2_SERIAL_MCR_DTR; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 902 | if (value & TIOCM_LOOP) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 903 | mcr_value &= ~QT2_SERIAL_MCR_LOOP; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 904 | break; |
| 905 | default: |
| 906 | break; |
| 907 | } /* end of local switch on cmd */ |
Richard Ash | dbe2481 | 2009-08-17 10:39:58 +0100 | [diff] [blame] | 908 | if (qt2_box_set_register(port->serial, UartNumber, |
| 909 | QT2_MODEM_CONTROL_REGISTER, mcr_value) < 0) { |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 910 | return -ESPIPE; |
| 911 | } else { |
| 912 | port_extra->shadowMCR = mcr_value; |
| 913 | return 0; |
| 914 | } |
| 915 | } else if (cmd == TIOCMIWAIT) { |
| 916 | dbg("%s() port %d, cmd == TIOCMIWAIT enter", |
| 917 | __func__, port->number); |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 918 | prev_msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 919 | while (1) { |
| 920 | add_wait_queue(&port_extra->wait, &wait); |
| 921 | set_current_state(TASK_INTERRUPTIBLE); |
| 922 | schedule(); |
| 923 | dbg("%s(): port %d, cmd == TIOCMIWAIT here\n", |
| 924 | __func__, port->number); |
| 925 | remove_wait_queue(&port_extra->wait, &wait); |
| 926 | /* see if a signal woke us up */ |
| 927 | if (signal_pending(current)) |
| 928 | return -ERESTARTSYS; |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 929 | msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 930 | if (msr_value == prev_msr_value) |
| 931 | return -EIO; /* no change - error */ |
| 932 | if ((arg & TIOCM_RNG && |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 933 | ((prev_msr_value & QT2_SERIAL_MSR_RI) == |
| 934 | (msr_value & QT2_SERIAL_MSR_RI))) || |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 935 | (arg & TIOCM_DSR && |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 936 | ((prev_msr_value & QT2_SERIAL_MSR_DSR) == |
| 937 | (msr_value & QT2_SERIAL_MSR_DSR))) || |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 938 | (arg & TIOCM_CD && |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 939 | ((prev_msr_value & QT2_SERIAL_MSR_CD) == |
| 940 | (msr_value & QT2_SERIAL_MSR_CD))) || |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 941 | (arg & TIOCM_CTS && |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 942 | ((prev_msr_value & QT2_SERIAL_MSR_CTS) == |
| 943 | (msr_value & QT2_SERIAL_MSR_CTS)))) { |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 944 | return 0; |
| 945 | } |
| 946 | } /* end inifinite while */ |
Richard Ash | dbe2481 | 2009-08-17 10:39:58 +0100 | [diff] [blame] | 947 | /* FIXME: This while loop needs a way to break out if the device |
| 948 | * is disconnected while a process is waiting for the MSR to |
| 949 | * change, because once it's disconnected, it isn't going to |
| 950 | * change state ... */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 951 | } else { |
| 952 | /* any other ioctls we don't know about come here */ |
| 953 | dbg("%s(): No ioctl for that one. port = %d", __func__, |
| 954 | port->number); |
| 955 | return -ENOIOCTLCMD; |
| 956 | } |
| 957 | } |
| 958 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 959 | /* Called when the user wishes to change the port settings using the termios |
| 960 | * userspace interface */ |
| 961 | static void qt2_set_termios(struct tty_struct *tty, |
| 962 | struct usb_serial_port *port, struct ktermios *old_termios) |
| 963 | { |
| 964 | struct usb_serial *serial; /* parent serial device */ |
| 965 | int baud, divisor, remainder; |
| 966 | unsigned char LCR_change_to = 0; |
| 967 | int status; |
| 968 | __u16 UartNumber; |
| 969 | |
| 970 | dbg("%s(): port %d", __func__, port->number); |
| 971 | |
| 972 | serial = port->serial; |
| 973 | |
| 974 | UartNumber = port->number; |
| 975 | |
Richard Ash | 560a9be | 2009-08-20 11:25:12 +0100 | [diff] [blame] | 976 | if (old_termios && !tty_termios_hw_change(old_termios, tty->termios)) |
| 977 | return; |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 978 | |
| 979 | switch (tty->termios->c_cflag) { |
| 980 | case CS5: |
| 981 | LCR_change_to |= QT2_SERIAL_5_DATA; |
| 982 | break; |
| 983 | case CS6: |
| 984 | LCR_change_to |= QT2_SERIAL_6_DATA; |
| 985 | break; |
| 986 | case CS7: |
| 987 | LCR_change_to |= QT2_SERIAL_7_DATA; |
| 988 | break; |
| 989 | default: |
| 990 | case CS8: |
| 991 | LCR_change_to |= QT2_SERIAL_8_DATA; |
| 992 | break; |
| 993 | } |
| 994 | |
| 995 | /* Parity stuff */ |
| 996 | if (tty->termios->c_cflag & PARENB) { |
| 997 | if (tty->termios->c_cflag & PARODD) |
| 998 | LCR_change_to |= QT2_SERIAL_ODD_PARITY; |
| 999 | else |
| 1000 | LCR_change_to |= QT2_SERIAL_EVEN_PARITY; |
| 1001 | } |
Richard Ash | 560a9be | 2009-08-20 11:25:12 +0100 | [diff] [blame] | 1002 | /* Because LCR_change_to is initialised to zero, we don't have to worry |
| 1003 | * about the case where PARENB is not set or clearing bits, because by |
| 1004 | * default all of them are cleared, turning parity off. |
| 1005 | * as we don't support mark/space parity, we should clear the |
| 1006 | * mark/space parity bit in c_cflag, so the caller can tell we have |
| 1007 | * ignored the request */ |
| 1008 | tty->termios->c_cflag &= ~CMSPAR; |
| 1009 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1010 | if (tty->termios->c_cflag & CSTOPB) |
| 1011 | LCR_change_to |= QT2_SERIAL_TWO_STOPB; |
| 1012 | else |
| 1013 | LCR_change_to |= QT2_SERIAL_ONE_STOPB; |
| 1014 | |
Richard Ash | 560a9be | 2009-08-20 11:25:12 +0100 | [diff] [blame] | 1015 | /* Thats the LCR stuff, next we need to work out the divisor as the |
| 1016 | * LCR and the divisor are set together */ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1017 | baud = tty_get_baud_rate(tty); |
| 1018 | if (!baud) { |
| 1019 | /* pick a default, any default... */ |
| 1020 | baud = 9600; |
| 1021 | } |
| 1022 | dbg("%s(): got baud = %d", __func__, baud); |
| 1023 | |
| 1024 | divisor = QT2_MAX_BAUD_RATE / baud; |
| 1025 | remainder = QT2_MAX_BAUD_RATE % baud; |
| 1026 | /* Round to nearest divisor */ |
| 1027 | if (((remainder * 2) >= baud) && (baud != 110)) |
| 1028 | divisor++; |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1029 | dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = %#.2x", |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1030 | __func__, divisor, QT2_MAX_BAUD_RATE, LCR_change_to); |
| 1031 | |
| 1032 | status = qt2_boxsetuart(serial, UartNumber, (unsigned short) divisor, |
| 1033 | LCR_change_to); |
| 1034 | if (status < 0) { |
| 1035 | dbg("qt2_boxsetuart() failed"); |
| 1036 | return; |
Richard Ash | 560a9be | 2009-08-20 11:25:12 +0100 | [diff] [blame] | 1037 | } else { |
| 1038 | /* now encode the baud rate we actually set, which may be |
| 1039 | * different to the request */ |
| 1040 | baud = QT2_MAX_BAUD_RATE / divisor; |
| 1041 | tty_encode_baud_rate(tty, baud, baud); |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1042 | } |
| 1043 | |
| 1044 | /* Now determine flow control */ |
| 1045 | if (tty->termios->c_cflag & CRTSCTS) { |
| 1046 | dbg("%s(): Enabling HW flow control port %d", __func__, |
| 1047 | port->number); |
| 1048 | /* Enable RTS/CTS flow control */ |
| 1049 | status = qt2_boxsethw_flowctl(serial, UartNumber, true); |
| 1050 | if (status < 0) { |
| 1051 | dbg("qt2_boxsethw_flowctl() failed"); |
| 1052 | return; |
| 1053 | } |
| 1054 | } else { |
| 1055 | /* Disable RTS/CTS flow control */ |
| 1056 | dbg("%s(): disabling HW flow control port %d", __func__, |
| 1057 | port->number); |
| 1058 | status = qt2_boxsethw_flowctl(serial, UartNumber, false); |
| 1059 | if (status < 0) { |
| 1060 | dbg("qt2_boxsethw_flowctl failed"); |
| 1061 | return; |
| 1062 | } |
| 1063 | } |
| 1064 | /* if we are implementing XON/XOFF, set the start and stop character |
| 1065 | * in the device */ |
| 1066 | if (I_IXOFF(tty) || I_IXON(tty)) { |
| 1067 | unsigned char stop_char = STOP_CHAR(tty); |
| 1068 | unsigned char start_char = START_CHAR(tty); |
| 1069 | status = qt2_boxsetsw_flowctl(serial, UartNumber, stop_char, |
| 1070 | start_char); |
| 1071 | if (status < 0) |
| 1072 | dbg("qt2_boxsetsw_flowctl (enabled) failed"); |
| 1073 | } else { |
| 1074 | /* disable SW flow control */ |
| 1075 | status = qt2_boxunsetsw_flowctl(serial, UartNumber); |
| 1076 | if (status < 0) |
| 1077 | dbg("qt2_boxunsetsw_flowctl (disabling) failed"); |
| 1078 | } |
| 1079 | } |
| 1080 | |
Alan Cox | 60b33c1 | 2011-02-14 16:26:14 +0000 | [diff] [blame] | 1081 | static int qt2_tiocmget(struct tty_struct *tty) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1082 | { |
| 1083 | struct usb_serial_port *port = tty->driver_data; |
| 1084 | struct usb_serial *serial = port->serial; |
| 1085 | |
| 1086 | __u8 mcr_value; /* Modem Control Register value */ |
| 1087 | __u8 msr_value; /* Modem Status Register value */ |
| 1088 | unsigned int result = 0; |
| 1089 | int status; |
| 1090 | unsigned int UartNumber; |
| 1091 | |
| 1092 | if (serial == NULL) |
| 1093 | return -ENODEV; |
| 1094 | |
| 1095 | dbg("%s(): port %d, tty =0x%p", __func__, port->number, tty); |
| 1096 | UartNumber = tty->index - serial->minor; |
| 1097 | dbg("UartNumber is %d", UartNumber); |
| 1098 | |
| 1099 | status = qt2_box_get_register(port->serial, UartNumber, |
| 1100 | QT2_MODEM_CONTROL_REGISTER, &mcr_value); |
| 1101 | if (status >= 0) { |
| 1102 | status = qt2_box_get_register(port->serial, UartNumber, |
| 1103 | QT2_MODEM_STATUS_REGISTER, &msr_value); |
| 1104 | } |
| 1105 | if (status >= 0) { |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1106 | result = ((mcr_value & QT2_SERIAL_MCR_DTR) ? TIOCM_DTR : 0) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1107 | /*DTR set */ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1108 | | ((mcr_value & QT2_SERIAL_MCR_RTS) ? TIOCM_RTS : 0) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1109 | /*RTS set */ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1110 | | ((msr_value & QT2_SERIAL_MSR_CTS) ? TIOCM_CTS : 0) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1111 | /* CTS set */ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1112 | | ((msr_value & QT2_SERIAL_MSR_CD) ? TIOCM_CAR : 0) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1113 | /*Carrier detect set */ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1114 | | ((msr_value & QT2_SERIAL_MSR_RI) ? TIOCM_RI : 0) |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1115 | /* Ring indicator set */ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1116 | | ((msr_value & QT2_SERIAL_MSR_DSR) ? TIOCM_DSR : 0); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1117 | /* DSR set */ |
| 1118 | return result; |
| 1119 | } else { |
| 1120 | return -ESPIPE; |
| 1121 | } |
| 1122 | } |
| 1123 | |
Alan Cox | 20b9d17 | 2011-02-14 16:26:50 +0000 | [diff] [blame] | 1124 | static int qt2_tiocmset(struct tty_struct *tty, |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1125 | unsigned int set, unsigned int clear) |
| 1126 | { |
| 1127 | struct usb_serial_port *port = tty->driver_data; |
| 1128 | struct usb_serial *serial = port->serial; |
| 1129 | __u8 mcr_value; /* Modem Control Register value */ |
| 1130 | int status; |
| 1131 | unsigned int UartNumber; |
| 1132 | |
| 1133 | if (serial == NULL) |
| 1134 | return -ENODEV; |
| 1135 | |
| 1136 | UartNumber = tty->index - serial->minor; |
| 1137 | dbg("%s(): port %d, UartNumber %d", __func__, port->number, UartNumber); |
| 1138 | |
| 1139 | status = qt2_box_get_register(port->serial, UartNumber, |
| 1140 | QT2_MODEM_CONTROL_REGISTER, &mcr_value); |
| 1141 | if (status < 0) |
| 1142 | return -ESPIPE; |
| 1143 | |
| 1144 | /* Turn off RTS, DTR and loopback, then only turn on what was asked |
| 1145 | * for */ |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1146 | mcr_value &= ~(QT2_SERIAL_MCR_RTS | QT2_SERIAL_MCR_DTR | |
| 1147 | QT2_SERIAL_MCR_LOOP); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1148 | if (set & TIOCM_RTS) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1149 | mcr_value |= QT2_SERIAL_MCR_RTS; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1150 | if (set & TIOCM_DTR) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1151 | mcr_value |= QT2_SERIAL_MCR_DTR; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1152 | if (set & TIOCM_LOOP) |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1153 | mcr_value |= QT2_SERIAL_MCR_LOOP; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1154 | |
| 1155 | status = qt2_box_set_register(port->serial, UartNumber, |
| 1156 | QT2_MODEM_CONTROL_REGISTER, mcr_value); |
| 1157 | if (status < 0) |
| 1158 | return -ESPIPE; |
| 1159 | else |
| 1160 | return 0; |
| 1161 | } |
| 1162 | |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1163 | /** qt2_break - Turn BREAK on and off on the UARTs |
| 1164 | */ |
| 1165 | static void qt2_break(struct tty_struct *tty, int break_state) |
| 1166 | { |
| 1167 | struct usb_serial_port *port = tty->driver_data; /* parent port */ |
| 1168 | struct usb_serial *serial = port->serial; /* parent device */ |
| 1169 | struct quatech2_port *port_extra; /* extra data for this port */ |
| 1170 | __u16 break_value; |
| 1171 | unsigned int result; |
| 1172 | |
| 1173 | port_extra = qt2_get_port_private(port); |
| 1174 | if (!serial) { |
| 1175 | dbg("%s(): port %d: no serial object", __func__, port->number); |
| 1176 | return; |
| 1177 | } |
| 1178 | |
| 1179 | if (break_state == -1) |
| 1180 | break_value = 1; |
| 1181 | else |
| 1182 | break_value = 0; |
| 1183 | dbg("%s(): port %d, break_value %d", __func__, port->number, |
| 1184 | break_value); |
| 1185 | |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1186 | mutex_lock(&port_extra->modelock); |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1187 | if (!port_extra->open_count) { |
| 1188 | dbg("%s(): port not open", __func__); |
| 1189 | goto exit; |
| 1190 | } |
| 1191 | |
| 1192 | result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 1193 | QT2_BREAK_CONTROL, 0x40, break_value, |
| 1194 | port->number, NULL, 0, 300); |
| 1195 | exit: |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1196 | mutex_unlock(&port_extra->modelock); |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1197 | dbg("%s(): exit port %d", __func__, port->number); |
| 1198 | |
| 1199 | } |
| 1200 | /** |
| 1201 | * qt2_throttle: - stop reading new data from the port |
| 1202 | */ |
| 1203 | static void qt2_throttle(struct tty_struct *tty) |
| 1204 | { |
| 1205 | struct usb_serial_port *port = tty->driver_data; |
| 1206 | struct usb_serial *serial = port->serial; |
| 1207 | struct quatech2_port *port_extra; /* extra data for this port */ |
| 1208 | dbg("%s(): port %d", __func__, port->number); |
| 1209 | |
| 1210 | port_extra = qt2_get_port_private(port); |
| 1211 | if (!serial) { |
| 1212 | dbg("%s(): enter port %d no serial object", __func__, |
| 1213 | port->number); |
| 1214 | return; |
| 1215 | } |
| 1216 | |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1217 | mutex_lock(&port_extra->modelock); /* lock structure */ |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1218 | if (!port_extra->open_count) { |
| 1219 | dbg("%s(): port not open", __func__); |
| 1220 | goto exit; |
| 1221 | } |
| 1222 | /* Send command to box to stop receiving stuff. This will stop this |
| 1223 | * particular UART from filling the endpoint - in the multiport case the |
| 1224 | * FPGA UART will handle any flow control implmented, but for the single |
| 1225 | * port it's handed differently and we just quit submitting urbs |
| 1226 | */ |
| 1227 | if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) |
| 1228 | qt2_boxstoprx(serial, port->number, 1); |
| 1229 | |
| 1230 | port->throttled = 1; |
| 1231 | exit: |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1232 | mutex_unlock(&port_extra->modelock); |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1233 | dbg("%s(): port %d: setting port->throttled", __func__, port->number); |
| 1234 | return; |
| 1235 | } |
| 1236 | |
| 1237 | /** |
| 1238 | * qt2_unthrottle: - start receiving data through the port again after being |
| 1239 | * throttled |
| 1240 | */ |
| 1241 | static void qt2_unthrottle(struct tty_struct *tty) |
| 1242 | { |
| 1243 | struct usb_serial_port *port = tty->driver_data; |
| 1244 | struct usb_serial *serial = port->serial; |
| 1245 | struct quatech2_port *port_extra; /* extra data for this port */ |
| 1246 | struct usb_serial_port *port0; /* first port structure on device */ |
| 1247 | struct quatech2_dev *dev_extra; /* extra data for the device */ |
| 1248 | |
| 1249 | if (!serial) { |
| 1250 | dbg("%s() enter port %d no serial object!", __func__, |
| 1251 | port->number); |
| 1252 | return; |
| 1253 | } |
| 1254 | dbg("%s(): enter port %d", __func__, port->number); |
| 1255 | dev_extra = qt2_get_dev_private(serial); |
| 1256 | port_extra = qt2_get_port_private(port); |
| 1257 | port0 = serial->port[0]; /* get the first port's device structure */ |
| 1258 | |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1259 | mutex_lock(&port_extra->modelock); |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1260 | if (!port_extra->open_count) { |
| 1261 | dbg("%s(): port %d not open", __func__, port->number); |
| 1262 | goto exit; |
| 1263 | } |
| 1264 | |
| 1265 | if (port->throttled != 0) { |
| 1266 | dbg("%s(): port %d: unsetting port->throttled", __func__, |
| 1267 | port->number); |
| 1268 | port->throttled = 0; |
| 1269 | /* Send command to box to start receiving stuff */ |
| 1270 | if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) { |
| 1271 | qt2_boxstoprx(serial, port->number, 0); |
| 1272 | } else if (dev_extra->ReadBulkStopped == true) { |
| 1273 | usb_fill_bulk_urb(port0->read_urb, serial->dev, |
| 1274 | usb_rcvbulkpipe(serial->dev, |
| 1275 | port0->bulk_in_endpointAddress), |
| 1276 | port0->bulk_in_buffer, |
| 1277 | port0->bulk_in_size, |
| 1278 | qt2_read_bulk_callback, |
| 1279 | serial); |
| 1280 | } |
| 1281 | } |
| 1282 | exit: |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1283 | mutex_unlock(&port_extra->modelock); |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1284 | dbg("%s(): exit port %d", __func__, port->number); |
| 1285 | return; |
| 1286 | } |
| 1287 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1288 | /* internal, private helper functions for the driver */ |
| 1289 | |
| 1290 | /* Power up the FPGA in the box to get it working */ |
| 1291 | static int qt2_boxpoweron(struct usb_serial *serial) |
| 1292 | { |
| 1293 | int result; |
| 1294 | __u8 Direcion; |
| 1295 | unsigned int pipe; |
| 1296 | Direcion = USBD_TRANSFER_DIRECTION_OUT; |
| 1297 | pipe = usb_rcvctrlpipe(serial->dev, 0); |
| 1298 | result = usb_control_msg(serial->dev, pipe, QT_SET_GET_DEVICE, |
| 1299 | Direcion, QU2BOXPWRON, 0x00, NULL, 0x00, |
| 1300 | 5000); |
| 1301 | return result; |
| 1302 | } |
| 1303 | |
| 1304 | /* |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1305 | * qt2_boxsetQMCR Issue a QT2_GET_SET_QMCR vendor-spcific request on the |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1306 | * default control pipe. If successful return the number of bytes written, |
| 1307 | * otherwise return a negative error number of the problem. |
| 1308 | */ |
| 1309 | static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number, |
| 1310 | __u8 QMCR_Value) |
| 1311 | { |
| 1312 | int result; |
| 1313 | __u16 PortSettings; |
| 1314 | |
| 1315 | PortSettings = (__u16)(QMCR_Value); |
| 1316 | |
| 1317 | dbg("%s(): Port = %d, PortSettings = 0x%x", __func__, |
| 1318 | Uart_Number, PortSettings); |
| 1319 | |
| 1320 | result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1321 | QT2_GET_SET_QMCR, 0x40, PortSettings, |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1322 | (__u16)Uart_Number, NULL, 0, 5000); |
| 1323 | return result; |
| 1324 | } |
| 1325 | |
| 1326 | static int port_paranoia_check(struct usb_serial_port *port, |
| 1327 | const char *function) |
| 1328 | { |
| 1329 | if (!port) { |
| 1330 | dbg("%s - port == NULL", function); |
| 1331 | return -1; |
| 1332 | } |
| 1333 | if (!port->serial) { |
| 1334 | dbg("%s - port->serial == NULL\n", function); |
| 1335 | return -1; |
| 1336 | } |
| 1337 | return 0; |
| 1338 | } |
| 1339 | |
| 1340 | static int serial_paranoia_check(struct usb_serial *serial, |
| 1341 | const char *function) |
| 1342 | { |
| 1343 | if (!serial) { |
| 1344 | dbg("%s - serial == NULL\n", function); |
| 1345 | return -1; |
| 1346 | } |
| 1347 | |
| 1348 | if (!serial->type) { |
| 1349 | dbg("%s - serial->type == NULL!", function); |
| 1350 | return -1; |
| 1351 | } |
| 1352 | |
| 1353 | return 0; |
| 1354 | } |
| 1355 | |
| 1356 | static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port |
| 1357 | *port) |
| 1358 | { |
| 1359 | return (struct quatech2_port *)usb_get_serial_port_data(port); |
| 1360 | } |
| 1361 | |
| 1362 | static inline void qt2_set_port_private(struct usb_serial_port *port, |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1363 | struct quatech2_port *data) |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1364 | { |
| 1365 | usb_set_serial_port_data(port, (void *)data); |
| 1366 | } |
| 1367 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1368 | static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial |
| 1369 | *serial) |
| 1370 | { |
| 1371 | return (struct quatech2_dev *)usb_get_serial_data(serial); |
| 1372 | } |
| 1373 | static inline void qt2_set_dev_private(struct usb_serial *serial, |
| 1374 | struct quatech2_dev *data) |
| 1375 | { |
| 1376 | usb_set_serial_data(serial, (void *)data); |
| 1377 | } |
| 1378 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1379 | static int qt2_openboxchannel(struct usb_serial *serial, __u16 |
| 1380 | Uart_Number, struct qt2_status_data *status) |
| 1381 | { |
| 1382 | int result; |
| 1383 | __u16 length; |
| 1384 | __u8 Direcion; |
| 1385 | unsigned int pipe; |
| 1386 | length = sizeof(struct qt2_status_data); |
| 1387 | Direcion = USBD_TRANSFER_DIRECTION_IN; |
| 1388 | pipe = usb_rcvctrlpipe(serial->dev, 0); |
| 1389 | result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL, |
| 1390 | Direcion, 0x00, Uart_Number, status, length, 5000); |
| 1391 | return result; |
| 1392 | } |
| 1393 | static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number) |
| 1394 | { |
| 1395 | int result; |
| 1396 | __u8 direcion; |
| 1397 | unsigned int pipe; |
| 1398 | direcion = USBD_TRANSFER_DIRECTION_OUT; |
| 1399 | pipe = usb_sndctrlpipe(serial->dev, 0); |
| 1400 | result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL, |
| 1401 | direcion, 0, Uart_Number, NULL, 0, 5000); |
| 1402 | return result; |
| 1403 | } |
| 1404 | |
| 1405 | /* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default |
| 1406 | * control pipe. If successful sets baud rate divisor and LCR value |
| 1407 | */ |
| 1408 | static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, |
| 1409 | unsigned short divisor, unsigned char LCR) |
| 1410 | { |
| 1411 | int result; |
| 1412 | unsigned short UartNumandLCR; |
| 1413 | |
| 1414 | UartNumandLCR = (LCR << 8) + Uart_Number; |
| 1415 | |
| 1416 | result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1417 | QT2_GET_SET_UART, 0x40, divisor, UartNumandLCR, |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1418 | NULL, 0, 300); |
| 1419 | return result; |
| 1420 | } |
| 1421 | |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1422 | /** @brief Callback for asynchronous submission of read URBs on bulk in |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1423 | * endpoints |
| 1424 | * |
| 1425 | * Registered in qt2_open_port(), used to deal with incomming data |
| 1426 | * from the box. |
| 1427 | */ |
| 1428 | static void qt2_read_bulk_callback(struct urb *urb) |
| 1429 | { |
| 1430 | /* Get the device pointer (struct usb_serial) back out of the URB */ |
| 1431 | struct usb_serial *serial = urb->context; |
| 1432 | /* get the extra struct for the device */ |
| 1433 | struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); |
| 1434 | /* Get first port structure from the device */ |
| 1435 | struct usb_serial_port *port0 = serial->port[0]; |
| 1436 | /* Get the currently active port structure from serial struct */ |
| 1437 | struct usb_serial_port *active = dev_extra->current_port; |
| 1438 | /* get the extra struct for port 0 */ |
| 1439 | struct quatech2_port *port0_extra = qt2_get_port_private(port0); |
| 1440 | /* and for the currently active port */ |
| 1441 | struct quatech2_port *active_extra = qt2_get_port_private(active); |
| 1442 | /* When we finally get to doing some tty stuff, we will need this */ |
| 1443 | struct tty_struct *tty_st; |
| 1444 | unsigned int RxCount; /* the length of the data to process */ |
| 1445 | unsigned int i; /* loop counter over the data to process */ |
| 1446 | int result; /* return value cache variable */ |
| 1447 | bool escapeflag; /* flag set to true if this loop iteration is |
| 1448 | * parsing an escape sequence, rather than |
| 1449 | * ordinary data */ |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1450 | dbg("%s(): callback running, active port is %d", __func__, |
| 1451 | active->number); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1452 | |
| 1453 | if (urb->status) { |
| 1454 | /* read didn't go well */ |
| 1455 | dev_extra->ReadBulkStopped = true; |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1456 | dbg("%s(): nonzero bulk read status received: %d", |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1457 | __func__, urb->status); |
| 1458 | return; |
| 1459 | } |
| 1460 | |
| 1461 | /* inline port_sofrint() here */ |
| 1462 | if (port_paranoia_check(port0, __func__) != 0) { |
| 1463 | dbg("%s - port_paranoia_check on port0 failed, exiting\n", |
| 1464 | __func__); |
| 1465 | return; |
| 1466 | } |
| 1467 | if (port_paranoia_check(active, __func__) != 0) { |
| 1468 | dbg("%s - port_paranoia_check on current_port " |
| 1469 | "failed, exiting", __func__); |
| 1470 | return; |
| 1471 | } |
| 1472 | |
| 1473 | /* This single callback function has to do for all the ports on |
| 1474 | * the device. Data being read up the USB can contain certain |
| 1475 | * escape sequences which are used to communicate out-of-band |
| 1476 | * information from the serial port in-band over the USB. |
| 1477 | * These escapes include sending modem and flow control line |
| 1478 | * status, and switching the port. The concept of a "Current Port" |
| 1479 | * is used, which is where data is going until a port change |
| 1480 | * escape seqence is received. This Current Port is kept between |
| 1481 | * callbacks so that when this function enters we know which the |
| 1482 | * currently active port is and can get to work right away without |
| 1483 | * the box having to send repeat escape sequences (anyway, how |
| 1484 | * would it know to do so?). |
| 1485 | */ |
| 1486 | |
| 1487 | if (active_extra->close_pending == true) { |
| 1488 | /* We are closing , stop reading */ |
| 1489 | dbg("%s - (active->close_pending == true", __func__); |
| 1490 | if (dev_extra->open_ports <= 0) { |
| 1491 | /* If this is the only port left open - stop the |
| 1492 | * bulk read */ |
| 1493 | dev_extra->ReadBulkStopped = true; |
| 1494 | dbg("%s - (ReadBulkStopped == true;", __func__); |
| 1495 | return; |
| 1496 | } |
| 1497 | } |
| 1498 | |
| 1499 | /* |
| 1500 | * RxHolding is asserted by throttle, if we assert it, we're not |
| 1501 | * receiving any more characters and let the box handle the flow |
| 1502 | * control |
| 1503 | */ |
| 1504 | if ((port0_extra->RxHolding == true) && |
| 1505 | (serial->dev->descriptor.idProduct == QUATECH_SSU2_100)) { |
| 1506 | /* single port device, input is already stopped, so we don't |
| 1507 | * need any more input data */ |
| 1508 | dev_extra->ReadBulkStopped = true; |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1509 | return; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1510 | } |
| 1511 | /* finally, we are in a situation where we might consider the data |
| 1512 | * that is contained within the URB, and what to do about it. |
| 1513 | * This is likely to involved communicating up to the TTY layer, so |
| 1514 | * we will need to get hold of the tty for the port we are currently |
| 1515 | * dealing with */ |
| 1516 | |
| 1517 | /* active is a usb_serial_port. It has a member port which is a |
| 1518 | * tty_port. From this we get a tty_struct pointer which is what we |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1519 | * actually wanted, and keep it on tty_st */ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1520 | tty_st = tty_port_tty_get(&active->port); |
| 1521 | if (!tty_st) { |
| 1522 | dbg("%s - bad tty pointer - exiting", __func__); |
| 1523 | return; |
| 1524 | } |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1525 | RxCount = urb->actual_length; /* grab length of data handy */ |
| 1526 | |
| 1527 | if (RxCount) { |
| 1528 | /* skip all this if no data to process */ |
| 1529 | for (i = 0; i < RxCount ; ++i) { |
| 1530 | /* Look ahead code here -works on several bytes at onc*/ |
| 1531 | if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b) |
| 1532 | && (NEXTCHAR == 0x1b)) { |
| 1533 | /* we are in an escape sequence, type |
| 1534 | * determined by the 3rd char */ |
| 1535 | escapeflag = false; |
| 1536 | switch (THIRDCHAR) { |
| 1537 | case 0x00: |
| 1538 | /* Line status change 4th byte must |
| 1539 | * follow */ |
| 1540 | if (i > (RxCount - 4)) { |
| 1541 | dbg("Illegal escape sequences " |
| 1542 | "in received data"); |
| 1543 | break; |
| 1544 | } |
| 1545 | qt2_process_line_status(active, |
| 1546 | FOURTHCHAR); |
| 1547 | i += 3; |
| 1548 | escapeflag = true; |
| 1549 | break; |
| 1550 | case 0x01: |
| 1551 | /* Modem status status change 4th byte |
| 1552 | * must follow */ |
| 1553 | if (i > (RxCount - 4)) { |
| 1554 | dbg("Illegal escape sequences " |
| 1555 | "in received data"); |
| 1556 | break; |
| 1557 | } |
| 1558 | qt2_process_modem_status(active, |
| 1559 | FOURTHCHAR); |
| 1560 | i += 3; |
| 1561 | escapeflag = true; |
| 1562 | break; |
| 1563 | case 0x02: |
| 1564 | /* xmit hold empty 4th byte |
| 1565 | * must follow */ |
| 1566 | if (i > (RxCount - 4)) { |
| 1567 | dbg("Illegal escape sequences " |
| 1568 | "in received data"); |
| 1569 | break; |
| 1570 | } |
| 1571 | qt2_process_xmit_empty(active, |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 1572 | FOURTHCHAR, FIFTHCHAR); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1573 | i += 4; |
| 1574 | escapeflag = true; |
| 1575 | break; |
| 1576 | case 0x03: |
| 1577 | /* Port number change 4th byte |
| 1578 | * must follow */ |
| 1579 | if (i > (RxCount - 4)) { |
| 1580 | dbg("Illegal escape sequences " |
| 1581 | "in received data"); |
| 1582 | break; |
| 1583 | } |
| 1584 | /* Port change. If port open push |
| 1585 | * current data up to tty layer */ |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1586 | if (active_extra->open_count > 0) |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1587 | tty_flip_buffer_push(tty_st); |
| 1588 | |
| 1589 | dbg("Port Change: new port = %d", |
| 1590 | FOURTHCHAR); |
| 1591 | qt2_process_port_change(active, |
| 1592 | FOURTHCHAR); |
| 1593 | i += 3; |
| 1594 | escapeflag = true; |
| 1595 | /* having changed port, the pointers for |
| 1596 | * the currently active port are all out |
| 1597 | * of date and need updating */ |
| 1598 | active = dev_extra->current_port; |
| 1599 | active_extra = |
| 1600 | qt2_get_port_private(active); |
| 1601 | tty_st = tty_port_tty_get( |
| 1602 | &active->port); |
| 1603 | break; |
| 1604 | case 0x04: |
| 1605 | /* Recv flush 3rd byte must |
| 1606 | * follow */ |
| 1607 | if (i > (RxCount - 3)) { |
| 1608 | dbg("Illegal escape sequences " |
| 1609 | "in received data"); |
| 1610 | break; |
| 1611 | } |
| 1612 | qt2_process_rcv_flush(active); |
| 1613 | i += 2; |
| 1614 | escapeflag = true; |
| 1615 | break; |
| 1616 | case 0x05: |
| 1617 | /* xmit flush 3rd byte must follow */ |
| 1618 | if (i > (RxCount - 3)) { |
| 1619 | dbg("Illegal escape sequences " |
| 1620 | "in received data"); |
| 1621 | break; |
| 1622 | } |
| 1623 | qt2_process_xmit_flush(active); |
| 1624 | i += 2; |
| 1625 | escapeflag = true; |
| 1626 | break; |
| 1627 | case 0xff: |
| 1628 | dbg("No status sequence"); |
| 1629 | qt2_process_rx_char(active, THISCHAR); |
| 1630 | qt2_process_rx_char(active, NEXTCHAR); |
| 1631 | i += 2; |
| 1632 | break; |
| 1633 | default: |
| 1634 | qt2_process_rx_char(active, THISCHAR); |
| 1635 | i += 1; |
| 1636 | break; |
| 1637 | } /*end switch*/ |
| 1638 | if (escapeflag == true) |
| 1639 | continue; |
| 1640 | /* if we did an escape char, we don't need |
| 1641 | * to mess around pushing data through the |
| 1642 | * tty layer, and can go round again */ |
| 1643 | } /*endif*/ |
| 1644 | if (tty_st && urb->actual_length) { |
| 1645 | tty_buffer_request_room(tty_st, 1); |
Soeren Moeller | 08db6c5 | 2010-03-30 20:11:12 +0000 | [diff] [blame] | 1646 | tty_insert_flip_string(tty_st, &( |
| 1647 | (unsigned char *) |
| 1648 | (urb->transfer_buffer) |
| 1649 | )[i], 1); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1650 | } |
| 1651 | } /*endfor*/ |
| 1652 | tty_flip_buffer_push(tty_st); |
| 1653 | } /*endif*/ |
| 1654 | |
| 1655 | /* at this point we have complete dealing with the data for this |
| 1656 | * callback. All we have to do now is to start the async read process |
| 1657 | * back off again. */ |
| 1658 | |
| 1659 | usb_fill_bulk_urb(port0->read_urb, serial->dev, |
| 1660 | usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress), |
| 1661 | port0->bulk_in_buffer, port0->bulk_in_size, |
| 1662 | qt2_read_bulk_callback, serial); |
| 1663 | result = usb_submit_urb(port0->read_urb, GFP_ATOMIC); |
| 1664 | if (result) { |
| 1665 | dbg("%s(): failed resubmitting read urb, error %d", |
| 1666 | __func__, result); |
| 1667 | } else { |
André Goddard Rosa | bbc9a99 | 2009-11-14 13:09:06 -0200 | [diff] [blame] | 1668 | dbg("%s() successfully resubmitted read urb", __func__); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1669 | if (tty_st && RxCount) { |
| 1670 | /* if some inbound data was processed, then |
| 1671 | * we need to push that through the tty layer |
| 1672 | */ |
| 1673 | tty_flip_buffer_push(tty_st); |
| 1674 | tty_schedule_flip(tty_st); |
| 1675 | } |
| 1676 | } |
| 1677 | |
| 1678 | /* cribbed from serqt_usb2 driver, but not sure which work needs |
| 1679 | * scheduling - port0 or currently active port? */ |
| 1680 | /* schedule_work(&port->work); */ |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1681 | dbg("%s() completed", __func__); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1682 | return; |
| 1683 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1684 | |
| 1685 | /** @brief Callback for asynchronous submission of write URBs on bulk in |
| 1686 | * endpoints |
| 1687 | * |
| 1688 | * Registered in qt2_write(), used to deal with outgoing data |
| 1689 | * to the box. |
| 1690 | */ |
| 1691 | static void qt2_write_bulk_callback(struct urb *urb) |
| 1692 | { |
| 1693 | struct usb_serial_port *port = (struct usb_serial_port *)urb->context; |
| 1694 | struct usb_serial *serial = port->serial; |
| 1695 | dbg("%s(): port %d", __func__, port->number); |
| 1696 | if (!serial) { |
| 1697 | dbg("%s(): bad serial pointer, exiting", __func__); |
| 1698 | return; |
| 1699 | } |
| 1700 | if (urb->status) { |
| 1701 | dbg("%s(): nonzero write bulk status received: %d", |
| 1702 | __func__, urb->status); |
| 1703 | return; |
| 1704 | } |
Richard Ash | eba1aad | 2009-08-20 11:24:59 +0100 | [diff] [blame] | 1705 | /* FIXME What is supposed to be going on here? |
| 1706 | * does this actually do anything useful, and should it? |
| 1707 | */ |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1708 | /*port_softint((void *) serial); commented in vendor driver */ |
| 1709 | schedule_work(&port->work); |
| 1710 | dbg("%s(): port %d exit", __func__, port->number); |
| 1711 | return; |
| 1712 | } |
| 1713 | |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1714 | static void qt2_process_line_status(struct usb_serial_port *port, |
| 1715 | unsigned char LineStatus) |
| 1716 | { |
| 1717 | /* obtain the private structure for the port */ |
| 1718 | struct quatech2_port *port_extra = qt2_get_port_private(port); |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1719 | port_extra->shadowLSR = LineStatus & (QT2_SERIAL_LSR_OE | |
| 1720 | QT2_SERIAL_LSR_PE | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI); |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1721 | } |
| 1722 | static void qt2_process_modem_status(struct usb_serial_port *port, |
| 1723 | unsigned char ModemStatus) |
| 1724 | { |
| 1725 | /* obtain the private structure for the port */ |
| 1726 | struct quatech2_port *port_extra = qt2_get_port_private(port); |
| 1727 | port_extra->shadowMSR = ModemStatus; |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1728 | wake_up_interruptible(&port_extra->wait); |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1729 | /* this wakes up the otherwise indefinitely waiting code for |
| 1730 | * the TIOCMIWAIT ioctl, so that it can notice that |
| 1731 | * port_extra->shadowMSR has changed and the ioctl needs to return. |
| 1732 | */ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1733 | } |
| 1734 | |
| 1735 | static void qt2_process_xmit_empty(struct usb_serial_port *port, |
| 1736 | unsigned char fourth_char, unsigned char fifth_char) |
| 1737 | { |
| 1738 | int byte_count; |
| 1739 | /* obtain the private structure for the port */ |
| 1740 | struct quatech2_port *port_extra = qt2_get_port_private(port); |
| 1741 | |
| 1742 | byte_count = (int)(fifth_char * 16); |
| 1743 | byte_count += (int)fourth_char; |
Richard Ash | 89b5098 | 2009-08-17 10:35:18 +0100 | [diff] [blame] | 1744 | /* byte_count indicates how many bytes the device has written out. This |
| 1745 | * message appears to occur regularly, and is used in the vendor driver |
| 1746 | * to keep track of the fill state of the port transmit buffer */ |
| 1747 | port_extra->tx_pending_bytes -= byte_count; |
| 1748 | /* reduce the stored data queue length by the known number of bytes |
| 1749 | * sent */ |
| 1750 | dbg("port %d: %d bytes reported sent, %d still pending", port->number, |
| 1751 | byte_count, port_extra->tx_pending_bytes); |
| 1752 | |
| 1753 | /*port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; ???*/ |
Richard Ash | 72ba94e | 2009-07-29 17:12:18 +0100 | [diff] [blame] | 1754 | } |
| 1755 | |
| 1756 | static void qt2_process_port_change(struct usb_serial_port *port, |
| 1757 | unsigned char New_Current_Port) |
| 1758 | { |
| 1759 | /* obtain the parent usb serial device structure */ |
| 1760 | struct usb_serial *serial = port->serial; |
| 1761 | /* obtain the private structure for the device */ |
| 1762 | struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); |
| 1763 | dev_extra->current_port = serial->port[New_Current_Port]; |
| 1764 | /* what should I do with this? commented out in upstream |
| 1765 | * driver */ |
| 1766 | /*schedule_work(&port->work);*/ |
| 1767 | } |
| 1768 | |
| 1769 | static void qt2_process_rcv_flush(struct usb_serial_port *port) |
| 1770 | { |
| 1771 | /* obtain the private structure for the port */ |
| 1772 | struct quatech2_port *port_extra = qt2_get_port_private(port); |
| 1773 | port_extra->rcv_flush = true; |
| 1774 | } |
| 1775 | static void qt2_process_xmit_flush(struct usb_serial_port *port) |
| 1776 | { |
| 1777 | /* obtain the private structure for the port */ |
| 1778 | struct quatech2_port *port_extra = qt2_get_port_private(port); |
| 1779 | port_extra->xmit_flush = true; |
| 1780 | } |
| 1781 | |
| 1782 | static void qt2_process_rx_char(struct usb_serial_port *port, |
| 1783 | unsigned char data) |
| 1784 | { |
| 1785 | /* get the tty_struct for this port */ |
| 1786 | struct tty_struct *tty = tty_port_tty_get(&(port->port)); |
| 1787 | /* get the URB with the data in to push */ |
| 1788 | struct urb *urb = port->serial->port[0]->read_urb; |
| 1789 | |
| 1790 | if (tty && urb->actual_length) { |
| 1791 | tty_buffer_request_room(tty, 1); |
| 1792 | tty_insert_flip_string(tty, &data, 1); |
| 1793 | /* should this be commented out here? */ |
| 1794 | /*tty_flip_buffer_push(tty);*/ |
| 1795 | } |
| 1796 | } |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1797 | |
| 1798 | /** @brief Retreive the value of a register from the device |
| 1799 | * |
| 1800 | * Issues a GET_REGISTER vendor-spcific request over the USB control |
| 1801 | * pipe to obtain a value back from a specific register on a specific |
| 1802 | * UART |
| 1803 | * @param serial Serial device handle to access the device through |
| 1804 | * @param uart_number Which UART the value is wanted from |
| 1805 | * @param register_num Which register to read the value from |
| 1806 | * @param pValue Pointer to somewhere to put the retrieved value |
| 1807 | */ |
| 1808 | static int qt2_box_get_register(struct usb_serial *serial, |
| 1809 | unsigned char uart_number, unsigned short register_num, |
| 1810 | __u8 *pValue) |
| 1811 | { |
| 1812 | int result; |
| 1813 | result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), |
| 1814 | QT2_GET_SET_REGISTER, 0xC0, register_num, |
| 1815 | uart_number, (void *)pValue, sizeof(*pValue), 300); |
| 1816 | return result; |
| 1817 | } |
| 1818 | |
| 1819 | /** qt2_box_set_register |
| 1820 | * Issue a SET_REGISTER vendor-specific request on the default control pipe |
| 1821 | */ |
| 1822 | static int qt2_box_set_register(struct usb_serial *serial, |
| 1823 | unsigned short Uart_Number, unsigned short Register_Num, |
| 1824 | unsigned short Value) |
| 1825 | { |
| 1826 | int result; |
| 1827 | unsigned short reg_and_byte; |
| 1828 | |
| 1829 | reg_and_byte = Value; |
| 1830 | reg_and_byte = reg_and_byte << 8; |
| 1831 | reg_and_byte = reg_and_byte + Register_Num; |
| 1832 | |
| 1833 | result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 1834 | QT2_GET_SET_REGISTER, 0x40, reg_and_byte, |
| 1835 | Uart_Number, NULL, 0, 300); |
| 1836 | return result; |
| 1837 | } |
| 1838 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1839 | /** qt2_boxsetuart - Issue a SET_UART vendor-spcific request on the default |
| 1840 | * control pipe. If successful sets baud rate divisor and LCR value. |
| 1841 | */ |
| 1842 | static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number, |
| 1843 | unsigned short default_divisor, unsigned char default_LCR) |
| 1844 | { |
| 1845 | unsigned short UartNumandLCR; |
| 1846 | |
| 1847 | UartNumandLCR = (default_LCR << 8) + Uart_Number; |
| 1848 | |
| 1849 | return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 1850 | QT2_GET_SET_UART, 0x40, default_divisor, UartNumandLCR, |
| 1851 | NULL, 0, 300); |
| 1852 | } |
Javier Martinez Canillas | 3457912 | 2010-07-30 18:51:51 -0400 | [diff] [blame] | 1853 | |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1854 | /** qt2_boxsethw_flowctl - Turn hardware (RTS/CTS) flow control on and off for |
| 1855 | * a hardware UART. |
| 1856 | */ |
| 1857 | static int qt2_boxsethw_flowctl(struct usb_serial *serial, |
| 1858 | unsigned int UartNumber, bool bSet) |
| 1859 | { |
| 1860 | __u8 MCR_Value = 0; |
| 1861 | __u8 MSR_Value = 0; |
| 1862 | __u16 MOUT_Value = 0; |
| 1863 | |
| 1864 | if (bSet == true) { |
| 1865 | MCR_Value = QT2_SERIAL_MCR_RTS; |
| 1866 | /* flow control, box will clear RTS line to prevent remote |
| 1867 | * device from transmitting more chars */ |
| 1868 | } else { |
| 1869 | /* no flow control to remote device */ |
| 1870 | MCR_Value = 0; |
| 1871 | } |
| 1872 | MOUT_Value = MCR_Value << 8; |
| 1873 | |
| 1874 | if (bSet == true) { |
| 1875 | MSR_Value = QT2_SERIAL_MSR_CTS; |
| 1876 | /* flow control on, box will inhibit tx data if CTS line is |
| 1877 | * asserted */ |
| 1878 | } else { |
| 1879 | /* Box will not inhibit tx data due to CTS line */ |
| 1880 | MSR_Value = 0; |
| 1881 | } |
| 1882 | MOUT_Value |= MSR_Value; |
| 1883 | return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 1884 | QT2_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value, UartNumber, |
| 1885 | NULL, 0, 300); |
| 1886 | } |
| 1887 | |
| 1888 | /** qt2_boxsetsw_flowctl - Turn software (XON/XOFF) flow control on for |
| 1889 | * a hardware UART, and set the XON and XOFF characters. |
| 1890 | */ |
| 1891 | static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber, |
| 1892 | unsigned char stop_char, unsigned char start_char) |
| 1893 | { |
| 1894 | __u16 nSWflowout; |
| 1895 | |
| 1896 | nSWflowout = start_char << 8; |
| 1897 | nSWflowout = (unsigned short)stop_char; |
| 1898 | return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 1899 | QT2_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout, UartNumber, |
| 1900 | NULL, 0, 300); |
| 1901 | } |
| 1902 | |
| 1903 | /** qt2_boxunsetsw_flowctl - Turn software (XON/XOFF) flow control off for |
| 1904 | * a hardware UART. |
| 1905 | */ |
| 1906 | static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber) |
| 1907 | { |
| 1908 | return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 1909 | QT2_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber, NULL, |
| 1910 | 0, 300); |
| 1911 | } |
| 1912 | |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1913 | /** |
| 1914 | * qt2_boxstoprx - Start and stop reception of data by the FPGA UART in |
| 1915 | * response to requests from the tty layer |
| 1916 | * @serial: pointer to the usb_serial structure for the parent device |
| 1917 | * @uart_number: which UART on the device we are addressing |
| 1918 | * @stop: Whether to start or stop data reception. Set to 1 to stop data being |
| 1919 | * received, and to 0 to start it being received. |
| 1920 | */ |
| 1921 | static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number, |
| 1922 | unsigned short stop) |
| 1923 | { |
| 1924 | return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 1925 | QT2_STOP_RECEIVE, 0x40, stop, uart_number, NULL, 0, 300); |
| 1926 | } |
| 1927 | |
| 1928 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1929 | /* |
| 1930 | * last things in file: stuff to register this driver into the generic |
| 1931 | * USB serial framework. |
| 1932 | */ |
| 1933 | |
| 1934 | static struct usb_serial_driver quatech2_device = { |
| 1935 | .driver = { |
| 1936 | .owner = THIS_MODULE, |
| 1937 | .name = "quatech_usb2", |
| 1938 | }, |
| 1939 | .description = DRIVER_DESC, |
| 1940 | .usb_driver = &quausb2_usb_driver, |
| 1941 | .id_table = quausb2_id_table, |
| 1942 | .num_ports = 8, |
| 1943 | .open = qt2_open, |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1944 | .close = qt2_close, |
| 1945 | .write = qt2_write, |
| 1946 | .write_room = qt2_write_room, |
| 1947 | .chars_in_buffer = qt2_chars_in_buffer, |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1948 | .throttle = qt2_throttle, |
| 1949 | .unthrottle = qt2_unthrottle, |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1950 | .calc_num_ports = qt2_calc_num_ports, |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1951 | .ioctl = qt2_ioctl, |
Richard Ash | 2715dd6 | 2009-08-20 11:24:39 +0100 | [diff] [blame] | 1952 | .set_termios = qt2_set_termios, |
Richard Ash | d3f0e10 | 2009-08-20 11:24:49 +0100 | [diff] [blame] | 1953 | .break_ctl = qt2_break, |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1954 | .tiocmget = qt2_tiocmget, |
| 1955 | .tiocmset = qt2_tiocmset, |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1956 | .attach = qt2_attach, |
| 1957 | .release = qt2_release, |
Richard Ash | 713e5f6 | 2009-08-17 10:32:53 +0100 | [diff] [blame] | 1958 | .read_bulk_callback = qt2_read_bulk_callback, |
| 1959 | .write_bulk_callback = qt2_write_bulk_callback, |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1960 | }; |
| 1961 | |
| 1962 | static int __init quausb2_usb_init(void) |
| 1963 | { |
| 1964 | int retval; |
| 1965 | |
| 1966 | dbg("%s\n", __func__); |
| 1967 | |
| 1968 | /* register with usb-serial */ |
| 1969 | retval = usb_serial_register(&quatech2_device); |
| 1970 | |
| 1971 | if (retval) |
| 1972 | goto failed_usb_serial_register; |
| 1973 | |
| 1974 | printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" |
| 1975 | DRIVER_DESC "\n"); |
| 1976 | |
| 1977 | /* register with usb */ |
| 1978 | |
| 1979 | retval = usb_register(&quausb2_usb_driver); |
| 1980 | if (retval == 0) |
| 1981 | return 0; |
| 1982 | |
| 1983 | /* if we're here, usb_register() failed */ |
| 1984 | usb_serial_deregister(&quatech2_device); |
| 1985 | failed_usb_serial_register: |
| 1986 | return retval; |
| 1987 | } |
| 1988 | |
Richard Ash | c4f3020 | 2009-06-23 17:28:06 +0100 | [diff] [blame] | 1989 | static void __exit quausb2_usb_exit(void) |
| 1990 | { |
| 1991 | usb_deregister(&quausb2_usb_driver); |
| 1992 | usb_serial_deregister(&quatech2_device); |
| 1993 | } |
| 1994 | |
| 1995 | module_init(quausb2_usb_init); |
| 1996 | module_exit(quausb2_usb_exit); |
| 1997 | |
| 1998 | MODULE_AUTHOR(DRIVER_AUTHOR); |
| 1999 | MODULE_DESCRIPTION(DRIVER_DESC); |
| 2000 | MODULE_LICENSE("GPL"); |
| 2001 | |
| 2002 | module_param(debug, bool, S_IRUGO | S_IWUSR); |
| 2003 | MODULE_PARM_DESC(debug, "Debug enabled or not"); |