← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/staging/quatech_usb2/quatech_usb2.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/quatech_usb2/quatech_usb2.c
 
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 */
 
41
#define QT2_FIFO_DEPTH 1024                     /* size of hardware fifos */
 
42
#define QT2_TX_HEADER_LENGTH    5
 
43
/* length of the header sent to the box with each write URB */
 
44
 
 
45
/* directions for USB transfers */
 
46
#define USBD_TRANSFER_DIRECTION_IN    0xc0
 
47
#define USBD_TRANSFER_DIRECTION_OUT   0x40
 
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 */
 
51
#define QT_SET_GET_DEVICE               0xc2
 
52
#define QT_OPEN_CLOSE_CHANNEL           0xca
 
53
/*#define QT_GET_SET_PREBUF_TRIG_LVL    0xcc
 
54
#define QT_SET_ATF                      0xcd*/
 
55
#define QT2_GET_SET_REGISTER                    0xc0
 
56
#define QT2_GET_SET_UART                        0xc1
 
57
#define QT2_HW_FLOW_CONTROL_MASK                0xc5
 
58
#define QT2_SW_FLOW_CONTROL_MASK                0xc6
 
59
#define QT2_SW_FLOW_CONTROL_DISABLE             0xc7
 
60
#define QT2_BREAK_CONTROL                       0xc8
 
61
#define QT2_STOP_RECEIVE                        0xe0
 
62
#define QT2_FLUSH_DEVICE                        0xc4
 
63
#define QT2_GET_SET_QMCR                        0xe1
 
64
 
 
65
/* sorts of flush we can do on */
 
66
#define QT2_FLUSH_RX                    0x00
 
67
#define QT2_FLUSH_TX                    0x01
 
68
 
 
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
 
74
 
 
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
 
80
 
 
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
 
85
 
 
86
#define QT2_SERIAL_ODD_PARITY   0x08
 
87
#define QT2_SERIAL_EVEN_PARITY  0x18
 
88
#define QT2_SERIAL_TWO_STOPB    0x04
 
89
#define QT2_SERIAL_ONE_STOPB    0x00
 
90
 
 
91
#define QT2_MAX_BAUD_RATE       921600
 
92
#define QT2_MAX_BAUD_REMAINDER  4608
 
93
 
 
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
 
98
 
 
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
 
 
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]
 
118
 
 
119
static const struct usb_device_id quausb2_id_table[] = {
 
120
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)},
 
121
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_100)},
 
122
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_400)},
 
123
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_100)},
 
124
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_400)},
 
125
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_100)},
 
126
        {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_400)},
 
127
        {}      /* Terminating entry */
 
128
};
 
129
 
 
130
MODULE_DEVICE_TABLE(usb, quausb2_id_table);
 
131
 
 
132
/* custom structures we need go here */
 
133
static struct usb_driver quausb2_usb_driver = {
 
134
        .name = "quatech-usb2-serial",
 
135
        .probe = usb_serial_probe,
 
136
        .disconnect = usb_serial_disconnect,
 
137
        .id_table = quausb2_id_table,
 
138
        .no_dynamic_id = 1,
 
139
};
 
140
 
 
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
 
146
 * being closed (and so no new reads / writes should be started).
 
147
 * @shadowLSR: Last received state of the line status register, holds the
 
148
 * value of the line status flags from the port
 
149
 * @shadowMSR: Last received state of the modem status register, holds
 
150
 * the value of the modem status received from the port
 
151
 * @rcv_flush: Flag indicating that a receive flush has occurred on
 
152
 * the hardware.
 
153
 * @xmit_flush: Flag indicating that a transmit flush has been processed by
 
154
 * the hardware.
 
155
 * @tx_pending_bytes: Number of bytes waiting to be sent. This total
 
156
 * includes the size (excluding header) of URBs that have been submitted but
 
157
 * have not yet been sent to to the device, and bytes that have been sent out
 
158
 * of the port but not yet reported sent by the "xmit_empty" messages (which
 
159
 * indicate the number of bytes sent each time they are received, 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.
 
166
 * @lock: Mutex to lock access to this structure when we need to ensure that
 
167
 * races don't occur to access bits of it.
 
168
 * @open_count: The number of uses of the port currently having
 
169
 * it open, i.e. the reference count.
 
170
 */
 
171
struct quatech2_port {
 
172
        int     magic;
 
173
        bool    read_urb_busy;
 
174
        bool    close_pending;
 
175
        __u8    shadowLSR;
 
176
        __u8    shadowMSR;
 
177
        bool    rcv_flush;
 
178
        bool    xmit_flush;
 
179
        int     tx_pending_bytes;
 
180
        struct mutex modelock;
 
181
        int     open_count;
 
182
 
 
183
        char    active;         /* someone has this device open */
 
184
        unsigned char           *xfer_to_tty_buffer;
 
185
        wait_queue_head_t       wait;
 
186
        __u8    shadowLCR;      /* last LCR value received */
 
187
        __u8    shadowMCR;      /* last MCR value received */
 
188
        char    RxHolding;
 
189
        struct semaphore        pend_xmit_sem;  /* locks this structure */
 
190
        spinlock_t lock;
 
191
};
 
192
 
 
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
 
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.
 
205
 */
 
206
struct quatech2_dev {
 
207
        bool    ReadBulkStopped;
 
208
        char    open_ports;
 
209
        struct usb_serial_port *current_port;
 
210
        int     buffer_size;
 
211
};
 
212
 
 
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);
 
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);
 
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);
 
241
static void qt2_read_bulk_callback(struct urb *urb);
 
242
static void qt2_write_bulk_callback(struct urb *urb);
 
243
static void qt2_process_line_status(struct usb_serial_port *port,
 
244
                              unsigned char LineStatus);
 
245
static void qt2_process_modem_status(struct usb_serial_port *port,
 
246
                               unsigned char ModemStatus);
 
247
static void qt2_process_xmit_empty(struct usb_serial_port *port,
 
248
        unsigned char fourth_char, unsigned char fifth_char);
 
249
static void qt2_process_port_change(struct usb_serial_port *port,
 
250
                              unsigned char New_Current_Port);
 
251
static void qt2_process_rcv_flush(struct usb_serial_port *port);
 
252
static void qt2_process_xmit_flush(struct usb_serial_port *port);
 
253
static void qt2_process_rx_char(struct usb_serial_port *port,
 
254
                                unsigned char data);
 
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);
 
261
static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number,
 
262
                unsigned short default_divisor, unsigned char default_LCR);
 
263
static int qt2_boxsethw_flowctl(struct usb_serial *serial,
 
264
                unsigned int UartNumber, bool bSet);
 
265
static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber,
 
266
                unsigned char stop_char,  unsigned char start_char);
 
267
static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber);
 
268
static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number,
 
269
                         unsigned short stop);
 
270
 
 
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;
 
308
        struct quatech2_port *qt2_port; /* port-specific private data pointer */
 
309
        struct quatech2_dev  *qt2_dev;  /* dev-specific private data pointer */
 
310
        int i;
 
311
        /* stuff for storing endpoint addresses now */
 
312
        struct usb_endpoint_descriptor *endpoint;
 
313
        struct usb_host_interface *iface_desc;
 
314
        struct usb_serial_port *port0;  /* first port structure on device */
 
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;
 
326
 
 
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 */
 
337
 
 
338
        /* Now setup per port private data, which replaces all the things
 
339
         * that quatech added to standard kernel structures in their driver */
 
340
        for (i = 0; i < serial->num_ports; i++) {
 
341
                port = serial->port[i];
 
342
                qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL);
 
343
                if (!qt2_port) {
 
344
                        dbg("%s: kmalloc for quatech2_port (%d) failed!.",
 
345
                            __func__, i);
 
346
                        return -ENOMEM;
 
347
                }
 
348
                /* initialise stuff in the structure */
 
349
                qt2_port->open_count = 0;       /* port is not open */
 
350
                spin_lock_init(&qt2_port->lock);
 
351
                mutex_init(&qt2_port->modelock);
 
352
                qt2_set_port_private(port, qt2_port);
 
353
        }
 
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 */
 
368
                        dbg("found bulk in at %#.2x",
 
369
                                endpoint->bEndpointAddress);
 
370
                }
 
371
 
 
372
                if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
 
373
                        ((endpoint->bmAttributes & 3) == 0x02)) {
 
374
                        /* we found a bulk out endpoint */
 
375
                        dbg("found bulk out at %#.2x",
 
376
                                endpoint->bEndpointAddress);
 
377
                        qt2_dev->buffer_size = endpoint->wMaxPacketSize;
 
378
                        /* max size of URB needs recording for the device */
 
379
                }
 
380
        }       /* end printing endpoint addresses */
 
381
 
 
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);
 
403
                qt2_set_port_private(port, NULL);
 
404
        }
 
405
        qt2_dev = qt2_get_dev_private(serial);
 
406
        kfree(qt2_dev);
 
407
        qt2_set_dev_private(serial, NULL);
 
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
}
 
431
/* This function is called once per serial port on the device, when
 
432
 * that port is opened by a userspace application.
 
433
 * The tty_struct and the usb_serial_port belong to this port,
 
434
 * i.e. there are multiple ones for a multi-port device.
 
435
 * However the usb_serial_port structure has a back-pointer
 
436
 * to the parent usb_serial structure which belongs to the device,
 
437
 * so we can access either the device-wide information or
 
438
 * any other port's information (because there are also forward
 
439
 * pointers) via that pointer.
 
440
 * This is most helpful if the device shares resources (e.g. end
 
441
 * points) between different ports
 
442
 */
 
443
int qt2_open(struct tty_struct *tty, struct usb_serial_port *port)
 
444
{
 
445
        struct usb_serial *serial;      /* device structure */
 
446
        struct usb_serial_port *port0;  /* first port structure on device */
 
447
        struct quatech2_port *port_extra;       /* extra data for this port */
 
448
        struct quatech2_port *port0_extra;      /* extra data for first port */
 
449
        struct quatech2_dev *dev_extra;         /* extra data for the device */
 
450
        struct qt2_status_data ChannelData;
 
451
        unsigned short default_divisor = QU2BOXSPD9600;
 
452
        unsigned char  default_LCR = QT2_SERIAL_8_DATA;
 
453
        int status;
 
454
        int result;
 
455
 
 
456
        if (port_paranoia_check(port, __func__))
 
457
                return -ENODEV;
 
458
 
 
459
        dbg("%s(): port %d", __func__, port->number);
 
460
 
 
461
        serial = port->serial;  /* get the parent device structure */
 
462
        if (serial_paranoia_check(serial, __func__)) {
 
463
                dbg("usb_serial struct failed sanity check");
 
464
                return -ENODEV;
 
465
        }
 
466
        dev_extra = qt2_get_dev_private(serial);
 
467
        /* get the device private data */
 
468
        if (dev_extra == NULL) {
 
469
                dbg("device extra data pointer is null");
 
470
                return -ENODEV;
 
471
        }
 
472
        port0 = serial->port[0]; /* get the first port's device structure */
 
473
        if (port_paranoia_check(port0, __func__)) {
 
474
                dbg("port0 usb_serial_port struct failed sanity check");
 
475
                return -ENODEV;
 
476
        }
 
477
 
 
478
        port_extra = qt2_get_port_private(port);
 
479
        port0_extra = qt2_get_port_private(port0);
 
480
        if (port_extra == NULL || port0_extra == NULL) {
 
481
                dbg("failed to get private data for port or port0");
 
482
                return -ENODEV;
 
483
        }
 
484
 
 
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 &
 
495
                        (QT2_SERIAL_LSR_OE | QT2_SERIAL_LSR_PE |
 
496
                        QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI);
 
497
        port_extra->shadowMSR = ChannelData.modem_status &
 
498
                        (QT2_SERIAL_MSR_CTS | QT2_SERIAL_MSR_DSR |
 
499
                        QT2_SERIAL_MSR_RI | QT2_SERIAL_MSR_CD);
 
500
 
 
501
/*      port_extra->fifo_empty_flag = true;*/
 
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
 
 
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
 
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.
 
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
         */
 
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);
 
534
 
 
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);
 
568
        port_extra->tx_pending_bytes = 0;
 
569
 
 
570
        if (dev_extra->open_ports == 0) {
 
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) */
 
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);
 
580
                dbg("port0 bulk in URB initialised");
 
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,
 
588
                                 "%s(): Error %d submitting bulk in urb",
 
589
                                __func__, result);
 
590
                        port_extra->read_urb_busy = false;
 
591
                        dev_extra->ReadBulkStopped = true;
 
592
                }
 
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;
 
600
        }
 
601
 
 
602
        /* initialize our wait queues */
 
603
        init_waitqueue_head(&port_extra->wait);
 
604
        /* increment the count of openings of this port by one */
 
605
        port_extra->open_count++;
 
606
 
 
607
        /* remember to store dev_extra, port_extra and port0_extra back again at
 
608
         * end !*/
 
609
        qt2_set_port_private(port, port_extra);
 
610
        qt2_set_port_private(serial->port[0], port0_extra);
 
611
        qt2_set_dev_private(serial, dev_extra);
 
612
 
 
613
        dev_extra->open_ports++; /* one more port opened */
 
614
 
 
615
        return 0;
 
616
}
 
617
 
 
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. */
 
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
 
 
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 transferring. */
 
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) */
 
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
 
 
684
        /* decrement the count of openings of this port by one */
 
685
        port_extra->open_count--;
 
686
        /* one less overall open as well */
 
687
        dev_extra->open_ports--;
 
688
        dbg("%s(): Exit, dev_extra->open_ports  = %d", __func__,
 
689
                dev_extra->open_ports);
 
690
}
 
691
 
 
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
 */
 
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 */
 
705
        int result;
 
706
 
 
707
        serial = port->serial; /* get the parent device of the port */
 
708
        port_extra = qt2_get_port_private(port); /* port extra info */
 
709
        if (serial == NULL)
 
710
                return -ENODEV;
 
711
        dbg("%s(): port %d, requested to write %d bytes, %d already pending",
 
712
                __func__, port->number, count, port_extra->tx_pending_bytes);
 
713
 
 
714
        if (count <= 0) {
 
715
                dbg("%s(): write request of <= 0 bytes", __func__);
 
716
                return 0;       /* no bytes written */
 
717
        }
 
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;
 
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 occurred */
 
730
                dbg("%s(): port transmit buffer is full!", __func__);
 
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*/
 
743
        if (count > port->bulk_out_size - QT2_TX_HEADER_LENGTH) {
 
744
                count = port->bulk_out_size - QT2_TX_HEADER_LENGTH;
 
745
                dbg("%s(): write request bigger than urb, only accepting "
 
746
                        "%d bytes", __func__, count);
 
747
        }
 
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.*/
 
751
        if (count > (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes)) {
 
752
                count = QT2_FIFO_DEPTH - port_extra->tx_pending_bytes;
 
753
                dbg("%s(): not enough room in buffer, only accepting %d bytes",
 
754
                        __func__, count);
 
755
        }
 
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 */
 
780
                result = 0;     /* return 0 as nothing got written */
 
781
                dbg("%s(): failed submitting write urb, error %d",
 
782
                        __func__, result);
 
783
        } else {
 
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);
 
789
        }
 
790
        return result;
 
791
}
 
792
 
 
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
 */
 
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
        }
 
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.
 
820
 
 
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 received 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)
 
832
                room = port->bulk_out_size - QT2_TX_HEADER_LENGTH;
 
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);
 
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 */
 
843
        struct quatech2_port *port_extra;       /* extra data for this port */
 
844
        port_extra = qt2_get_port_private(port);
 
845
 
 
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;
 
849
}
 
850
 
 
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
 */
 
855
static int qt2_ioctl(struct tty_struct *tty,
 
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;
 
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
 
 
880
        if (cmd == TIOCMBIS || cmd == TIOCMBIC) {
 
881
                if (qt2_box_get_register(port->serial, UartNumber,
 
882
                        QT2_MODEM_CONTROL_REGISTER, &mcr_value) < 0)
 
883
                        return -ESPIPE;
 
884
                if (copy_from_user(&value, (unsigned int *)arg,
 
885
                        sizeof(value)))
 
886
                        return -EFAULT;
 
887
 
 
888
                switch (cmd) {
 
889
                case TIOCMBIS:
 
890
                        if (value & TIOCM_RTS)
 
891
                                mcr_value |= QT2_SERIAL_MCR_RTS;
 
892
                        if (value & TIOCM_DTR)
 
893
                                mcr_value |= QT2_SERIAL_MCR_DTR;
 
894
                        if (value & TIOCM_LOOP)
 
895
                                mcr_value |= QT2_SERIAL_MCR_LOOP;
 
896
                break;
 
897
                case TIOCMBIC:
 
898
                        if (value & TIOCM_RTS)
 
899
                                mcr_value &= ~QT2_SERIAL_MCR_RTS;
 
900
                        if (value & TIOCM_DTR)
 
901
                                mcr_value &= ~QT2_SERIAL_MCR_DTR;
 
902
                        if (value & TIOCM_LOOP)
 
903
                                mcr_value &= ~QT2_SERIAL_MCR_LOOP;
 
904
                break;
 
905
                default:
 
906
                break;
 
907
                }       /* end of local switch on cmd */
 
908
                if (qt2_box_set_register(port->serial,  UartNumber,
 
909
                    QT2_MODEM_CONTROL_REGISTER, mcr_value) < 0) {
 
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);
 
918
                prev_msr_value = port_extra->shadowMSR  & QT2_SERIAL_MSR_MASK;
 
919
                barrier();
 
920
                __set_current_state(TASK_INTERRUPTIBLE);
 
921
                while (1) {
 
922
                        add_wait_queue(&port_extra->wait, &wait);
 
923
                        schedule();
 
924
                        dbg("%s(): port %d, cmd == TIOCMIWAIT here\n",
 
925
                                __func__, port->number);
 
926
                        remove_wait_queue(&port_extra->wait, &wait);
 
927
                        /* see if a signal woke us up */
 
928
                        if (signal_pending(current))
 
929
                                return -ERESTARTSYS;
 
930
                        set_current_state(TASK_INTERRUPTIBLE);
 
931
                        msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK;
 
932
                        if (msr_value == prev_msr_value) {
 
933
                                __set_current_state(TASK_RUNNING);
 
934
                                return -EIO;  /* no change - error */
 
935
                        }
 
936
                        if ((arg & TIOCM_RNG &&
 
937
                                ((prev_msr_value & QT2_SERIAL_MSR_RI) ==
 
938
                                        (msr_value & QT2_SERIAL_MSR_RI))) ||
 
939
                                (arg & TIOCM_DSR &&
 
940
                                ((prev_msr_value & QT2_SERIAL_MSR_DSR) ==
 
941
                                        (msr_value & QT2_SERIAL_MSR_DSR))) ||
 
942
                                (arg & TIOCM_CD &&
 
943
                                ((prev_msr_value & QT2_SERIAL_MSR_CD) ==
 
944
                                        (msr_value & QT2_SERIAL_MSR_CD))) ||
 
945
                                (arg & TIOCM_CTS &&
 
946
                                ((prev_msr_value & QT2_SERIAL_MSR_CTS) ==
 
947
                                        (msr_value & QT2_SERIAL_MSR_CTS)))) {
 
948
                                __set_current_state(TASK_RUNNING);
 
949
                                return 0;
 
950
                        }
 
951
                } /* end inifinite while */
 
952
                /* FIXME: This while loop needs a way to break out if the device
 
953
                 * is disconnected while a process is waiting for the MSR to
 
954
                 * change, because once it's disconnected, it isn't going to
 
955
                 * change state ... */
 
956
        } else {
 
957
                /* any other ioctls we don't know about come here */
 
958
                dbg("%s(): No ioctl for that one. port = %d", __func__,
 
959
                        port->number);
 
960
                return -ENOIOCTLCMD;
 
961
        }
 
962
}
 
963
 
 
964
/* Called when the user wishes to change the port settings using the termios
 
965
 * userspace interface */
 
966
static void qt2_set_termios(struct tty_struct *tty,
 
967
        struct usb_serial_port *port, struct ktermios *old_termios)
 
968
{
 
969
        struct usb_serial *serial; /* parent serial device */
 
970
        int baud, divisor, remainder;
 
971
        unsigned char LCR_change_to = 0;
 
972
        int status;
 
973
        __u16 UartNumber;
 
974
 
 
975
        dbg("%s(): port %d", __func__, port->number);
 
976
 
 
977
        serial = port->serial;
 
978
 
 
979
        UartNumber = port->number;
 
980
 
 
981
        if (old_termios && !tty_termios_hw_change(old_termios, tty->termios))
 
982
                return;
 
983
 
 
984
        switch (tty->termios->c_cflag) {
 
985
        case CS5:
 
986
                LCR_change_to |= QT2_SERIAL_5_DATA;
 
987
                break;
 
988
        case CS6:
 
989
                LCR_change_to |= QT2_SERIAL_6_DATA;
 
990
                break;
 
991
        case CS7:
 
992
                LCR_change_to |= QT2_SERIAL_7_DATA;
 
993
                break;
 
994
        default:
 
995
        case CS8:
 
996
                LCR_change_to |= QT2_SERIAL_8_DATA;
 
997
                break;
 
998
        }
 
999
 
 
1000
        /* Parity stuff */
 
1001
        if (tty->termios->c_cflag & PARENB) {
 
1002
                if (tty->termios->c_cflag & PARODD)
 
1003
                        LCR_change_to |= QT2_SERIAL_ODD_PARITY;
 
1004
                else
 
1005
                        LCR_change_to |= QT2_SERIAL_EVEN_PARITY;
 
1006
        }
 
1007
        /* Because LCR_change_to is initialised to zero, we don't have to worry
 
1008
         * about the case where PARENB is not set or clearing bits, because by
 
1009
         * default all of them are cleared, turning parity off.
 
1010
         * as we don't support mark/space parity, we should clear the
 
1011
         * mark/space parity bit in c_cflag, so the caller can tell we have
 
1012
         * ignored the request */
 
1013
        tty->termios->c_cflag &= ~CMSPAR;
 
1014
 
 
1015
        if (tty->termios->c_cflag & CSTOPB)
 
1016
                LCR_change_to |= QT2_SERIAL_TWO_STOPB;
 
1017
        else
 
1018
                LCR_change_to |= QT2_SERIAL_ONE_STOPB;
 
1019
 
 
1020
        /* Thats the LCR stuff, next we need to work out the divisor as the
 
1021
         * LCR and the divisor are set together */
 
1022
        baud = tty_get_baud_rate(tty);
 
1023
        if (!baud) {
 
1024
                /* pick a default, any default... */
 
1025
                baud = 9600;
 
1026
        }
 
1027
        dbg("%s(): got baud = %d", __func__, baud);
 
1028
 
 
1029
        divisor = QT2_MAX_BAUD_RATE / baud;
 
1030
        remainder = QT2_MAX_BAUD_RATE % baud;
 
1031
        /* Round to nearest divisor */
 
1032
        if (((remainder * 2) >= baud) && (baud != 110))
 
1033
                divisor++;
 
1034
        dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = %#.2x",
 
1035
              __func__, divisor, QT2_MAX_BAUD_RATE, LCR_change_to);
 
1036
 
 
1037
        status = qt2_boxsetuart(serial, UartNumber, (unsigned short) divisor,
 
1038
                            LCR_change_to);
 
1039
        if (status < 0) {
 
1040
                dbg("qt2_boxsetuart() failed");
 
1041
                return;
 
1042
        } else {
 
1043
                /* now encode the baud rate we actually set, which may be
 
1044
                 * different to the request */
 
1045
                baud = QT2_MAX_BAUD_RATE / divisor;
 
1046
                tty_encode_baud_rate(tty, baud, baud);
 
1047
        }
 
1048
 
 
1049
        /* Now determine flow control */
 
1050
        if (tty->termios->c_cflag & CRTSCTS) {
 
1051
                dbg("%s(): Enabling HW flow control port %d", __func__,
 
1052
                      port->number);
 
1053
                /* Enable  RTS/CTS flow control */
 
1054
                status = qt2_boxsethw_flowctl(serial, UartNumber, true);
 
1055
                if (status < 0) {
 
1056
                        dbg("qt2_boxsethw_flowctl() failed");
 
1057
                        return;
 
1058
                }
 
1059
        } else {
 
1060
                /* Disable RTS/CTS flow control */
 
1061
                dbg("%s(): disabling HW flow control port %d", __func__,
 
1062
                        port->number);
 
1063
                status = qt2_boxsethw_flowctl(serial, UartNumber, false);
 
1064
                if (status < 0) {
 
1065
                        dbg("qt2_boxsethw_flowctl failed");
 
1066
                        return;
 
1067
                }
 
1068
        }
 
1069
        /* if we are implementing XON/XOFF, set the start and stop character
 
1070
         * in the device */
 
1071
        if (I_IXOFF(tty) || I_IXON(tty)) {
 
1072
                unsigned char stop_char  = STOP_CHAR(tty);
 
1073
                unsigned char start_char = START_CHAR(tty);
 
1074
                status = qt2_boxsetsw_flowctl(serial, UartNumber, stop_char,
 
1075
                                start_char);
 
1076
                if (status < 0)
 
1077
                        dbg("qt2_boxsetsw_flowctl (enabled) failed");
 
1078
        } else {
 
1079
                /* disable SW flow control */
 
1080
                status = qt2_boxunsetsw_flowctl(serial, UartNumber);
 
1081
                if (status < 0)
 
1082
                        dbg("qt2_boxunsetsw_flowctl (disabling) failed");
 
1083
        }
 
1084
}
 
1085
 
 
1086
static int qt2_tiocmget(struct tty_struct *tty)
 
1087
{
 
1088
        struct usb_serial_port *port = tty->driver_data;
 
1089
        struct usb_serial *serial = port->serial;
 
1090
 
 
1091
        __u8 mcr_value; /* Modem Control Register value */
 
1092
        __u8 msr_value; /* Modem Status Register value */
 
1093
        unsigned int result = 0;
 
1094
        int status;
 
1095
        unsigned int UartNumber;
 
1096
 
 
1097
        if (serial == NULL)
 
1098
                return -ENODEV;
 
1099
 
 
1100
        dbg("%s(): port %d, tty =0x%p", __func__, port->number, tty);
 
1101
        UartNumber = tty->index - serial->minor;
 
1102
        dbg("UartNumber is %d", UartNumber);
 
1103
 
 
1104
        status = qt2_box_get_register(port->serial, UartNumber,
 
1105
                        QT2_MODEM_CONTROL_REGISTER,     &mcr_value);
 
1106
        if (status >= 0) {
 
1107
                status = qt2_box_get_register(port->serial,  UartNumber,
 
1108
                                QT2_MODEM_STATUS_REGISTER, &msr_value);
 
1109
        }
 
1110
        if (status >= 0) {
 
1111
                result = ((mcr_value & QT2_SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
 
1112
                                /*DTR set */
 
1113
                        | ((mcr_value & QT2_SERIAL_MCR_RTS)  ? TIOCM_RTS : 0)
 
1114
                                /*RTS set */
 
1115
                        | ((msr_value & QT2_SERIAL_MSR_CTS)  ? TIOCM_CTS : 0)
 
1116
                                /* CTS set */
 
1117
                        | ((msr_value & QT2_SERIAL_MSR_CD)  ? TIOCM_CAR : 0)
 
1118
                                /*Carrier detect set */
 
1119
                        | ((msr_value & QT2_SERIAL_MSR_RI)  ? TIOCM_RI : 0)
 
1120
                                /* Ring indicator set */
 
1121
                        | ((msr_value & QT2_SERIAL_MSR_DSR)  ? TIOCM_DSR : 0);
 
1122
                                /* DSR set */
 
1123
                return result;
 
1124
        } else {
 
1125
                return -ESPIPE;
 
1126
        }
 
1127
}
 
1128
 
 
1129
static int qt2_tiocmset(struct tty_struct *tty,
 
1130
                       unsigned int set, unsigned int clear)
 
1131
{
 
1132
        struct usb_serial_port *port = tty->driver_data;
 
1133
        struct usb_serial *serial = port->serial;
 
1134
        __u8 mcr_value; /* Modem Control Register value */
 
1135
        int status;
 
1136
        unsigned int UartNumber;
 
1137
 
 
1138
        if (serial == NULL)
 
1139
                return -ENODEV;
 
1140
 
 
1141
        UartNumber = tty->index - serial->minor;
 
1142
        dbg("%s(): port %d, UartNumber %d", __func__, port->number, UartNumber);
 
1143
 
 
1144
        status = qt2_box_get_register(port->serial, UartNumber,
 
1145
                        QT2_MODEM_CONTROL_REGISTER, &mcr_value);
 
1146
        if (status < 0)
 
1147
                return -ESPIPE;
 
1148
 
 
1149
        /* Turn off RTS, DTR and loopback, then only turn on what was asked
 
1150
         * for */
 
1151
        mcr_value &= ~(QT2_SERIAL_MCR_RTS | QT2_SERIAL_MCR_DTR |
 
1152
                        QT2_SERIAL_MCR_LOOP);
 
1153
        if (set & TIOCM_RTS)
 
1154
                mcr_value |= QT2_SERIAL_MCR_RTS;
 
1155
        if (set & TIOCM_DTR)
 
1156
                mcr_value |= QT2_SERIAL_MCR_DTR;
 
1157
        if (set & TIOCM_LOOP)
 
1158
                mcr_value |= QT2_SERIAL_MCR_LOOP;
 
1159
 
 
1160
        status = qt2_box_set_register(port->serial, UartNumber,
 
1161
                        QT2_MODEM_CONTROL_REGISTER, mcr_value);
 
1162
        if (status < 0)
 
1163
                return -ESPIPE;
 
1164
        else
 
1165
                return 0;
 
1166
}
 
1167
 
 
1168
/** qt2_break - Turn BREAK on and off on the UARTs
 
1169
 */
 
1170
static void qt2_break(struct tty_struct *tty, int break_state)
 
1171
{
 
1172
        struct usb_serial_port *port = tty->driver_data; /* parent port */
 
1173
        struct usb_serial *serial = port->serial;       /* parent device */
 
1174
        struct quatech2_port *port_extra;       /* extra data for this port */
 
1175
        __u16 break_value;
 
1176
        unsigned int result;
 
1177
 
 
1178
        port_extra = qt2_get_port_private(port);
 
1179
        if (!serial) {
 
1180
                dbg("%s(): port %d: no serial object", __func__, port->number);
 
1181
                return;
 
1182
        }
 
1183
 
 
1184
        if (break_state == -1)
 
1185
                break_value = 1;
 
1186
        else
 
1187
                break_value = 0;
 
1188
        dbg("%s(): port %d, break_value %d", __func__, port->number,
 
1189
                break_value);
 
1190
 
 
1191
        mutex_lock(&port_extra->modelock);
 
1192
        if (!port_extra->open_count) {
 
1193
                dbg("%s(): port not open", __func__);
 
1194
                goto exit;
 
1195
        }
 
1196
 
 
1197
        result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1198
                                QT2_BREAK_CONTROL, 0x40, break_value,
 
1199
                                port->number, NULL, 0, 300);
 
1200
exit:
 
1201
        mutex_unlock(&port_extra->modelock);
 
1202
        dbg("%s(): exit port %d", __func__, port->number);
 
1203
 
 
1204
}
 
1205
/**
 
1206
 * qt2_throttle: - stop reading new data from the port
 
1207
 */
 
1208
static void qt2_throttle(struct tty_struct *tty)
 
1209
{
 
1210
        struct usb_serial_port *port = tty->driver_data;
 
1211
        struct usb_serial *serial = port->serial;
 
1212
        struct quatech2_port *port_extra;       /* extra data for this port */
 
1213
        dbg("%s(): port %d", __func__, port->number);
 
1214
 
 
1215
        port_extra = qt2_get_port_private(port);
 
1216
        if (!serial) {
 
1217
                dbg("%s(): enter port %d no serial object", __func__,
 
1218
                      port->number);
 
1219
                return;
 
1220
        }
 
1221
 
 
1222
        mutex_lock(&port_extra->modelock);      /* lock structure */
 
1223
        if (!port_extra->open_count) {
 
1224
                dbg("%s(): port not open", __func__);
 
1225
                goto exit;
 
1226
        }
 
1227
        /* Send command to box to stop receiving stuff. This will stop this
 
1228
         * particular UART from filling the endpoint - in the multiport case the
 
1229
         * FPGA UART will handle any flow control implemented, but for the single
 
1230
         * port it's handed differently and we just quit submitting urbs
 
1231
         */
 
1232
        if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100)
 
1233
                qt2_boxstoprx(serial, port->number, 1);
 
1234
 
 
1235
        port->throttled = 1;
 
1236
exit:
 
1237
        mutex_unlock(&port_extra->modelock);
 
1238
        dbg("%s(): port %d: setting port->throttled", __func__, port->number);
 
1239
        return;
 
1240
}
 
1241
 
 
1242
/**
 
1243
 * qt2_unthrottle: - start receiving data through the port again after being
 
1244
 * throttled
 
1245
 */
 
1246
static void qt2_unthrottle(struct tty_struct *tty)
 
1247
{
 
1248
        struct usb_serial_port *port = tty->driver_data;
 
1249
        struct usb_serial *serial = port->serial;
 
1250
        struct quatech2_port *port_extra;       /* extra data for this port */
 
1251
        struct usb_serial_port *port0;  /* first port structure on device */
 
1252
        struct quatech2_dev *dev_extra;         /* extra data for the device */
 
1253
 
 
1254
        if (!serial) {
 
1255
                dbg("%s() enter port %d no serial object!", __func__,
 
1256
                        port->number);
 
1257
                return;
 
1258
        }
 
1259
        dbg("%s(): enter port %d", __func__, port->number);
 
1260
        dev_extra = qt2_get_dev_private(serial);
 
1261
        port_extra = qt2_get_port_private(port);
 
1262
        port0 = serial->port[0]; /* get the first port's device structure */
 
1263
 
 
1264
        mutex_lock(&port_extra->modelock);
 
1265
        if (!port_extra->open_count) {
 
1266
                dbg("%s(): port %d not open", __func__, port->number);
 
1267
                goto exit;
 
1268
        }
 
1269
 
 
1270
        if (port->throttled != 0) {
 
1271
                dbg("%s(): port %d: unsetting port->throttled", __func__,
 
1272
                    port->number);
 
1273
                port->throttled = 0;
 
1274
                /* Send command to box to start receiving stuff */
 
1275
                if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) {
 
1276
                        qt2_boxstoprx(serial,  port->number, 0);
 
1277
                } else if (dev_extra->ReadBulkStopped == true) {
 
1278
                        usb_fill_bulk_urb(port0->read_urb, serial->dev,
 
1279
                                usb_rcvbulkpipe(serial->dev,
 
1280
                                port0->bulk_in_endpointAddress),
 
1281
                                port0->bulk_in_buffer,
 
1282
                                port0->bulk_in_size,
 
1283
                                qt2_read_bulk_callback,
 
1284
                                serial);
 
1285
                }
 
1286
        }
 
1287
exit:
 
1288
        mutex_unlock(&port_extra->modelock);
 
1289
        dbg("%s(): exit port %d", __func__, port->number);
 
1290
        return;
 
1291
}
 
1292
 
 
1293
/* internal, private helper functions for the driver */
 
1294
 
 
1295
/* Power up the FPGA in the box to get it working */
 
1296
static int qt2_boxpoweron(struct usb_serial *serial)
 
1297
{
 
1298
        int result;
 
1299
        __u8  Direcion;
 
1300
        unsigned int pipe;
 
1301
        Direcion = USBD_TRANSFER_DIRECTION_OUT;
 
1302
        pipe = usb_rcvctrlpipe(serial->dev, 0);
 
1303
        result = usb_control_msg(serial->dev, pipe, QT_SET_GET_DEVICE,
 
1304
                                Direcion, QU2BOXPWRON, 0x00, NULL, 0x00,
 
1305
                                5000);
 
1306
        return result;
 
1307
}
 
1308
 
 
1309
/*
 
1310
 * qt2_boxsetQMCR Issue a QT2_GET_SET_QMCR vendor-spcific request on the
 
1311
 * default control pipe. If successful return the number of bytes written,
 
1312
 * otherwise return a negative error number of the problem.
 
1313
 */
 
1314
static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number,
 
1315
                          __u8 QMCR_Value)
 
1316
{
 
1317
        int result;
 
1318
        __u16 PortSettings;
 
1319
 
 
1320
        PortSettings = (__u16)(QMCR_Value);
 
1321
 
 
1322
        dbg("%s(): Port = %d, PortSettings = 0x%x", __func__,
 
1323
                        Uart_Number, PortSettings);
 
1324
 
 
1325
        result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1326
                                QT2_GET_SET_QMCR, 0x40, PortSettings,
 
1327
                                (__u16)Uart_Number, NULL, 0, 5000);
 
1328
        return result;
 
1329
}
 
1330
 
 
1331
static int port_paranoia_check(struct usb_serial_port *port,
 
1332
                               const char *function)
 
1333
{
 
1334
        if (!port) {
 
1335
                dbg("%s - port == NULL", function);
 
1336
                return -1;
 
1337
        }
 
1338
        if (!port->serial) {
 
1339
                dbg("%s - port->serial == NULL\n", function);
 
1340
                return -1;
 
1341
        }
 
1342
        return 0;
 
1343
}
 
1344
 
 
1345
static int serial_paranoia_check(struct usb_serial *serial,
 
1346
                                 const char *function)
 
1347
{
 
1348
        if (!serial) {
 
1349
                dbg("%s - serial == NULL\n", function);
 
1350
                return -1;
 
1351
        }
 
1352
 
 
1353
        if (!serial->type) {
 
1354
                dbg("%s - serial->type == NULL!", function);
 
1355
                return -1;
 
1356
        }
 
1357
 
 
1358
        return 0;
 
1359
}
 
1360
 
 
1361
static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port
 
1362
                *port)
 
1363
{
 
1364
        return (struct quatech2_port *)usb_get_serial_port_data(port);
 
1365
}
 
1366
 
 
1367
static inline void qt2_set_port_private(struct usb_serial_port *port,
 
1368
                struct quatech2_port *data)
 
1369
{
 
1370
        usb_set_serial_port_data(port, (void *)data);
 
1371
}
 
1372
 
 
1373
static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial
 
1374
                *serial)
 
1375
{
 
1376
        return (struct quatech2_dev *)usb_get_serial_data(serial);
 
1377
}
 
1378
static inline void qt2_set_dev_private(struct usb_serial *serial,
 
1379
                struct quatech2_dev *data)
 
1380
{
 
1381
        usb_set_serial_data(serial, (void *)data);
 
1382
}
 
1383
 
 
1384
static int qt2_openboxchannel(struct usb_serial *serial, __u16
 
1385
                Uart_Number, struct qt2_status_data *status)
 
1386
{
 
1387
        int result;
 
1388
        __u16 length;
 
1389
        __u8  Direcion;
 
1390
        unsigned int pipe;
 
1391
        length = sizeof(struct qt2_status_data);
 
1392
        Direcion = USBD_TRANSFER_DIRECTION_IN;
 
1393
        pipe = usb_rcvctrlpipe(serial->dev, 0);
 
1394
        result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
 
1395
                        Direcion, 0x00, Uart_Number, status, length, 5000);
 
1396
        return result;
 
1397
}
 
1398
static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number)
 
1399
{
 
1400
        int result;
 
1401
        __u8  direcion;
 
1402
        unsigned int pipe;
 
1403
        direcion = USBD_TRANSFER_DIRECTION_OUT;
 
1404
        pipe = usb_sndctrlpipe(serial->dev, 0);
 
1405
        result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
 
1406
                  direcion, 0, Uart_Number, NULL, 0, 5000);
 
1407
        return result;
 
1408
}
 
1409
 
 
1410
/* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default
 
1411
 * control pipe. If successful sets baud rate divisor and LCR value
 
1412
 */
 
1413
static int qt2_conf_uart(struct usb_serial *serial,  unsigned short Uart_Number,
 
1414
                      unsigned short divisor, unsigned char LCR)
 
1415
{
 
1416
        int result;
 
1417
        unsigned short UartNumandLCR;
 
1418
 
 
1419
        UartNumandLCR = (LCR << 8) + Uart_Number;
 
1420
 
 
1421
        result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1422
                                QT2_GET_SET_UART, 0x40, divisor, UartNumandLCR,
 
1423
                                NULL, 0, 300);
 
1424
        return result;
 
1425
}
 
1426
 
 
1427
/** @brief Callback for asynchronous submission of read URBs on bulk in
 
1428
 * endpoints
 
1429
 *
 
1430
 * Registered in qt2_open_port(), used to deal with incomming data
 
1431
 * from the box.
 
1432
 */
 
1433
static void qt2_read_bulk_callback(struct urb *urb)
 
1434
{
 
1435
        /* Get the device pointer (struct usb_serial) back out of the URB */
 
1436
        struct usb_serial *serial = urb->context;
 
1437
        /* get the extra struct for the device */
 
1438
        struct quatech2_dev *dev_extra = qt2_get_dev_private(serial);
 
1439
        /* Get first port structure from the device */
 
1440
        struct usb_serial_port *port0 = serial->port[0];
 
1441
        /* Get the currently active port structure from serial struct */
 
1442
        struct usb_serial_port *active = dev_extra->current_port;
 
1443
        /* get the extra struct for port 0 */
 
1444
        struct quatech2_port *port0_extra = qt2_get_port_private(port0);
 
1445
        /* and for the currently active port */
 
1446
        struct quatech2_port *active_extra = qt2_get_port_private(active);
 
1447
        /* When we finally get to doing some tty stuff, we will need this */
 
1448
        struct tty_struct *tty_st;
 
1449
        unsigned int RxCount;   /* the length of the data to process */
 
1450
        unsigned int i; /* loop counter over the data to process */
 
1451
        int result;     /* return value cache variable */
 
1452
        bool escapeflag;        /* flag set to true if this loop iteration is
 
1453
                                 * parsing an escape sequence, rather than
 
1454
                                 * ordinary data */
 
1455
        dbg("%s(): callback running, active port is %d", __func__,
 
1456
                active->number);
 
1457
 
 
1458
        if (urb->status) {
 
1459
                /* read didn't go well */
 
1460
                dev_extra->ReadBulkStopped = true;
 
1461
                dbg("%s(): nonzero bulk read status received: %d",
 
1462
                        __func__, urb->status);
 
1463
                return;
 
1464
        }
 
1465
 
 
1466
        /* inline port_sofrint() here */
 
1467
        if (port_paranoia_check(port0, __func__) != 0) {
 
1468
                dbg("%s - port_paranoia_check on port0 failed, exiting\n",
 
1469
__func__);
 
1470
                return;
 
1471
        }
 
1472
        if (port_paranoia_check(active, __func__) != 0) {
 
1473
                dbg("%s - port_paranoia_check on current_port "
 
1474
                        "failed, exiting", __func__);
 
1475
                return;
 
1476
        }
 
1477
 
 
1478
/* This single callback function has to do for all the ports on
 
1479
 * the device. Data being read up the USB can contain certain
 
1480
 * escape sequences which are used to communicate out-of-band
 
1481
 * information from the serial port in-band over the USB.
 
1482
 * These escapes include sending modem and flow control line
 
1483
 * status, and switching the port. The concept of a "Current Port"
 
1484
 * is used, which is where data is going until a port change
 
1485
 * escape seqence is received. This Current Port is kept between
 
1486
 * callbacks so that when this function enters we know which the
 
1487
 * currently active port is and can get to work right away without
 
1488
 * the box having to send repeat escape sequences (anyway, how
 
1489
 * would it know to do so?).
 
1490
 */
 
1491
 
 
1492
        if (active_extra->close_pending == true) {
 
1493
                /* We are closing , stop reading */
 
1494
                dbg("%s - (active->close_pending == true", __func__);
 
1495
                if (dev_extra->open_ports <= 0) {
 
1496
                        /* If this is the only port left open - stop the
 
1497
                         * bulk read */
 
1498
                        dev_extra->ReadBulkStopped = true;
 
1499
                        dbg("%s - (ReadBulkStopped == true;", __func__);
 
1500
                        return;
 
1501
                }
 
1502
        }
 
1503
 
 
1504
        /*
 
1505
         * RxHolding is asserted by throttle, if we assert it, we're not
 
1506
         * receiving any more characters and let the box handle the flow
 
1507
         * control
 
1508
         */
 
1509
        if ((port0_extra->RxHolding == true) &&
 
1510
                    (serial->dev->descriptor.idProduct == QUATECH_SSU2_100)) {
 
1511
                /* single port device, input is already stopped, so we don't
 
1512
                 * need any more input data */
 
1513
                dev_extra->ReadBulkStopped = true;
 
1514
                return;
 
1515
        }
 
1516
        /* finally, we are in a situation where we might consider the data
 
1517
         * that is contained within the URB, and what to do about it.
 
1518
         * This is likely to involved communicating up to the TTY layer, so
 
1519
         * we will need to get hold of the tty for the port we are currently
 
1520
         * dealing with */
 
1521
 
 
1522
        /* active is a usb_serial_port. It has a member port which is a
 
1523
         * tty_port. From this we get a tty_struct pointer which is what we
 
1524
         * actually wanted, and keep it on tty_st */
 
1525
        tty_st = tty_port_tty_get(&active->port);
 
1526
        if (!tty_st) {
 
1527
                dbg("%s - bad tty pointer - exiting", __func__);
 
1528
                return;
 
1529
        }
 
1530
        RxCount = urb->actual_length;   /* grab length of data handy */
 
1531
 
 
1532
        if (RxCount) {
 
1533
                /* skip all this if no data to process */
 
1534
                for (i = 0; i < RxCount ; ++i) {
 
1535
                        /* Look ahead code here -works on several bytes at onc*/
 
1536
                        if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b)
 
1537
                                && (NEXTCHAR == 0x1b)) {
 
1538
                                /* we are in an escape sequence, type
 
1539
                                 * determined by the 3rd char */
 
1540
                                escapeflag = false;
 
1541
                                switch (THIRDCHAR) {
 
1542
                                case 0x00:
 
1543
                                        /* Line status change 4th byte must
 
1544
                                         * follow */
 
1545
                                        if (i > (RxCount - 4)) {
 
1546
                                                dbg("Illegal escape sequences "
 
1547
                                                "in received data");
 
1548
                                                break;
 
1549
                                        }
 
1550
                                        qt2_process_line_status(active,
 
1551
                                                FOURTHCHAR);
 
1552
                                        i += 3;
 
1553
                                        escapeflag = true;
 
1554
                                        break;
 
1555
                                case 0x01:
 
1556
                                        /* Modem status status change 4th byte
 
1557
                                         * must follow */
 
1558
                                        if (i > (RxCount - 4)) {
 
1559
                                                dbg("Illegal escape sequences "
 
1560
                                                "in received data");
 
1561
                                                break;
 
1562
                                        }
 
1563
                                        qt2_process_modem_status(active,
 
1564
                                                FOURTHCHAR);
 
1565
                                        i += 3;
 
1566
                                        escapeflag = true;
 
1567
                                        break;
 
1568
                                case 0x02:
 
1569
                                        /* xmit hold empty 4th byte
 
1570
                                         * must follow */
 
1571
                                        if (i > (RxCount - 4)) {
 
1572
                                                dbg("Illegal escape sequences "
 
1573
                                                "in received data");
 
1574
                                                break;
 
1575
                                        }
 
1576
                                        qt2_process_xmit_empty(active,
 
1577
                                                FOURTHCHAR, FIFTHCHAR);
 
1578
                                        i += 4;
 
1579
                                        escapeflag = true;
 
1580
                                        break;
 
1581
                                case 0x03:
 
1582
                                        /* Port number change 4th byte
 
1583
                                         * must follow */
 
1584
                                        if (i > (RxCount - 4)) {
 
1585
                                                dbg("Illegal escape sequences "
 
1586
                                                "in received data");
 
1587
                                                break;
 
1588
                                        }
 
1589
                                        /* Port change. If port open push
 
1590
                                         * current data up to tty layer */
 
1591
                                        if (active_extra->open_count > 0)
 
1592
                                                tty_flip_buffer_push(tty_st);
 
1593
 
 
1594
                                        dbg("Port Change: new port = %d",
 
1595
                                                FOURTHCHAR);
 
1596
                                        qt2_process_port_change(active,
 
1597
                                                FOURTHCHAR);
 
1598
                                        i += 3;
 
1599
                                        escapeflag = true;
 
1600
                                        /* having changed port, the pointers for
 
1601
                                         * the currently active port are all out
 
1602
                                         * of date and need updating */
 
1603
                                        active = dev_extra->current_port;
 
1604
                                        active_extra =
 
1605
                                                qt2_get_port_private(active);
 
1606
                                        tty_st = tty_port_tty_get(
 
1607
                                                &active->port);
 
1608
                                        break;
 
1609
                                case 0x04:
 
1610
                                        /* Recv flush 3rd byte must
 
1611
                                         * follow */
 
1612
                                        if (i > (RxCount - 3)) {
 
1613
                                                dbg("Illegal escape sequences "
 
1614
                                                        "in received data");
 
1615
                                                break;
 
1616
                                        }
 
1617
                                        qt2_process_rcv_flush(active);
 
1618
                                        i += 2;
 
1619
                                        escapeflag = true;
 
1620
                                        break;
 
1621
                                case 0x05:
 
1622
                                        /* xmit flush 3rd byte must follow */
 
1623
                                        if (i > (RxCount - 3)) {
 
1624
                                                dbg("Illegal escape sequences "
 
1625
                                                "in received data");
 
1626
                                                break;
 
1627
                                        }
 
1628
                                        qt2_process_xmit_flush(active);
 
1629
                                        i += 2;
 
1630
                                        escapeflag = true;
 
1631
                                        break;
 
1632
                                case 0xff:
 
1633
                                        dbg("No status sequence");
 
1634
                                        qt2_process_rx_char(active, THISCHAR);
 
1635
                                        qt2_process_rx_char(active, NEXTCHAR);
 
1636
                                        i += 2;
 
1637
                                        break;
 
1638
                                default:
 
1639
                                        qt2_process_rx_char(active, THISCHAR);
 
1640
                                        i += 1;
 
1641
                                        break;
 
1642
                                } /*end switch*/
 
1643
                                if (escapeflag == true)
 
1644
                                        continue;
 
1645
                                /* if we did an escape char, we don't need
 
1646
                                 * to mess around pushing data through the
 
1647
                                 * tty layer, and can go round again */
 
1648
                        } /*endif*/
 
1649
                        if (tty_st && urb->actual_length) {
 
1650
                                tty_buffer_request_room(tty_st, 1);
 
1651
                                tty_insert_flip_string(tty_st, &(
 
1652
                                                (unsigned char *)
 
1653
                                                (urb->transfer_buffer)
 
1654
                                        )[i], 1);
 
1655
                        }
 
1656
                } /*endfor*/
 
1657
                tty_flip_buffer_push(tty_st);
 
1658
        } /*endif*/
 
1659
 
 
1660
        /* at this point we have complete dealing with the data for this
 
1661
         * callback. All we have to do now is to start the async read process
 
1662
         * back off again. */
 
1663
 
 
1664
        usb_fill_bulk_urb(port0->read_urb, serial->dev,
 
1665
                usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress),
 
1666
                port0->bulk_in_buffer, port0->bulk_in_size,
 
1667
                qt2_read_bulk_callback, serial);
 
1668
        result = usb_submit_urb(port0->read_urb, GFP_ATOMIC);
 
1669
        if (result) {
 
1670
                dbg("%s(): failed resubmitting read urb, error %d",
 
1671
                        __func__, result);
 
1672
        } else {
 
1673
                dbg("%s() successfully resubmitted read urb", __func__);
 
1674
                if (tty_st && RxCount) {
 
1675
                        /* if some inbound data was processed, then
 
1676
                         * we need to push that through the tty layer
 
1677
                         */
 
1678
                        tty_flip_buffer_push(tty_st);
 
1679
                        tty_schedule_flip(tty_st);
 
1680
                }
 
1681
        }
 
1682
 
 
1683
        /* cribbed from serqt_usb2 driver, but not sure which work needs
 
1684
         * scheduling - port0 or currently active port? */
 
1685
        /* schedule_work(&port->work); */
 
1686
        dbg("%s() completed", __func__);
 
1687
        return;
 
1688
}
 
1689
 
 
1690
/** @brief Callback for asynchronous submission of write URBs on bulk in
 
1691
 * endpoints
 
1692
 *
 
1693
 * Registered in qt2_write(), used to deal with outgoing data
 
1694
 * to the box.
 
1695
 */
 
1696
static void qt2_write_bulk_callback(struct urb *urb)
 
1697
{
 
1698
        struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 
1699
        struct usb_serial *serial = port->serial;
 
1700
        dbg("%s(): port %d", __func__, port->number);
 
1701
        if (!serial) {
 
1702
                dbg("%s(): bad serial pointer, exiting", __func__);
 
1703
                return;
 
1704
        }
 
1705
        if (urb->status) {
 
1706
                dbg("%s(): nonzero write bulk status received: %d",
 
1707
                        __func__, urb->status);
 
1708
                return;
 
1709
        }
 
1710
        /* FIXME What is supposed to be going on here?
 
1711
         * does this actually do anything useful, and should it?
 
1712
         */
 
1713
        /*port_softint((void *) serial); commented in vendor driver */
 
1714
        schedule_work(&port->work);
 
1715
        dbg("%s(): port %d exit", __func__, port->number);
 
1716
        return;
 
1717
}
 
1718
 
 
1719
static void qt2_process_line_status(struct usb_serial_port *port,
 
1720
        unsigned char LineStatus)
 
1721
{
 
1722
        /* obtain the private structure for the port */
 
1723
        struct quatech2_port *port_extra = qt2_get_port_private(port);
 
1724
        port_extra->shadowLSR = LineStatus & (QT2_SERIAL_LSR_OE |
 
1725
                QT2_SERIAL_LSR_PE | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI);
 
1726
}
 
1727
static void qt2_process_modem_status(struct usb_serial_port *port,
 
1728
        unsigned char ModemStatus)
 
1729
{
 
1730
        /* obtain the private structure for the port */
 
1731
        struct quatech2_port *port_extra = qt2_get_port_private(port);
 
1732
        port_extra->shadowMSR = ModemStatus;
 
1733
        wake_up_interruptible(&port_extra->wait);
 
1734
        /* this wakes up the otherwise indefinitely waiting code for
 
1735
         * the TIOCMIWAIT ioctl, so that it can notice that
 
1736
         * port_extra->shadowMSR has changed and the ioctl needs to return.
 
1737
         */
 
1738
}
 
1739
 
 
1740
static void qt2_process_xmit_empty(struct usb_serial_port *port,
 
1741
        unsigned char fourth_char, unsigned char fifth_char)
 
1742
{
 
1743
        int byte_count;
 
1744
        /* obtain the private structure for the port */
 
1745
        struct quatech2_port *port_extra = qt2_get_port_private(port);
 
1746
 
 
1747
        byte_count = (int)(fifth_char * 16);
 
1748
        byte_count +=  (int)fourth_char;
 
1749
        /* byte_count indicates how many bytes the device has written out. This
 
1750
         * message appears to occur regularly, and is used in the vendor driver
 
1751
         * to keep track of the fill state of the port transmit buffer */
 
1752
        port_extra->tx_pending_bytes -= byte_count;
 
1753
        /* reduce the stored data queue length by the known number of bytes
 
1754
         * sent */
 
1755
        dbg("port %d: %d bytes reported sent, %d still pending", port->number,
 
1756
                        byte_count, port_extra->tx_pending_bytes);
 
1757
 
 
1758
        /*port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; ???*/
 
1759
}
 
1760
 
 
1761
static void qt2_process_port_change(struct usb_serial_port *port,
 
1762
        unsigned char New_Current_Port)
 
1763
{
 
1764
        /* obtain the parent usb serial device structure */
 
1765
        struct usb_serial *serial = port->serial;
 
1766
        /* obtain the private structure for the device */
 
1767
        struct quatech2_dev *dev_extra = qt2_get_dev_private(serial);
 
1768
        dev_extra->current_port = serial->port[New_Current_Port];
 
1769
        /* what should I do with this? commented out in upstream
 
1770
         * driver */
 
1771
        /*schedule_work(&port->work);*/
 
1772
}
 
1773
 
 
1774
static void qt2_process_rcv_flush(struct usb_serial_port *port)
 
1775
{
 
1776
        /* obtain the private structure for the port */
 
1777
        struct quatech2_port *port_extra = qt2_get_port_private(port);
 
1778
        port_extra->rcv_flush = true;
 
1779
}
 
1780
static void qt2_process_xmit_flush(struct usb_serial_port *port)
 
1781
{
 
1782
        /* obtain the private structure for the port */
 
1783
        struct quatech2_port *port_extra = qt2_get_port_private(port);
 
1784
        port_extra->xmit_flush = true;
 
1785
}
 
1786
 
 
1787
static void qt2_process_rx_char(struct usb_serial_port *port,
 
1788
        unsigned char data)
 
1789
{
 
1790
        /* get the tty_struct for this port */
 
1791
        struct tty_struct *tty = tty_port_tty_get(&(port->port));
 
1792
        /* get the URB with the data in to push */
 
1793
        struct urb *urb = port->serial->port[0]->read_urb;
 
1794
 
 
1795
        if (tty && urb->actual_length) {
 
1796
                tty_buffer_request_room(tty, 1);
 
1797
                tty_insert_flip_string(tty, &data, 1);
 
1798
                /* should this be commented out here? */
 
1799
                /*tty_flip_buffer_push(tty);*/
 
1800
        }
 
1801
}
 
1802
 
 
1803
/** @brief Retrieve the value of a register from the device
 
1804
 *
 
1805
 * Issues a GET_REGISTER vendor-spcific request over the USB control
 
1806
 * pipe to obtain a value back from a specific register on a specific
 
1807
 * UART
 
1808
 * @param serial Serial device handle to access the device through
 
1809
 * @param uart_number Which UART the value is wanted from
 
1810
 * @param register_num Which register to read the value from
 
1811
 * @param pValue Pointer to somewhere to put the retrieved value
 
1812
 */
 
1813
static int qt2_box_get_register(struct usb_serial *serial,
 
1814
                unsigned char uart_number, unsigned short register_num,
 
1815
                __u8 *pValue)
 
1816
{
 
1817
        int result;
 
1818
        result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 
1819
                        QT2_GET_SET_REGISTER, 0xC0, register_num,
 
1820
                        uart_number, (void *)pValue, sizeof(*pValue), 300);
 
1821
        return result;
 
1822
}
 
1823
 
 
1824
/** qt2_box_set_register
 
1825
 * Issue a SET_REGISTER vendor-specific request on the default control pipe
 
1826
 */
 
1827
static int qt2_box_set_register(struct usb_serial *serial,
 
1828
                unsigned short Uart_Number, unsigned short Register_Num,
 
1829
                unsigned short Value)
 
1830
{
 
1831
        int result;
 
1832
        unsigned short reg_and_byte;
 
1833
 
 
1834
        reg_and_byte = Value;
 
1835
        reg_and_byte = reg_and_byte << 8;
 
1836
        reg_and_byte = reg_and_byte + Register_Num;
 
1837
 
 
1838
        result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1839
                        QT2_GET_SET_REGISTER, 0x40, reg_and_byte,
 
1840
                        Uart_Number, NULL, 0, 300);
 
1841
        return result;
 
1842
}
 
1843
 
 
1844
/** qt2_boxsetuart - Issue a SET_UART vendor-spcific request on the default
 
1845
 * control pipe. If successful sets baud rate divisor and LCR value.
 
1846
 */
 
1847
static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number,
 
1848
                unsigned short default_divisor, unsigned char default_LCR)
 
1849
{
 
1850
        unsigned short UartNumandLCR;
 
1851
 
 
1852
        UartNumandLCR = (default_LCR << 8) + Uart_Number;
 
1853
 
 
1854
        return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1855
                        QT2_GET_SET_UART, 0x40, default_divisor, UartNumandLCR,
 
1856
                        NULL, 0, 300);
 
1857
}
 
1858
 
 
1859
/** qt2_boxsethw_flowctl - Turn hardware (RTS/CTS) flow control on and off for
 
1860
 * a hardware UART.
 
1861
 */
 
1862
static int qt2_boxsethw_flowctl(struct usb_serial *serial,
 
1863
                unsigned int UartNumber, bool bSet)
 
1864
{
 
1865
        __u8 MCR_Value = 0;
 
1866
        __u8 MSR_Value = 0;
 
1867
        __u16 MOUT_Value = 0;
 
1868
 
 
1869
        if (bSet == true) {
 
1870
                MCR_Value =  QT2_SERIAL_MCR_RTS;
 
1871
                /* flow control, box will clear RTS line to prevent remote
 
1872
                 * device from transmitting more chars */
 
1873
        } else {
 
1874
                /* no flow control to remote device */
 
1875
                MCR_Value =  0;
 
1876
        }
 
1877
        MOUT_Value = MCR_Value << 8;
 
1878
 
 
1879
        if (bSet == true) {
 
1880
                MSR_Value = QT2_SERIAL_MSR_CTS;
 
1881
                /* flow control on, box will inhibit tx data if CTS line is
 
1882
                 * asserted */
 
1883
        } else {
 
1884
                /* Box will not inhibit tx data due to CTS line */
 
1885
                MSR_Value = 0;
 
1886
        }
 
1887
        MOUT_Value |= MSR_Value;
 
1888
        return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1889
                        QT2_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value, UartNumber,
 
1890
                        NULL, 0, 300);
 
1891
}
 
1892
 
 
1893
/** qt2_boxsetsw_flowctl - Turn software (XON/XOFF) flow control on for
 
1894
 * a hardware UART, and set the XON and XOFF characters.
 
1895
 */
 
1896
static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber,
 
1897
                        unsigned char stop_char,  unsigned char start_char)
 
1898
{
 
1899
        __u16 nSWflowout;
 
1900
 
 
1901
        nSWflowout = start_char << 8;
 
1902
        nSWflowout = (unsigned short)stop_char;
 
1903
        return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1904
                        QT2_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout, UartNumber,
 
1905
                        NULL, 0, 300);
 
1906
}
 
1907
 
 
1908
/** qt2_boxunsetsw_flowctl - Turn software (XON/XOFF) flow control off for
 
1909
 * a hardware UART.
 
1910
 */
 
1911
static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber)
 
1912
{
 
1913
        return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1914
                        QT2_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber, NULL,
 
1915
                        0, 300);
 
1916
}
 
1917
 
 
1918
/**
 
1919
 * qt2_boxstoprx - Start and stop reception of data by the FPGA UART in
 
1920
 * response to requests from the tty layer
 
1921
 * @serial: pointer to the usb_serial structure for the parent device
 
1922
 * @uart_number: which UART on the device we are addressing
 
1923
 * @stop: Whether to start or stop data reception. Set to 1 to stop data being
 
1924
 * received, and to 0 to start it being received.
 
1925
 */
 
1926
static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number,
 
1927
                unsigned short stop)
 
1928
{
 
1929
        return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 
1930
                QT2_STOP_RECEIVE, 0x40, stop, uart_number, NULL, 0, 300);
 
1931
}
 
1932
 
 
1933
 
 
1934
/*
 
1935
 * last things in file: stuff to register this driver into the generic
 
1936
 * USB serial framework.
 
1937
 */
 
1938
 
 
1939
static struct usb_serial_driver quatech2_device = {
 
1940
        .driver = {
 
1941
                .owner = THIS_MODULE,
 
1942
                .name = "quatech_usb2",
 
1943
        },
 
1944
        .description = DRIVER_DESC,
 
1945
        .usb_driver = &quausb2_usb_driver,
 
1946
        .id_table = quausb2_id_table,
 
1947
        .num_ports = 8,
 
1948
        .open = qt2_open,
 
1949
        .close = qt2_close,
 
1950
        .write = qt2_write,
 
1951
        .write_room = qt2_write_room,
 
1952
        .chars_in_buffer = qt2_chars_in_buffer,
 
1953
        .throttle = qt2_throttle,
 
1954
        .unthrottle = qt2_unthrottle,
 
1955
        .calc_num_ports = qt2_calc_num_ports,
 
1956
        .ioctl = qt2_ioctl,
 
1957
        .set_termios = qt2_set_termios,
 
1958
        .break_ctl = qt2_break,
 
1959
        .tiocmget = qt2_tiocmget,
 
1960
        .tiocmset = qt2_tiocmset,
 
1961
        .attach = qt2_attach,
 
1962
        .release = qt2_release,
 
1963
        .read_bulk_callback = qt2_read_bulk_callback,
 
1964
        .write_bulk_callback = qt2_write_bulk_callback,
 
1965
};
 
1966
 
 
1967
static int __init quausb2_usb_init(void)
 
1968
{
 
1969
        int retval;
 
1970
 
 
1971
        dbg("%s\n", __func__);
 
1972
 
 
1973
        /* register with usb-serial */
 
1974
        retval = usb_serial_register(&quatech2_device);
 
1975
 
 
1976
        if (retval)
 
1977
                goto failed_usb_serial_register;
 
1978
 
 
1979
        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 
1980
                        DRIVER_DESC "\n");
 
1981
 
 
1982
        /* register with usb */
 
1983
 
 
1984
        retval = usb_register(&quausb2_usb_driver);
 
1985
        if (retval == 0)
 
1986
                return 0;
 
1987
 
 
1988
        /* if we're here, usb_register() failed */
 
1989
        usb_serial_deregister(&quatech2_device);
 
1990
failed_usb_serial_register:
 
1991
                return retval;
 
1992
}
 
1993
 
 
1994
static void __exit quausb2_usb_exit(void)
 
1995
{
 
1996
        usb_deregister(&quausb2_usb_driver);
 
1997
        usb_serial_deregister(&quatech2_device);
 
1998
}
 
1999
 
 
2000
module_init(quausb2_usb_init);
 
2001
module_exit(quausb2_usb_exit);
 
2002
 
 
2003
MODULE_AUTHOR(DRIVER_AUTHOR);
 
2004
MODULE_DESCRIPTION(DRIVER_DESC);
 
2005
MODULE_LICENSE("GPL");
 
2006
 
 
2007
module_param(debug, bool, S_IRUGO | S_IWUSR);
 
2008
MODULE_PARM_DESC(debug, "Debug enabled or not");