?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
serqt: initial clean up pass for tty side
[linux-2.6/btrfs-unstable.git] / drivers / staging / serqt_usb / serqt_usb.c
blob234f332fc82fb813b21e92e7a851289d0ad7ea4f
1 /*
2 * This code was developed for the Quatech USB line for linux, it used
3 * much of the code developed by Greg Kroah-Hartman for USB serial devices
4 *
5 */
6
7 #include <linux/sched.h>
8 #include <linux/slab.h>
9 #include <linux/tty.h>
10 #include <linux/tty_flip.h>
11 #include <linux/module.h>
12 #include <linux/usb.h>
13 #include <linux/wait.h>
14 #include <linux/types.h>
15 #include <linux/version.h>
16 #include <linux/uaccess.h>
17
18 /* Use our own dbg macro */
19 /* #define DEBUG_ON */
20 /* #undef dbg */
21 #ifdef DEBUG_ON
22 #define mydbg(const...) printk(const)
23 #else
24 #define mydbg(const...)
25 #endif
26
27 /* parity check flag */
28 #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
29
30 #define SERIAL_TTY_MAJOR 0 /* Nice legal number now */
31 #define SERIAL_TTY_MINORS 255 /* loads of devices :) */
32 #define MAX_NUM_PORTS 8 /* The maximum number of ports one device can grab at once */
33 #define PREFUFF_LEVEL_CONSERVATIVE 128
34 #define ATC_DISABLED 0x00
35
36 #define RR_BITS 0x03 /* for clearing clock bits */
37 #define DUPMODE_BITS 0xc0
38
39 #define RS232_MODE 0x00
40 #define RTSCTS_TO_CONNECTOR 0x40
41 #define CLKS_X4 0x02
42
43 #define LOOPMODE_BITS 0x41 /* LOOP1 = b6, LOOP0 = b0 (PORT B) */
44 #define ALL_LOOPBACK 0x01
45 #define MODEM_CTRL 0x40
46
47 #define THISCHAR data[i]
48 #define NEXTCHAR data[i + 1]
49 #define THIRDCHAR data[i + 2]
50 #define FOURTHCHAR data[i + 3]
51
52 /*
53 * Useful defintions for port A, Port B and Port C
54 */
55 #define FULLPWRBIT 0x00000080
56 #define NEXT_BOARD_POWER_BIT 0x00000004
57
58 #define SERIAL_LSR_OE 0x02
59 #define SERIAL_LSR_PE 0x04
60 #define SERIAL_LSR_FE 0x08
61 #define SERIAL_LSR_BI 0x10
62
63 #define SERIAL_LSR_TEMT 0x40
64
65 #define DIV_LATCH_LS 0x00
66 #define XMT_HOLD_REGISTER 0x00
67 #define XVR_BUFFER_REGISTER 0x00
68 #define DIV_LATCH_MS 0x01
69 #define FIFO_CONTROL_REGISTER 0x02
70 #define LINE_CONTROL_REGISTER 0x03
71 #define MODEM_CONTROL_REGISTER 0x04
72 #define LINE_STATUS_REGISTER 0x05
73 #define MODEM_STATUS_REGISTER 0x06
74
75 #define SERIAL_MCR_DTR 0x01
76 #define SERIAL_MCR_RTS 0x02
77 #define SERIAL_MCR_LOOP 0x10
78
79 #define SERIAL_MSR_CTS 0x10
80 #define SERIAL_MSR_CD 0x80
81 #define SERIAL_MSR_RI 0x40
82 #define SERIAL_MSR_DSR 0x20
83 #define SERIAL_MSR_MASK 0xf0
84
85 #define SERIAL_8_DATA 0x03
86 #define SERIAL_7_DATA 0x02
87 #define SERIAL_6_DATA 0x01
88 #define SERIAL_5_DATA 0x00
89
90 #define SERIAL_ODD_PARITY 0X08
91 #define SERIAL_EVEN_PARITY 0X18
92 #define SERIAL_TWO_STOPB 0x04
93 #define SERIAL_ONE_STOPB 0x00
94
95 #define MAX_BAUD_RATE 460800
96 #define MAX_BAUD_REMAINDER 4608
97
98 #define QT_SET_GET_DEVICE 0xc2
99 #define QT_OPEN_CLOSE_CHANNEL 0xca
100 #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
101 #define QT_SET_ATF 0xcd
102 #define QT_GET_SET_REGISTER 0xc0
103 #define QT_GET_SET_UART 0xc1
104 #define QT_HW_FLOW_CONTROL_MASK 0xc5
105 #define QT_SW_FLOW_CONTROL_MASK 0xc6
106 #define QT_SW_FLOW_CONTROL_DISABLE 0xc7
107 #define QT_BREAK_CONTROL 0xc8
108
109 #define SERIALQT_PCI_IOC_MAGIC 'k'
110 #define SERIALQT_WRITE_QOPR _IOW(SERIALQT_PCI_IOC_MAGIC, 0, int)
111 #define SERIALQT_WRITE_QMCR _IOW(SERIALQT_PCI_IOC_MAGIC, 1, int)
112 #define SERIALQT_GET_NUMOF_UNITS _IOR(SERIALQT_PCI_IOC_MAGIC, 2, void *)
113 #define SERIALQT_GET_THIS_UNIT _IOR(SERIALQT_PCI_IOC_MAGIC, 3, void *)
114 #define SERIALQT_READ_QOPR _IOR(SERIALQT_PCI_IOC_MAGIC, 4, int)
115 #define SERIALQT_READ_QMCR _IOR(SERIALQT_PCI_IOC_MAGIC, 5, int)
116 #define SERIALQT_IS422_EXTENDED _IOR(SERIALQT_PCI_IOC_MAGIC, 6, int) /* returns successful if 422 extended */
117
118 #define USBD_TRANSFER_DIRECTION_IN 0xc0
119 #define USBD_TRANSFER_DIRECTION_OUT 0x40
120
121 #define ATC_DISABLED 0x00
122 #define ATC_RTS_ENABLED 0x02
123 #define ATC_DTR_ENABLED 0x01
124
125 #define RR_BITS 0x03 /* for clearing clock bits */
126 #define DUPMODE_BITS 0xc0
127
128 #define FULL_DUPLEX 0x00
129 #define HALF_DUPLEX_RTS 0x40
130 #define HALF_DUPLEX_DTR 0x80
131
132 #define QMCR_FULL_DUPLEX 0x00
133 #define QMCR_HALF_DUPLEX_RTS 0x02
134 #define QMCR_HALF_DUPLEX_DTR 0x01
135 #define QMCR_HALF_DUPLEX_MASK 0x03
136 #define QMCR_CONNECTOR_MASK 0x1C
137
138 #define QMCR_RX_EN_MASK 0x20
139
140 #define QMCR_ALL_LOOPBACK 0x10
141 #define QMCR_MODEM_CONTROL 0X00
142
143 #define SERIALQT_IOC_MAXNR 6
144
145 struct usb_serial_port {
146 struct usb_serial *serial; /* pointer back to the owner of this port */
147 struct tty_struct *tty; /* the coresponding tty for this port */
148 unsigned char number;
149 char active; /* someone has this device open */
150
151 unsigned char *interrupt_in_buffer;
152 struct urb *interrupt_in_urb;
153 __u8 interrupt_in_endpointAddress;
154
155 unsigned char *bulk_in_buffer;
156 unsigned char *xfer_to_tty_buffer;
157 struct urb *read_urb;
158 __u8 bulk_in_endpointAddress;
159
160 unsigned char *bulk_out_buffer;
161 int bulk_out_size;
162 struct urb *write_urb;
163 __u8 bulk_out_endpointAddress;
164
165 wait_queue_head_t write_wait;
166 wait_queue_head_t wait;
167 struct work_struct work;
168
169 int open_count; /* number of times this port has been opened */
170 struct semaphore sem; /* locks this structure */
171
172 __u8 shadowLCR; /* last LCR value received */
173 __u8 shadowMCR; /* last MCR value received */
174 __u8 shadowMSR; /* last MSR value received */
175 __u8 shadowLSR; /* last LSR value received */
176 int RxHolding;
177 char closePending;
178 int ReadBulkStopped;
179
180 void *private; /* data private to the specific port */
181 };
182
183 struct identity {
184 int index;
185 int n_identity;
186 };
187
188 struct usb_serial {
189 struct usb_device *dev;
190 struct usb_interface *interface; /* the interface for this device */
191 struct tty_driver *tty_driver; /* the tty_driver for this device */
192 unsigned char minor; /* the starting minor number for this device */
193 unsigned char num_ports; /* the number of ports this device has */
194 char num_interrupt_in; /* number of interrupt in endpoints we have */
195 char num_bulk_in; /* number of bulk in endpoints we have */
196 char num_bulk_out; /* number of bulk out endpoints we have */
197 unsigned char num_OpenCount; /* the number of ports this device has */
198
199 __u16 vendor; /* vendor id of this device */
200 __u16 product; /* product id of this device */
201 struct usb_serial_port port[MAX_NUM_PORTS];
202
203 void *private; /* data private to the specific driver */
204 };
205
206 static inline int port_paranoia_check(struct usb_serial_port *port,
207 const char *function)
208 {
209 if (!port) {
210 dbg("%s - port == NULL", function);
211 return -1;
212 }
213 if (!port->serial) {
214 dbg("%s - port->serial == NULL\n", function);
215 return -1;
216 }
217 if (!port->tty) {
218 dbg("%s - port->tty == NULL\n", function);
219 return -1;
220 }
221
222 return 0;
223 }
224
225 /* Inline functions to check the sanity of a pointer that is passed to us */
226 static inline int serial_paranoia_check(struct usb_serial *serial,
227 const char *function)
228 {
229 if (!serial) {
230 dbg("%s - serial == NULL\n", function);
231 return -1;
232 }
233
234 return 0;
235 }
236
237 static inline struct usb_serial *get_usb_serial(struct usb_serial_port *port,
238 const char *function)
239 {
240 /* if no port was specified, or it fails a paranoia check */
241 if (!port ||
242 port_paranoia_check(port, function) ||
243 serial_paranoia_check(port->serial, function)) {
244 /* then say that we dont have a valid usb_serial thing, which will
245 * end up genrating -ENODEV return values */
246 return NULL;
247 }
248
249 return port->serial;
250 }
251
252 struct qt_get_device_data {
253 __u8 porta;
254 __u8 portb;
255 __u8 portc;
256 };
257
258 struct qt_open_channel_data {
259 __u8 line_status;
260 __u8 modem_status;
261 };
262
263 static void ProcessLineStatus(struct usb_serial_port *port,
264 unsigned char line_status);
265 static void ProcessModemStatus(struct usb_serial_port *port,
266 unsigned char modem_status);
267 static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data);
268 static struct usb_serial *get_free_serial(int num_ports, int *minor);
269
270 static int serqt_probe(struct usb_interface *interface,
271 const struct usb_device_id *id);
272
273 static void serqt_usb_disconnect(struct usb_interface *interface);
274 static int box_set_device(struct usb_serial *serial,
275 struct qt_get_device_data *pDeviceData);
276 static int box_get_device(struct usb_serial *serial,
277 struct qt_get_device_data *pDeviceData);
278 static int serial_open(struct tty_struct *tty, struct file *filp);
279 static void serial_close(struct tty_struct *tty, struct file *filp);
280 static int serial_write_room(struct tty_struct *tty);
281 static int serial_ioctl(struct tty_struct *tty, struct file *file,
282 unsigned int cmd, unsigned long arg);
283 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old);
284 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
285 int count);
286
287 static void serial_throttle(struct tty_struct *tty);
288 static void serial_unthrottle(struct tty_struct *tty);
289 static int serial_break(struct tty_struct *tty, int break_state);
290 static int serial_chars_in_buffer(struct tty_struct *tty);
291
292 static int qt_open(struct tty_struct *tty, struct usb_serial_port *port,
293 struct file *filp);
294 static int BoxSetPrebufferLevel(struct usb_serial *serial);
295
296 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode);
297 static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
298 unsigned short default_divisor,
299 unsigned char default_LCR);
300
301 static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
302 __u16 OpenClose,
303 struct qt_open_channel_data *pDeviceData);
304 static void qt_close(struct tty_struct *tty, struct usb_serial_port *port,
305 struct file *filp);
306 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
307 unsigned short Register_Num, __u8 *pValue);
308 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
309 unsigned short Register_Num, unsigned short Value);
310 static void qt_write_bulk_callback(struct urb *urb);
311 static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
312 const unsigned char *buf, int count);
313 static void port_softint(struct work_struct *work);
314 static int qt_write_room(struct usb_serial_port *port);
315 static int qt_chars_in_buffer(struct usb_serial_port *port);
316 static int qt_ioctl(struct tty_struct *tty, struct usb_serial_port *port,
317 struct file *file, unsigned int cmd, unsigned long arg);
318 static void qt_set_termios(struct tty_struct *tty,
319 struct usb_serial_port *port,
320 struct ktermios *old_termios);
321 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
322 int bSet);
323 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index);
324 static int EmulateWriteQMCR_Reg(int index, unsigned uc_value);
325 static int EmulateReadQMCR_Reg(int index, unsigned *uc_value);
326 static struct usb_serial *find_the_box(unsigned int index);
327 static int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
328 unsigned long arg);
329
330 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 Uart,
331 unsigned char stop_char, unsigned char start_char);
332 static void qt_read_bulk_callback(struct urb *urb);
333
334 static void port_sofrint(void *private);
335
336 static void return_serial(struct usb_serial *serial);
337
338 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
339 unsigned int set, unsigned int clear);
340 static int serial_tiocmget(struct tty_struct *tty, struct file *file);
341
342 static int qt_tiocmset(struct tty_struct *tty, struct usb_serial_port *port,
343 struct file *file, unsigned int value);
344
345 static int qt_tiocmget(struct tty_struct *tty, struct usb_serial_port *port,
346 struct file *file);
347
348 /* Version Information */
349 #define DRIVER_VERSION "v2.14"
350 #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
351 #define DRIVER_DESC "Quatech USB to Serial Driver"
352
353 #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
354 #define DEVICE_ID_QUATECH_RS232_SINGLE_PORT 0xC020 /* SSU100 */
355 #define DEVICE_ID_QUATECH_RS422_SINGLE_PORT 0xC030 /* SSU200 */
356 #define DEVICE_ID_QUATECH_RS232_DUAL_PORT 0xC040 /* DSU100 */
357 #define DEVICE_ID_QUATECH_RS422_DUAL_PORT 0xC050 /* DSU200 */
358 #define DEVICE_ID_QUATECH_RS232_FOUR_PORT 0xC060 /* QSU100 */
359 #define DEVICE_ID_QUATECH_RS422_FOUR_PORT 0xC070 /* QSU200 */
360 #define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A 0xC080 /* ESU100A */
361 #define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B 0xC081 /* ESU100B */
362 #define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A 0xC0A0 /* ESU200A */
363 #define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B 0xC0A1 /* ESU200B */
364 #define DEVICE_ID_QUATECH_RS232_16_PORT_A 0xC090 /* HSU100A */
365 #define DEVICE_ID_QUATECH_RS232_16_PORT_B 0xC091 /* HSU100B */
366 #define DEVICE_ID_QUATECH_RS232_16_PORT_C 0xC092 /* HSU100C */
367 #define DEVICE_ID_QUATECH_RS232_16_PORT_D 0xC093 /* HSU100D */
368 #define DEVICE_ID_QUATECH_RS422_16_PORT_A 0xC0B0 /* HSU200A */
369 #define DEVICE_ID_QUATECH_RS422_16_PORT_B 0xC0B1 /* HSU200B */
370 #define DEVICE_ID_QUATECH_RS422_16_PORT_C 0xC0B2 /* HSU200C */
371 #define DEVICE_ID_QUATECH_RS422_16_PORT_D 0xC0B3 /* HSU200D */
372
373 /* table of Quatech devices */
374 static struct usb_device_id serqt_table[] = {
375 {USB_DEVICE
376 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_SINGLE_PORT)},
377 {USB_DEVICE
378 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_SINGLE_PORT)},
379 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_DUAL_PORT)},
380 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_DUAL_PORT)},
381 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_FOUR_PORT)},
382 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_FOUR_PORT)},
383 {USB_DEVICE
384 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A)},
385 {USB_DEVICE
386 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B)},
387 {USB_DEVICE
388 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A)},
389 {USB_DEVICE
390 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B)},
391 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_A)},
392 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_B)},
393 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_C)},
394 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_D)},
395 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_A)},
396 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_B)},
397 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_C)},
398 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_D)},
399 {} /* Terminating entry */
400 };
401
402 MODULE_DEVICE_TABLE(usb, serqt_table);
403
404 static int major_number;
405 static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
406
407 /* table of Quatech 422devices */
408 static unsigned int serqt_422_table[] = {
409 DEVICE_ID_QUATECH_RS422_SINGLE_PORT,
410 DEVICE_ID_QUATECH_RS422_DUAL_PORT,
411 DEVICE_ID_QUATECH_RS422_FOUR_PORT,
412 DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A,
413 DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B,
414 DEVICE_ID_QUATECH_RS422_16_PORT_A,
415 DEVICE_ID_QUATECH_RS422_16_PORT_B,
416 DEVICE_ID_QUATECH_RS422_16_PORT_C,
417 DEVICE_ID_QUATECH_RS422_16_PORT_D,
418 0 /* terminate with zero */
419 };
420
421 /* usb specific object needed to register this driver with the usb subsystem */
422 static struct usb_driver serqt_usb_driver = {
423 .name = "quatech-usb-serial",
424 .probe = serqt_probe,
425 .disconnect = serqt_usb_disconnect,
426 .id_table = serqt_table,
427 };
428
429 static struct ktermios *serial_termios[SERIAL_TTY_MINORS];
430 static struct ktermios *serial_termios_locked[SERIAL_TTY_MINORS];
431
432 static const struct tty_operations serial_ops = {
433 .open = serial_open,
434 .close = serial_close,
435 .write = serial_write,
436 .write_room = serial_write_room,
437 .ioctl = serial_ioctl,
438 .set_termios = serial_set_termios,
439 .throttle = serial_throttle,
440 .unthrottle = serial_unthrottle,
441 .break_ctl = serial_break,
442 .chars_in_buffer = serial_chars_in_buffer,
443 .tiocmset = serial_tiocmset,
444 .tiocmget = serial_tiocmget,
445 };
446
447 static struct tty_driver serial_tty_driver = {
448 .magic = TTY_DRIVER_MAGIC,
449 .driver_name = "Quatech usb-serial",
450 .name = "ttyQT_USB",
451 .major = SERIAL_TTY_MAJOR,
452 .minor_start = 0,
453 .num = SERIAL_TTY_MINORS,
454 .type = TTY_DRIVER_TYPE_SERIAL,
455 .subtype = SERIAL_TYPE_NORMAL,
456 .flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV,
457
458 .termios = serial_termios,
459 .termios_locked = serial_termios_locked,
460 .init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL,
461
462 .init_termios.c_iflag = ICRNL | IXON,
463 .init_termios.c_oflag = OPOST,
464
465 .init_termios.c_lflag =
466 ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN,
467 };
468
469 /* fops for parent device */
470 static const struct file_operations serialqt_usb_fops = {
471 .ioctl = ioctl_serial_usb,
472 };
473
474 /**
475 * serqt_probe
476 *
477 * Called by the usb core when a new device is connected that it thinks
478 * this driver might be interested in.
479 *
480 */
481 static int serqt_probe(struct usb_interface *interface,
482 const struct usb_device_id *id)
483 {
484 struct usb_device *dev = interface_to_usbdev(interface);
485 struct usb_serial *serial = NULL;
486 struct usb_serial_port *port;
487 struct usb_endpoint_descriptor *endpoint;
488 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
489 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
490 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
491 int minor;
492 int buffer_size;
493 int i;
494 struct usb_host_interface *iface_desc;
495 int num_interrupt_in = 0;
496 int num_bulk_in = 0;
497 int num_bulk_out = 0;
498 int num_ports;
499 struct qt_get_device_data DeviceData;
500 int status;
501
502 mydbg("In %s\n", __func__);
503
504 /* let's find the endpoints needed */
505 /* check out the endpoints */
506 iface_desc = interface->cur_altsetting;;
507 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
508 endpoint = &iface_desc->endpoint[i].desc;
509
510 if ((endpoint->bEndpointAddress & 0x80) &&
511 ((endpoint->bmAttributes & 3) == 0x02)) {
512 /* we found a bulk in endpoint */
513 mydbg("found bulk in");
514 bulk_in_endpoint[num_bulk_in] = endpoint;
515 ++num_bulk_in;
516 }
517
518 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
519 ((endpoint->bmAttributes & 3) == 0x02)) {
520 /* we found a bulk out endpoint */
521 mydbg("found bulk out\n");
522 bulk_out_endpoint[num_bulk_out] = endpoint;
523 ++num_bulk_out;
524 }
525
526 if ((endpoint->bEndpointAddress & 0x80) &&
527 ((endpoint->bmAttributes & 3) == 0x03)) {
528 /* we found a interrupt in endpoint */
529 mydbg("found interrupt in\n");
530 interrupt_in_endpoint[num_interrupt_in] = endpoint;
531 ++num_interrupt_in;
532 }
533 }
534
535 /* found all that we need */
536 dev_info(&interface->dev, "Quatech converter detected\n");
537 num_ports = num_bulk_out;
538 if (num_ports == 0) {
539 err("Quatech device with no bulk out, not allowed.");
540 return -ENODEV;
541
542 }
543
544 serial = get_free_serial(num_ports, &minor);
545 if (serial == NULL) {
546 err("No more free serial devices");
547 return -ENODEV;
548 }
549
550 serial->dev = dev;
551 serial->interface = interface;
552 serial->minor = minor;
553 serial->num_ports = num_ports;
554 serial->num_bulk_in = num_bulk_in;
555 serial->num_bulk_out = num_bulk_out;
556 serial->num_interrupt_in = num_interrupt_in;
557 serial->vendor = dev->descriptor.idVendor;
558 serial->product = dev->descriptor.idProduct;
559
560 /* set up the endpoint information */
561 for (i = 0; i < num_bulk_in; ++i) {
562 endpoint = bulk_in_endpoint[i];
563 port = &serial->port[i];
564 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
565 if (!port->read_urb) {
566 err("No free urbs available");
567 goto probe_error;
568 }
569 buffer_size = endpoint->wMaxPacketSize;
570 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
571 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
572 port->xfer_to_tty_buffer = kmalloc(buffer_size, GFP_KERNEL);
573 if (!port->bulk_in_buffer) {
574 err("Couldn't allocate bulk_in_buffer");
575 goto probe_error;
576 }
577 usb_fill_bulk_urb(port->read_urb, dev,
578 usb_rcvbulkpipe(dev,
579 endpoint->bEndpointAddress),
580 port->bulk_in_buffer, buffer_size,
581 qt_read_bulk_callback, port);
582 }
583
584 for (i = 0; i < num_bulk_out; ++i) {
585 endpoint = bulk_out_endpoint[i];
586 port = &serial->port[i];
587 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
588 if (!port->write_urb) {
589 err("No free urbs available");
590 goto probe_error;
591 }
592 buffer_size = endpoint->wMaxPacketSize;
593 port->bulk_out_size = buffer_size;
594 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
595 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
596 if (!port->bulk_out_buffer) {
597 err("Couldn't allocate bulk_out_buffer");
598 goto probe_error;
599 }
600 usb_fill_bulk_urb(port->write_urb, dev,
601 usb_sndbulkpipe(dev,
602 endpoint->bEndpointAddress),
603 port->bulk_out_buffer, buffer_size,
604 qt_write_bulk_callback, port);
605
606 }
607
608 /* For us numb of bulkin or out = number of ports */
609 mydbg("%s - setting up %d port structures for this device\n",
610 __func__, num_bulk_in);
611 for (i = 0; i < num_bulk_in; ++i) {
612 port = &serial->port[i];
613 port->number = i + serial->minor;
614 port->serial = serial;
615
616 INIT_WORK(&port->work, port_softint);
617
618 init_MUTEX(&port->sem);
619
620 }
621 status = box_get_device(serial, &DeviceData);
622 if (status < 0) {
623 mydbg(__FILE__ "box_get_device failed");
624 goto probe_error;
625 }
626
627 mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
628
629 DeviceData.portb &= ~FULLPWRBIT;
630 mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
631
632 status = box_set_device(serial, &DeviceData);
633 if (status < 0) {
634 mydbg(__FILE__ "box_set_device failed\n");
635 goto probe_error;
636 }
637
638 /* initialize the devfs nodes for this device and let the user know what ports we are bound to */
639 for (i = 0; i < serial->num_ports; ++i) {
640 dev_info(&interface->dev,
641 "Converter now attached to ttyUSB%d (or usb/tts/%d for devfs)",
642 serial->port[i].number, serial->port[i].number);
643 }
644
645 /* usb_serial_console_init (debug, minor); */
646
647 /***********TAG add start next board here ****/
648 status = box_get_device(serial, &DeviceData);
649 if (status < 0) {
650 mydbg(__FILE__ "box_get_device failed");
651 goto probe_error;
652 }
653 /*
654 * and before we power up lets initialiaze parnent device stuff here before
655 * we set thmem via any other method such as the property pages
656 */
657 switch (serial->product) {
658 case DEVICE_ID_QUATECH_RS232_SINGLE_PORT:
659 case DEVICE_ID_QUATECH_RS232_DUAL_PORT:
660 case DEVICE_ID_QUATECH_RS232_FOUR_PORT:
661 case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A:
662 case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B:
663 case DEVICE_ID_QUATECH_RS232_16_PORT_A:
664 case DEVICE_ID_QUATECH_RS232_16_PORT_B:
665 case DEVICE_ID_QUATECH_RS232_16_PORT_C:
666 case DEVICE_ID_QUATECH_RS232_16_PORT_D:
667 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
668 DeviceData.porta |= CLKS_X4;
669 DeviceData.portb &= ~(LOOPMODE_BITS);
670 DeviceData.portb |= RS232_MODE;
671 break;
672
673 case DEVICE_ID_QUATECH_RS422_SINGLE_PORT:
674 case DEVICE_ID_QUATECH_RS422_DUAL_PORT:
675 case DEVICE_ID_QUATECH_RS422_FOUR_PORT:
676 case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A:
677 case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B:
678 case DEVICE_ID_QUATECH_RS422_16_PORT_A:
679 case DEVICE_ID_QUATECH_RS422_16_PORT_B:
680 case DEVICE_ID_QUATECH_RS422_16_PORT_C:
681 case DEVICE_ID_QUATECH_RS422_16_PORT_D:
682 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
683 DeviceData.porta |= CLKS_X4;
684 DeviceData.portb &= ~(LOOPMODE_BITS);
685 DeviceData.portb |= ALL_LOOPBACK;
686 break;
687 default:
688 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
689 DeviceData.porta |= CLKS_X4;
690 DeviceData.portb &= ~(LOOPMODE_BITS);
691 DeviceData.portb |= RS232_MODE;
692 break;
693
694 }
695 status = BoxSetPrebufferLevel(serial); /* sets to default vaue */
696 if (status < 0) {
697 mydbg(__FILE__ "BoxSetPrebufferLevel failed\n");
698 goto probe_error;
699 }
700
701 status = BoxSetATC(serial, ATC_DISABLED);
702 if (status < 0) {
703 mydbg(__FILE__ "BoxSetATC failed\n");
704 goto probe_error;
705 }
706 /**********************************************************/
707 mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
708
709 DeviceData.portb |= NEXT_BOARD_POWER_BIT;
710 mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
711
712 status = box_set_device(serial, &DeviceData);
713 if (status < 0) {
714 mydbg(__FILE__ "box_set_device failed\n");
715 goto probe_error;
716 }
717
718 mydbg("Exit Success %s\n", __func__);
719
720 usb_set_intfdata(interface, serial);
721 return 0;
722
723 probe_error:
724
725 for (i = 0; i < num_bulk_in; ++i) {
726 port = &serial->port[i];
727 usb_free_urb(port->read_urb);
728 kfree(port->bulk_in_buffer);
729 }
730 for (i = 0; i < num_bulk_out; ++i) {
731 port = &serial->port[i];
732 usb_free_urb(port->write_urb);
733 kfree(port->bulk_out_buffer);
734 kfree(port->xfer_to_tty_buffer);
735 }
736 for (i = 0; i < num_interrupt_in; ++i) {
737 port = &serial->port[i];
738 usb_free_urb(port->interrupt_in_urb);
739 kfree(port->interrupt_in_buffer);
740 }
741
742 /* return the minor range that this device had */
743 return_serial(serial);
744 mydbg("Exit fail %s\n", __func__);
745
746 /* free up any memory that we allocated */
747 kfree(serial);
748 return -EIO;
749 }
750
751 /*
752 * returns the serial_table array pointers that are taken
753 * up in consecutive positions for each port to a common usb_serial structure
754 * back to NULL
755 */
756 static void return_serial(struct usb_serial *serial)
757 {
758 int i;
759
760 mydbg("%s\n", __func__);
761
762 if (serial == NULL)
763 return;
764
765 for (i = 0; i < serial->num_ports; ++i)
766 serial_table[serial->minor + i] = NULL;
767
768 return;
769 }
770
771 /*
772 * Finds the first locatio int the serial_table array where it can fit
773 * num_ports number of consecutive points to a common usb_serial
774 * structure,allocates a stucture points to it in all the structures, and
775 * returns the index to the first location in the array in the "minor"
776 * variable.
777 */
778 static struct usb_serial *get_free_serial(int num_ports, int *minor)
779 {
780 struct usb_serial *serial = NULL;
781 int i, j;
782 int good_spot;
783
784 mydbg("%s %d\n", __func__, num_ports);
785
786 *minor = 0;
787 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
788 if (serial_table[i])
789 continue;
790
791 good_spot = 1;
792 /*
793 * find a spot in the array where you can fit consecutive
794 * positions to put the pointers to the usb_serail allocated
795 * structure for all the minor numbers (ie. ports)
796 */
797 for (j = 1; j <= num_ports - 1; ++j)
798 if (serial_table[i + j])
799 good_spot = 0;
800 if (good_spot == 0)
801 continue;
802
803 serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL);
804 if (!serial) {
805 err("%s - Out of memory", __func__);
806 return NULL;
807 }
808 memset(serial, 0, sizeof(struct usb_serial));
809 serial_table[i] = serial;
810 *minor = i;
811 mydbg("%s - minor base = %d\n", __func__, *minor);
812
813 /*
814 * copy in the pointer into the array starting a the *minor
815 * position minor is the index into the array.
816 */
817 for (i = *minor + 1;
818 (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
819 serial_table[i] = serial;
820 return serial;
821 }
822 return NULL;
823 }
824
825 static int flip_that(struct tty_struct *tty, __u16 index,
826 struct usb_serial *serial)
827 {
828 tty_flip_buffer_push(tty);
829 tty_schedule_flip(tty);
830 return 0;
831 }
832
833 /* Handles processing and moving data to the tty layer */
834 static void port_sofrint(void *private)
835 {
836 struct usb_serial_port *port = private;
837 struct usb_serial *serial = get_usb_serial(port, __func__);
838 struct tty_struct *tty = port->tty;
839 unsigned char *data = port->read_urb->transfer_buffer;
840 unsigned int index;
841 struct urb *urb = port->read_urb;
842 unsigned int RxCount = urb->actual_length;
843 int i, result;
844 int flag, flag_data;
845
846 /* index = MINOR(port->tty->device) - serial->minor; */
847 index = tty->index - serial->minor;
848
849 mydbg("%s - port %d\n", __func__, port->number);
850 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
851
852 if (port_paranoia_check(port, __func__) != 0) {
853 mydbg("%s - port_paranoia_check, exiting\n", __func__);
854 port->ReadBulkStopped = 1;
855 return;
856 }
857
858 if (!serial) {
859 mydbg("%s - bad serial pointer, exiting\n", __func__);
860 return;
861 }
862 if (port->closePending == 1) {
863 /* Were closing , stop reading */
864 mydbg("%s - (port->closepending == 1\n", __func__);
865 port->ReadBulkStopped = 1;
866 return;
867 }
868
869 /*
870 * RxHolding is asserted by throttle, if we assert it, we're not
871 * receiving any more characters and let the box handle the flow
872 * control
873 */
874 if (port->RxHolding == 1) {
875 port->ReadBulkStopped = 1;
876 return;
877 }
878
879 if (urb->status) {
880 port->ReadBulkStopped = 1;
881
882 mydbg("%s - nonzero read bulk status received: %d\n",
883 __func__, urb->status);
884 return;
885 }
886
887 tty = port->tty;
888 mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
889
890 if (tty && RxCount) {
891 flag_data = 0;
892 for (i = 0; i < RxCount; ++i) {
893 /* Look ahead code here */
894 if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b)
895 && (NEXTCHAR == 0x1b)) {
896 flag = 0;
897 switch (THIRDCHAR) {
898 case 0x00:
899 /* Line status change 4th byte must follow */
900 if (i > (RxCount - 4)) {
901 mydbg("Illegal escape sequences in received data\n");
902 break;
903 }
904 ProcessLineStatus(port, FOURTHCHAR);
905 i += 3;
906 flag = 1;
907 break;
908
909 case 0x01:
910 /* Modem status status change 4th byte must follow */
911 mydbg("Modem status status. \n");
912 if (i > (RxCount - 4)) {
913 mydbg
914 ("Illegal escape sequences in received data\n");
915 break;
916 }
917 ProcessModemStatus(port, FOURTHCHAR);
918 i += 3;
919 flag = 1;
920 break;
921 case 0xff:
922 mydbg("No status sequence. \n");
923
924 ProcessRxChar(port, THISCHAR);
925 ProcessRxChar(port, NEXTCHAR);
926 i += 2;
927 break;
928 }
929 if (flag == 1)
930 continue;
931 }
932
933 if (tty && urb->actual_length) {
934 tty_buffer_request_room(tty, 1);
935 tty_insert_flip_string(tty, (data + i), 1);
936 }
937
938 }
939 tty_flip_buffer_push(tty);
940 }
941
942 /* Continue trying to always read */
943 usb_fill_bulk_urb(port->read_urb, serial->dev,
944 usb_rcvbulkpipe(serial->dev,
945 port->bulk_in_endpointAddress),
946 port->read_urb->transfer_buffer,
947 port->read_urb->transfer_buffer_length,
948 qt_read_bulk_callback, port);
949 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
950 if (result)
951 mydbg("%s - failed resubmitting read urb, error %d",
952 __func__, result);
953 else {
954 if (tty && RxCount)
955 flip_that(tty, index, serial);
956 }
957
958 return;
959
960 }
961
962 static void qt_read_bulk_callback(struct urb *urb)
963 {
964
965 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
966
967 if (urb->status) {
968 port->ReadBulkStopped = 1;
969 mydbg("%s - nonzero write bulk status received: %d\n",
970 __func__, urb->status);
971 return;
972 }
973
974 port_sofrint((void *)port);
975 schedule_work(&port->work);
976 }
977
978 static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data)
979 {
980 struct tty_struct *tty;
981 struct urb *urb = port->read_urb;
982 tty = port->tty;
983 /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
984
985 if (tty && urb->actual_length) {
986 tty_buffer_request_room(tty, 1);
987 tty_insert_flip_string(tty, &Data, 1);
988 /* tty_flip_buffer_push(tty); */
989 }
990
991 return;
992 }
993
994 static void ProcessLineStatus(struct usb_serial_port *port,
995 unsigned char line_status)
996 {
997
998 port->shadowLSR =
999 line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
1000 SERIAL_LSR_BI);
1001 return;
1002 }
1003
1004 static void ProcessModemStatus(struct usb_serial_port *port,
1005 unsigned char modem_status)
1006 {
1007
1008 port->shadowMSR = modem_status;
1009 wake_up_interruptible(&port->wait);
1010 return;
1011 }
1012
1013 static void serqt_usb_disconnect(struct usb_interface *interface)
1014 {
1015 struct usb_serial *serial = usb_get_intfdata(interface);
1016 /* struct device *dev = &interface->dev; */
1017 struct usb_serial_port *port;
1018 int i;
1019
1020 mydbg("%s\n", __func__);
1021 if (serial) {
1022
1023 serial->dev = NULL;
1024
1025 for (i = 0; i < serial->num_ports; ++i)
1026 serial->port[i].open_count = 0;
1027
1028 for (i = 0; i < serial->num_bulk_in; ++i) {
1029 port = &serial->port[i];
1030 usb_unlink_urb(port->read_urb);
1031 usb_free_urb(port->read_urb);
1032 kfree(port->bulk_in_buffer);
1033 }
1034 for (i = 0; i < serial->num_bulk_out; ++i) {
1035 port = &serial->port[i];
1036 usb_unlink_urb(port->write_urb);
1037 usb_free_urb(port->write_urb);
1038 kfree(port->bulk_out_buffer);
1039 }
1040 for (i = 0; i < serial->num_interrupt_in; ++i) {
1041 port = &serial->port[i];
1042 usb_unlink_urb(port->interrupt_in_urb);
1043 usb_free_urb(port->interrupt_in_urb);
1044 kfree(port->interrupt_in_buffer);
1045 }
1046
1047 /* return the minor range that this device had */
1048 return_serial(serial);
1049
1050 /* free up any memory that we allocated */
1051 kfree(serial);
1052
1053 } else {
1054 dev_info(&interface->dev, "device disconnected");
1055 }
1056
1057 }
1058
1059 static struct usb_serial *get_serial_by_minor(unsigned int minor)
1060 {
1061 return serial_table[minor];
1062 }
1063
1064 /*****************************************************************************
1065 * Driver tty interface functions
1066 *****************************************************************************/
1067 static int serial_open(struct tty_struct *tty, struct file *filp)
1068 {
1069 struct usb_serial *serial;
1070 struct usb_serial_port *port;
1071 unsigned int portNumber;
1072 int retval = 0;
1073
1074 mydbg("%s\n", __func__);
1075
1076 /* initialize the pointer incase something fails */
1077 tty->driver_data = NULL;
1078
1079 /* get the serial object associated with this tty pointer */
1080 /* serial = get_serial_by_minor (MINOR(tty->device)); */
1081
1082 /* get the serial object associated with this tty pointer */
1083 serial = get_serial_by_minor(tty->index);
1084
1085 if (serial_paranoia_check(serial, __func__))
1086 return -ENODEV;
1087
1088 /* set up our port structure making the tty driver remember our port object, and us it */
1089 portNumber = tty->index - serial->minor;
1090 port = &serial->port[portNumber];
1091 tty->driver_data = port;
1092
1093 down(&port->sem);
1094 port->tty = tty;
1095
1096 ++port->open_count;
1097 if (port->open_count == 1) {
1098 port->closePending = 0;
1099 mydbg("%s port->closepending = 0\n", __func__);
1100
1101 port->RxHolding = 0;
1102 mydbg("%s port->RxHolding = 0\n", __func__);
1103
1104 retval = qt_open(tty, port, filp);
1105 }
1106
1107 if (retval)
1108 port->open_count = 0;
1109 mydbg("%s returning port->closePending = %d\n", __func__,
1110 port->closePending);
1111
1112 up(&port->sem);
1113 return retval;
1114 }
1115
1116 /*****************************************************************************
1117 *device's specific driver functions
1118 *****************************************************************************/
1119 static int qt_open(struct tty_struct *tty, struct usb_serial_port *port,
1120 struct file *filp)
1121 {
1122 struct usb_serial *serial = port->serial;
1123 int result = 0;
1124 unsigned int index;
1125 struct qt_get_device_data DeviceData;
1126 struct qt_open_channel_data ChannelData;
1127 unsigned short default_divisor = 0x30; /* gives 9600 baud rate */
1128 unsigned char default_LCR = SERIAL_8_DATA; /* 8, none , 1 */
1129 int status = 0;
1130
1131 if (port_paranoia_check(port, __func__))
1132 return -ENODEV;
1133
1134 mydbg("%s - port %d\n", __func__, port->number);
1135
1136 index = tty->index - serial->minor;
1137
1138 status = box_get_device(serial, &DeviceData);
1139 if (status < 0) {
1140 mydbg(__FILE__ "box_get_device failed\n");
1141 return status;
1142 }
1143 serial->num_OpenCount++;
1144 mydbg("%s serial->num_OpenCount = %d\n", __func__,
1145 serial->num_OpenCount);
1146 /* Open uart channel */
1147
1148 /* Port specific setups */
1149 status = BoxOPenCloseChannel(serial, index, 1, &ChannelData);
1150 if (status < 0) {
1151 mydbg(__FILE__ "BoxOPenCloseChannel failed\n");
1152 return status;
1153 }
1154 mydbg(__FILE__ "BoxOPenCloseChannel completed.\n");
1155
1156 port->shadowLSR = ChannelData.line_status &
1157 (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
1158
1159 port->shadowMSR = ChannelData.modem_status &
1160 (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
1161
1162 /* Set Baud rate to default and turn off (default)flow control here */
1163 status = BoxSetUart(serial, index, default_divisor, default_LCR);
1164 if (status < 0) {
1165 mydbg(__FILE__ "BoxSetUart failed\n");
1166 return status;
1167 }
1168 mydbg(__FILE__ "BoxSetUart completed.\n");
1169
1170 /* Put this here to make it responsive to stty and defauls set by the tty layer */
1171 qt_set_termios(tty, port, NULL);
1172
1173 /* Initialize the wait que head */
1174 init_waitqueue_head(&(port->wait));
1175
1176 /* if we have a bulk endpoint, start reading from it */
1177 if (serial->num_bulk_in) {
1178 /* Start reading from the device */
1179 usb_fill_bulk_urb(port->read_urb, serial->dev,
1180 usb_rcvbulkpipe(serial->dev,
1181 port->
1182 bulk_in_endpointAddress),
1183 port->read_urb->transfer_buffer,
1184 port->read_urb->transfer_buffer_length,
1185 qt_read_bulk_callback, port);
1186
1187 port->ReadBulkStopped = 0;
1188
1189 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1190
1191 if (result) {
1192 err("%s - failed resubmitting read urb, error %d\n",
1193 __func__, result);
1194 port->ReadBulkStopped = 1;
1195 }
1196
1197 }
1198
1199 return result;
1200 }
1201
1202 static void serial_close(struct tty_struct *tty, struct file *filp)
1203 {
1204 struct usb_serial_port *port =
1205 tty->driver_data;
1206 struct usb_serial *serial = get_usb_serial(port, __func__);
1207
1208 if (!serial)
1209 return;
1210
1211 down(&port->sem);
1212
1213 mydbg("%s - port %d\n", __func__, port->number);
1214
1215 /* if disconnect beat us to the punch here, there's nothing to do */
1216 if (tty->driver_data) {
1217 if (!port->open_count) {
1218 mydbg("%s - port not opened\n", __func__);
1219 goto exit;
1220 }
1221
1222 --port->open_count;
1223 if (port->open_count <= 0) {
1224 port->closePending = 1;
1225 mydbg("%s - port->closePending = 1\n", __func__);
1226
1227 if (serial->dev) {
1228 qt_close(tty, port, filp);
1229 port->open_count = 0;
1230 }
1231 }
1232
1233 }
1234
1235 exit:
1236 up(&port->sem);
1237
1238 mydbg("%s - %d return\n", __func__, port->number);
1239
1240 }
1241
1242 static void qt_close(struct tty_struct *tty, struct usb_serial_port *port,
1243 struct file *filp)
1244 {
1245 unsigned long jift = jiffies + 10 * HZ;
1246 u8 lsr, mcr;
1247 struct usb_serial *serial = port->serial;
1248 int status;
1249 unsigned int index;
1250
1251 struct qt_open_channel_data ChannelData;
1252 status = 0;
1253 lsr = 0;
1254
1255 mydbg("%s - port %d\n", __func__, port->number);
1256 index = tty->index - serial->minor;
1257
1258 /* shutdown any bulk reads that might be going on */
1259 if (serial->num_bulk_out)
1260 usb_unlink_urb(port->write_urb);
1261 if (serial->num_bulk_in)
1262 usb_unlink_urb(port->read_urb);
1263
1264 /* wait up to 30 seconds for transmitter to empty */
1265 do {
1266 status = BoxGetRegister(serial, index, LINE_STATUS_REGISTER, &lsr);
1267 if (status < 0) {
1268 mydbg(__FILE__ "box_get_device failed\n");
1269 break;
1270 }
1271
1272 if ((lsr & SERIAL_LSR_TEMT)
1273 && (port->ReadBulkStopped == 1))
1274 break;
1275 schedule();
1276
1277 }
1278 while (jiffies <= jift);
1279
1280 if (jiffies > jift)
1281 mydbg("%s - port %d timout of checking transmitter empty\n",
1282 __func__, port->number);
1283 else
1284 mydbg("%s - port %d checking transmitter empty succeded\n",
1285 __func__, port->number);
1286
1287 status =
1288 BoxGetRegister(serial, index, MODEM_CONTROL_REGISTER,
1289 &mcr);
1290 mydbg(__FILE__ "BoxGetRegister MCR = 0x%x.\n", mcr);
1291
1292 if (status >= 0) {
1293 mcr &= ~(SERIAL_MCR_DTR | SERIAL_MCR_RTS);
1294 /* status = BoxSetRegister(serial, index, MODEM_CONTROL_REGISTER, mcr); */
1295 }
1296
1297 /* Close uart channel */
1298 status = BoxOPenCloseChannel(serial, index, 0, &ChannelData);
1299 if (status < 0)
1300 mydbg("%s - port %d BoxOPenCloseChannel failed.\n",
1301 __func__, port->number);
1302
1303 serial->num_OpenCount--;
1304
1305 }
1306
1307 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
1308 int count)
1309 {
1310 struct usb_serial_port *port = tty->driver_data;
1311 struct usb_serial *serial;
1312 int retval = -EINVAL;
1313 unsigned int index;
1314
1315 serial = get_usb_serial(port, __func__);
1316 if (serial == NULL)
1317 return -ENODEV;
1318 /* This can happen if we get disconnected a */
1319 if (port->open_count == 0)
1320 return -ENODEV;
1321 index = tty->index - serial->minor;
1322
1323 mydbg("%s - port %d, %d byte(s)\n", __func__, port->number, count);
1324 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1325
1326 if (!port->open_count) {
1327 mydbg("%s - port not opened\n", __func__);
1328 goto exit;
1329 }
1330
1331 retval = qt_write(tty, port, buf, count);
1332
1333 exit:
1334 return retval;
1335 }
1336
1337 static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
1338 const unsigned char *buf, int count)
1339 {
1340 int result;
1341 unsigned int index;
1342 struct usb_serial *serial = get_usb_serial(port, __func__);
1343
1344 if (serial == NULL)
1345 return -ENODEV;
1346
1347 mydbg("%s - port %d\n", __func__, port->number);
1348
1349 if (count == 0) {
1350 mydbg("%s - write request of 0 bytes\n", __func__);
1351 return 0;
1352 }
1353
1354 index = tty->index - serial->minor;
1355 /* only do something if we have a bulk out endpoint */
1356 if (serial->num_bulk_out) {
1357 if (port->write_urb->status == -EINPROGRESS) {
1358 mydbg("%s - already writing\n", __func__);
1359 return 0;
1360 }
1361
1362 count =
1363 (count > port->bulk_out_size) ? port->bulk_out_size : count;
1364 memcpy(port->write_urb->transfer_buffer, buf, count);
1365
1366 /* usb_serial_debug_data(__FILE__, __func__, count, port->write_urb->transfer_buffer); */
1367
1368 /* set up our urb */
1369
1370 usb_fill_bulk_urb(port->write_urb, serial->dev,
1371 usb_sndbulkpipe(serial->dev,
1372 port->
1373 bulk_out_endpointAddress),
1374 port->write_urb->transfer_buffer, count,
1375 qt_write_bulk_callback, port);
1376
1377 /* send the data out the bulk port */
1378 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1379 if (result)
1380 mydbg("%s - failed submitting write urb, error %d\n",
1381 __func__, result);
1382 else
1383 result = count;
1384
1385 return result;
1386 }
1387
1388 /* no bulk out, so return 0 bytes written */
1389 return 0;
1390 }
1391
1392 static void qt_write_bulk_callback(struct urb *urb)
1393 {
1394 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1395 struct usb_serial *serial = get_usb_serial(port, __func__);
1396
1397 mydbg("%s - port %d\n", __func__, port->number);
1398
1399 if (!serial) {
1400 mydbg("%s - bad serial pointer, exiting\n", __func__);
1401 return;
1402 }
1403
1404 if (urb->status) {
1405 mydbg("%s - nonzero write bulk status received: %d\n",
1406 __func__, urb->status);
1407 return;
1408 }
1409 port_softint(&port->work);
1410 schedule_work(&port->work);
1411
1412 return;
1413 }
1414
1415 static void port_softint(struct work_struct *work)
1416 {
1417 struct usb_serial_port *port =
1418 container_of(work, struct usb_serial_port, work);
1419 struct usb_serial *serial = get_usb_serial(port, __func__);
1420 struct tty_struct *tty;
1421
1422 mydbg("%s - port %d\n", __func__, port->number);
1423
1424 if (!serial)
1425 return;
1426
1427 tty = port->tty;
1428 if (!tty)
1429 return;
1430 #if 0
1431 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP))
1432 && tty->ldisc.write_wakeup) {
1433 mydbg("%s - write wakeup call.\n", __func__);
1434 (tty->ldisc.write_wakeup) (tty);
1435 }
1436 #endif
1437
1438 wake_up_interruptible(&tty->write_wait);
1439 }
1440 static int serial_write_room(struct tty_struct *tty)
1441 {
1442 struct usb_serial_port *port = tty->driver_data;
1443 struct usb_serial *serial = get_usb_serial(port, __func__);
1444 int retval = -EINVAL;
1445
1446 if (!serial)
1447 return -ENODEV;
1448
1449 down(&port->sem);
1450
1451 mydbg("%s - port %d\n", __func__, port->number);
1452
1453 if (!port->open_count) {
1454 mydbg("%s - port not open\n", __func__);
1455 goto exit;
1456 }
1457
1458 retval = qt_write_room(port);
1459
1460 exit:
1461 up(&port->sem);
1462 return retval;
1463 }
1464 static int qt_write_room(struct usb_serial_port *port)
1465 {
1466 struct usb_serial *serial = port->serial;
1467 int room = 0;
1468 if (port->closePending == 1) {
1469 mydbg("%s - port->closePending == 1\n", __func__);
1470 return -ENODEV;
1471 }
1472
1473 mydbg("%s - port %d\n", __func__, port->number);
1474
1475 if (serial->num_bulk_out) {
1476 if (port->write_urb->status != -EINPROGRESS)
1477 room = port->bulk_out_size;
1478 }
1479
1480 mydbg("%s - returns %d\n", __func__, room);
1481 return room;
1482 }
1483 static int serial_chars_in_buffer(struct tty_struct *tty)
1484 {
1485 struct usb_serial_port *port = tty->driver_data;
1486 struct usb_serial *serial = get_usb_serial(port, __func__);
1487 int retval = -EINVAL;
1488
1489 if (!serial)
1490 return -ENODEV;
1491
1492 down(&port->sem);
1493
1494 mydbg("%s = port %d\n", __func__, port->number);
1495
1496 if (!port->open_count) {
1497 mydbg("%s - port not open\n", __func__);
1498 goto exit;
1499 }
1500
1501 retval = qt_chars_in_buffer(port);
1502
1503 exit:
1504 up(&port->sem);
1505 return retval;
1506 }
1507
1508 static int qt_chars_in_buffer(struct usb_serial_port *port)
1509 {
1510 struct usb_serial *serial = port->serial;
1511 int chars = 0;
1512
1513 mydbg("%s - port %d\n", __func__, port->number);
1514
1515 if (serial->num_bulk_out) {
1516 if (port->write_urb->status == -EINPROGRESS)
1517 chars = port->write_urb->transfer_buffer_length;
1518 }
1519
1520 mydbg("%s - returns %d\n", __func__, chars);
1521 return chars;
1522 }
1523
1524 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
1525 unsigned int set, unsigned int clear)
1526 {
1527
1528 struct usb_serial_port *port = tty->driver_data;
1529 struct usb_serial *serial = get_usb_serial(port, __func__);
1530 int retval = -ENODEV;
1531 unsigned int index;
1532 mydbg("In %s \n", __func__);
1533
1534 if (!serial)
1535 return -ENODEV;
1536
1537 index = tty->index - serial->minor;
1538
1539 down(&port->sem);
1540
1541 mydbg("%s - port %d \n", __func__, port->number);
1542 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1543
1544 if (!port->open_count) {
1545 mydbg("%s - port not open\n", __func__);
1546 goto exit;
1547 }
1548
1549 retval = qt_tiocmset(tty, port, file, set);
1550
1551 exit:
1552 up(&port->sem);
1553 return retval;
1554 }
1555
1556 static int qt_tiocmset(struct tty_struct *tty, struct usb_serial_port *port,
1557 struct file *file, unsigned int value)
1558 {
1559
1560 u8 mcr;
1561 int status;
1562 unsigned int index;
1563 struct usb_serial *serial = get_usb_serial(port, __func__);
1564
1565 if (serial == NULL)
1566 return -ENODEV;
1567
1568 mydbg("%s - port %d\n", __func__, port->number);
1569
1570 /**************************************************************************************/
1571 /** TIOCMGET
1572 */
1573 index = tty->index - serial->minor;
1574 status =
1575 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
1576 &mcr);
1577 if (status < 0)
1578 return -ESPIPE;
1579
1580 /*
1581 * Turn off the RTS and DTR and loopbcck and then only turn on what was
1582 * asked for
1583 */
1584 mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
1585 if (value & TIOCM_RTS)
1586 mcr |= SERIAL_MCR_RTS;
1587 if (value & TIOCM_DTR)
1588 mcr |= SERIAL_MCR_DTR;
1589 if (value & TIOCM_LOOP)
1590 mcr |= SERIAL_MCR_LOOP;
1591
1592 status =
1593 BoxSetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
1594 mcr);
1595 if (status < 0)
1596 return -ESPIPE;
1597 else
1598 return 0;
1599 }
1600
1601 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
1602 {
1603
1604 struct usb_serial_port *port = tty->driver_data;
1605 struct usb_serial *serial = get_usb_serial(port, __func__);
1606 int retval = -ENODEV;
1607 unsigned int index;
1608 mydbg("In %s \n", __func__);
1609
1610 if (!serial)
1611 return -ENODEV;
1612
1613 index = tty->index - serial->minor;
1614
1615 down(&port->sem);
1616
1617 mydbg("%s - port %d\n", __func__, port->number);
1618 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1619
1620 if (!port->open_count) {
1621 mydbg("%s - port not open\n", __func__);
1622 goto exit;
1623 }
1624
1625 retval = qt_tiocmget(tty, port, file);
1626
1627 exit:
1628 up(&port->sem);
1629 return retval;
1630 }
1631
1632 static int qt_tiocmget(struct tty_struct *tty,
1633 struct usb_serial_port *port, struct file *file)
1634 {
1635
1636 u8 mcr;
1637 u8 msr;
1638 unsigned int result = 0;
1639 int status;
1640 unsigned int index;
1641
1642 struct usb_serial *serial = get_usb_serial(port, __func__);
1643 if (serial == NULL)
1644 return -ENODEV;
1645
1646 mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
1647
1648 /**************************************************************************************/
1649 /** TIOCMGET
1650 */
1651 index = tty->index - serial->minor;
1652 status =
1653 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
1654 &mcr);
1655 if (status >= 0) {
1656 status =
1657 BoxGetRegister(port->serial, index,
1658 MODEM_STATUS_REGISTER, &msr);
1659
1660 }
1661
1662 if (status >= 0) {
1663 result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1664 /* DTR IS SET */
1665 | ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1666 /* RTS IS SET */
1667 | ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1668 /* CTS is set */
1669 | ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1670 /* Carrier detect is set */
1671 | ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1672 /* Ring indicator set */
1673 | ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1674 /* DSR is set */
1675 return result;
1676
1677 } else
1678 return -ESPIPE;
1679 }
1680
1681 static int serial_ioctl(struct tty_struct *tty, struct file *file,
1682 unsigned int cmd, unsigned long arg)
1683 {
1684
1685 struct usb_serial_port *port = tty->driver_data;
1686 struct usb_serial *serial = get_usb_serial(port, __func__);
1687 int retval = -ENODEV;
1688 unsigned int index;
1689 mydbg("In %s \n", __func__);
1690
1691 if (!serial)
1692 return -ENODEV;
1693
1694 index = tty->index - serial->minor;
1695
1696 down(&port->sem);
1697
1698 mydbg("%s - port %d, cmd 0x%.4x\n", __func__, port->number, cmd);
1699 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1700
1701 if (!port->open_count) {
1702 mydbg("%s - port not open\n", __func__);
1703 goto exit;
1704 }
1705
1706 retval = qt_ioctl(tty, port, file, cmd, arg);
1707
1708 exit:
1709 up(&port->sem);
1710 return retval;
1711 }
1712 static int qt_ioctl(struct tty_struct *tty, struct usb_serial_port *port,
1713 struct file *file, unsigned int cmd, unsigned long arg)
1714 {
1715 __u8 mcr;
1716 __u8 msr;
1717 unsigned short prev_msr;
1718 unsigned int value, result = 0;
1719 int status;
1720 unsigned int index;
1721
1722 struct usb_serial *serial = get_usb_serial(port, __func__);
1723 if (serial == NULL)
1724 return -ENODEV;
1725
1726 mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
1727
1728 /* TIOCMGET */
1729 index = tty->index - serial->minor;
1730
1731 if (cmd == TIOCMIWAIT) {
1732 DECLARE_WAITQUEUE(wait, current);
1733 prev_msr = port->shadowMSR & SERIAL_MSR_MASK;
1734 while (1) {
1735 add_wait_queue(&port->wait, &wait);
1736 set_current_state(TASK_INTERRUPTIBLE);
1737 schedule();
1738 remove_wait_queue(&port->wait, &wait);
1739 /* see if a signal woke us up */
1740 if (signal_pending(current))
1741 return -ERESTARTSYS;
1742 msr = port->shadowMSR & SERIAL_MSR_MASK;
1743 if (msr == prev_msr)
1744 return -EIO; /* no change error */
1745
1746 if ((arg & TIOCM_RNG
1747 && ((prev_msr & SERIAL_MSR_RI) ==
1748 (msr & SERIAL_MSR_RI)))
1749 || (arg & TIOCM_DSR
1750 && ((prev_msr & SERIAL_MSR_DSR) ==
1751 (msr & SERIAL_MSR_DSR)))
1752 || (arg & TIOCM_CD
1753 && ((prev_msr & SERIAL_MSR_CD) ==
1754 (msr & SERIAL_MSR_CD)))
1755 || (arg & TIOCM_CTS
1756 && ((prev_msr & SERIAL_MSR_CTS) ==
1757 (msr & SERIAL_MSR_CTS)))) {
1758 return 0;
1759 }
1760
1761 }
1762
1763 }
1764 mydbg("%s -No ioctl for that one. port = %d\n", __func__,
1765 port->number);
1766
1767 return -ENOIOCTLCMD;
1768 }
1769
1770 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
1771 {
1772 struct usb_serial_port *port =
1773 tty->driver_data;
1774 struct usb_serial *serial = get_usb_serial(port, __func__);
1775
1776 if (!serial)
1777 return;
1778
1779 down(&port->sem);
1780
1781 mydbg("%s - port %d\n", __func__, port->number);
1782
1783 if (!port->open_count) {
1784 mydbg("%s - port not open\n", __func__);
1785 goto exit;
1786 }
1787
1788 /* pass on to the driver specific version of this function if it is available */
1789 qt_set_termios(tty, port, old);
1790
1791 exit:
1792 up(&port->sem);
1793 }
1794
1795 static void qt_set_termios(struct tty_struct *tty,
1796 struct usb_serial_port *port,
1797 struct ktermios *old_termios)
1798 {
1799 unsigned int cflag;
1800 int baud, divisor, remainder;
1801 unsigned char new_LCR = 0;
1802 int status;
1803 struct usb_serial *serial;
1804 __u16 index;
1805 __u16 tmp, tmp2;
1806
1807 mydbg("%s - port %d\n", __func__, port->number);
1808
1809 tmp = port->tty->index;
1810 mydbg("%s - MINOR(port->tty->index) = %d\n", __func__, tmp);
1811
1812 serial = port->serial;
1813 tmp2 = serial->minor;
1814 mydbg("%s - serial->minor = %d\n", __func__, tmp2);
1815
1816 index = port->tty->index - serial->minor;
1817
1818 cflag = tty->termios->c_cflag;
1819
1820 mydbg("%s - 3\n", __func__);
1821
1822 switch (cflag) {
1823 case CS5:
1824 new_LCR |= SERIAL_5_DATA;
1825 break;
1826 case CS6:
1827 new_LCR |= SERIAL_6_DATA;
1828 break;
1829 case CS7:
1830 new_LCR |= SERIAL_7_DATA;
1831 break;
1832 default:
1833 case CS8:
1834 new_LCR |= SERIAL_8_DATA;
1835 break;
1836 }
1837
1838 /* Parity stuff */
1839 if (cflag & PARENB) {
1840 if (cflag & PARODD)
1841 new_LCR |= SERIAL_ODD_PARITY;
1842 else
1843 new_LCR |= SERIAL_EVEN_PARITY;
1844 }
1845 if (cflag & CSTOPB)
1846 new_LCR |= SERIAL_TWO_STOPB;
1847 else
1848 new_LCR |= SERIAL_TWO_STOPB;
1849
1850 mydbg("%s - 4\n", __func__);
1851 /* Thats the LCR stuff, go ahead and set it */
1852 baud = tty_get_baud_rate(tty);
1853 if (!baud)
1854 /* pick a default, any default... */
1855 baud = 9600;
1856
1857 mydbg("%s - got baud = %d\n", __func__, baud);
1858
1859 divisor = MAX_BAUD_RATE / baud;
1860 remainder = MAX_BAUD_RATE % baud;
1861 /* Round to nearest divisor */
1862 if (((remainder * 2) >= baud) && (baud != 110))
1863 divisor++;
1864
1865 /*
1866 * Set Baud rate to default and turn off (default)flow control here
1867 */
1868 status = BoxSetUart(serial, index, (unsigned short)divisor, new_LCR);
1869 if (status < 0) {
1870 mydbg(__FILE__ "BoxSetUart failed\n");
1871 return;
1872 }
1873
1874 /* Now determine flow control */
1875 if (cflag & CRTSCTS) {
1876 mydbg("%s - Enabling HW flow control port %d\n", __func__,
1877 port->number);
1878
1879 /* Enable RTS/CTS flow control */
1880 status = BoxSetHW_FlowCtrl(serial, index, 1);
1881
1882 if (status < 0) {
1883 mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
1884 return;
1885 }
1886 } else {
1887 /* Disable RTS/CTS flow control */
1888 mydbg("%s - disabling HW flow control port %d\n", __func__,
1889 port->number);
1890
1891 status = BoxSetHW_FlowCtrl(serial, index, 0);
1892 if (status < 0) {
1893 mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
1894 return;
1895 }
1896
1897 }
1898
1899 /* if we are implementing XON/XOFF, set the start and stop character in
1900 * the device */
1901 if (I_IXOFF(tty) || I_IXON(tty)) {
1902 unsigned char stop_char = STOP_CHAR(tty);
1903 unsigned char start_char = START_CHAR(tty);
1904 status =
1905 BoxSetSW_FlowCtrl(serial, index, stop_char,
1906 start_char);
1907 if (status < 0)
1908 mydbg(__FILE__ "BoxSetSW_FlowCtrl (enabled) failed\n");
1909
1910 } else {
1911 /* disable SW flow control */
1912 status = BoxDisable_SW_FlowCtrl(serial, index);
1913 if (status < 0)
1914 mydbg(__FILE__ "BoxSetSW_FlowCtrl (diabling) failed\n");
1915
1916 }
1917 tty->termios->c_cflag &= ~CMSPAR;
1918 /* FIXME: Error cases should be returning the actual bits changed only */
1919 }
1920
1921 /****************************************************************************
1922 * BoxGetRegister
1923 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
1924 * If successful, fills in the pValue with the register value asked for
1925 ****************************************************************************/
1926 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
1927 unsigned short Register_Num, __u8 *pValue)
1928 {
1929 int result;
1930 __u16 current_length;
1931
1932 current_length = sizeof(struct qt_get_device_data);
1933
1934 result =
1935 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1936 QT_GET_SET_REGISTER, 0xC0, Register_Num,
1937 Uart_Number, (void *)pValue, sizeof(*pValue), 300);
1938
1939 return result;
1940 }
1941
1942 /****************************************************************************
1943 * BoxSetRegister
1944 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
1945 * If successful, fills in the pValue with the register value asked for
1946 ****************************************************************************/
1947 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
1948 unsigned short Register_Num, unsigned short Value)
1949 {
1950 int result;
1951 unsigned short RegAndByte;
1952
1953 RegAndByte = Value;
1954 RegAndByte = RegAndByte << 8;
1955 RegAndByte = RegAndByte + Register_Num;
1956
1957 /*
1958 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1959 QT_GET_SET_REGISTER, 0xC0, Register_Num,
1960 Uart_Number, NULL, 0, 300);
1961 */
1962
1963 result =
1964 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1965 QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number,
1966 NULL, 0, 300);
1967
1968 return result;
1969 }
1970
1971 /**
1972 * box_get_device
1973 * Issue a GET_DEVICE vendor-specific request on the default control pipe If
1974 * successful, fills in the qt_get_device_data structure pointed to by
1975 * device_data, otherwise return a negative error number of the problem.
1976 */
1977 static int box_get_device(struct usb_serial *serial,
1978 struct qt_get_device_data *device_data)
1979 {
1980 int result;
1981 __u16 current_length;
1982 unsigned char *transfer_buffer;
1983
1984 current_length = sizeof(struct qt_get_device_data);
1985 transfer_buffer = kmalloc(current_length, GFP_KERNEL);
1986 if (!transfer_buffer)
1987 return -ENOMEM;
1988
1989 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1990 QT_SET_GET_DEVICE, 0xc0, 0, 0,
1991 transfer_buffer, current_length, 300);
1992 if (result > 0)
1993 memcpy(device_data, transfer_buffer, current_length);
1994 kfree(transfer_buffer);
1995
1996 return result;
1997 }
1998
1999 /**
2000 * box_set_device
2001 * Issue a SET_DEVICE vendor-specific request on the default control pipe If
2002 * successful returns the number of bytes written, otherwise it returns a
2003 * negative error number of the problem.
2004 */
2005 static int box_set_device(struct usb_serial *serial,
2006 struct qt_get_device_data *device_data)
2007 {
2008 int result;
2009 __u16 length;
2010 __u16 PortSettings;
2011
2012 PortSettings = ((__u16) (device_data->portb));
2013 PortSettings = (PortSettings << 8);
2014 PortSettings += ((__u16) (device_data->porta));
2015
2016 length = sizeof(struct qt_get_device_data);
2017 mydbg("%s - PortSettings = 0x%x\n", __func__, PortSettings);
2018
2019 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2020 QT_SET_GET_DEVICE, 0x40, PortSettings,
2021 0, NULL, 0, 300);
2022 return result;
2023 }
2024
2025 /****************************************************************************
2026 * BoxOPenCloseChannel
2027 * This funciotn notifies the device that the device driver wishes to open a particular UART channel. its
2028 * purpose is to allow the device driver and the device to synchronize state information.
2029 * OpenClose = 1 for open , 0 for close
2030 ****************************************************************************/
2031 static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
2032 __u16 OpenClose,
2033 struct qt_open_channel_data *pDeviceData)
2034 {
2035 int result;
2036 __u16 length;
2037 __u8 Direcion;
2038 unsigned int pipe;
2039 length = sizeof(struct qt_open_channel_data);
2040
2041 /* if opening... */
2042 if (OpenClose == 1) {
2043 Direcion = USBD_TRANSFER_DIRECTION_IN;
2044 pipe = usb_rcvctrlpipe(serial->dev, 0);
2045 result =
2046 usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
2047 Direcion, OpenClose, Uart_Number,
2048 pDeviceData, length, 300);
2049
2050 } else {
2051 Direcion = USBD_TRANSFER_DIRECTION_OUT;
2052 pipe = usb_sndctrlpipe(serial->dev, 0);
2053 result =
2054 usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
2055 Direcion, OpenClose, Uart_Number, NULL, 0,
2056 300);
2057
2058 }
2059
2060 return result;
2061 }
2062
2063 /****************************************************************************
2064 * BoxSetPrebufferLevel
2065 TELLS BOX WHEN TO ASSERT FLOW CONTROL
2066 ****************************************************************************/
2067 static int BoxSetPrebufferLevel(struct usb_serial *serial)
2068 {
2069 int result;
2070 __u16 buffer_length;
2071
2072 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
2073 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2074 QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
2075 buffer_length, 0, NULL, 0, 300);
2076 return result;
2077 }
2078
2079 /****************************************************************************
2080 * BoxSetATC
2081 TELLS BOX WHEN TO ASSERT automatic transmitter control
2082 ****************************************************************************/
2083 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
2084 {
2085 int result;
2086 __u16 buffer_length;
2087
2088 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
2089
2090 result =
2091 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2092 QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
2093
2094 return result;
2095 }
2096
2097 /****************************************************************************
2098 * BoxSetUart
2099 * issuse a SET_UART vendor-spcific request on the default control pipe
2100 * If successful sets baud rate divisor and LCR value
2101 ****************************************************************************/
2102 static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
2103 unsigned short default_divisor, unsigned char default_LCR)
2104 {
2105 int result;
2106 unsigned short UartNumandLCR;
2107
2108 UartNumandLCR = (default_LCR << 8) + Uart_Number;
2109
2110 result =
2111 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2112 QT_GET_SET_UART, 0x40, default_divisor,
2113 UartNumandLCR, NULL, 0, 300);
2114
2115 return result;
2116 }
2117
2118 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
2119 int bSet)
2120 {
2121 __u8 mcr = 0;
2122 __u8 msr = 0, MOUT_Value = 0;
2123 struct usb_serial_port *port;
2124 unsigned int status;
2125
2126 port = serial->port;
2127
2128 if (bSet == 1) {
2129 /* flow control, box will clear RTS line to prevent remote */
2130 mcr = SERIAL_MCR_RTS;
2131 } /* device from xmitting more chars */
2132 else {
2133 /* no flow control to remote device */
2134 mcr = 0;
2135
2136 }
2137 MOUT_Value = mcr << 8;
2138
2139 if (bSet == 1) {
2140 /* flow control, box will inhibit xmit data if CTS line is
2141 * asserted */
2142 msr = SERIAL_MSR_CTS;
2143 } else {
2144 /* Box will not inhimbe xmit data due to CTS line */
2145 msr = 0;
2146 }
2147 MOUT_Value |= msr;
2148
2149 status =
2150 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2151 QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
2152 index, NULL, 0, 300);
2153 return status;
2154
2155 }
2156
2157 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 index,
2158 unsigned char stop_char, unsigned char start_char)
2159 {
2160 __u16 nSWflowout;
2161 int result;
2162
2163 nSWflowout = start_char << 8;
2164 nSWflowout = (unsigned short)stop_char;
2165
2166 result =
2167 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2168 QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
2169 index, NULL, 0, 300);
2170 return result;
2171
2172 }
2173 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index)
2174 {
2175 int result;
2176
2177 result =
2178 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2179 QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index,
2180 NULL, 0, 300);
2181 return result;
2182
2183 }
2184
2185 static void serial_throttle(struct tty_struct *tty)
2186 {
2187 struct usb_serial_port *port =
2188 tty->driver_data;
2189 struct usb_serial *serial = get_usb_serial(port, __func__);
2190 mydbg("%s - port %d\n", __func__, port->number);
2191
2192 if (!serial)
2193 return;
2194
2195 down(&port->sem);
2196
2197 if (!port->open_count) {
2198 mydbg("%s - port not open\n", __func__);
2199 goto exit;
2200 }
2201 /* shut down any bulk reads that may be going on */
2202 /* usb_unlink_urb (port->read_urb); */
2203 /* pass on to the driver specific version of this function */
2204 port->RxHolding = 1;
2205 mydbg("%s - port->RxHolding = 1\n", __func__);
2206
2207 exit:
2208 up(&port->sem);
2209 return;
2210 }
2211
2212 static void serial_unthrottle(struct tty_struct *tty)
2213 {
2214 struct usb_serial_port *port =
2215 tty->driver_data;
2216 struct usb_serial *serial = get_usb_serial(port, __func__);
2217 unsigned int result;
2218
2219 if (!serial)
2220 return;
2221 down(&port->sem);
2222
2223 mydbg("%s - port %d\n", __func__, port->number);
2224
2225 if (!port->open_count) {
2226 mydbg("%s - port not open\n", __func__);
2227 goto exit;
2228 }
2229
2230 if (port->RxHolding == 1) {
2231 mydbg("%s -port->RxHolding == 1\n", __func__);
2232
2233 port->RxHolding = 0;
2234 mydbg("%s - port->RxHolding = 0\n", __func__);
2235
2236 /* if we have a bulk endpoint, start it up */
2237 if ((serial->num_bulk_in) && (port->ReadBulkStopped == 1)) {
2238 /* Start reading from the device */
2239 usb_fill_bulk_urb(port->read_urb, serial->dev,
2240 usb_rcvbulkpipe(serial->dev,
2241 port->
2242 bulk_in_endpointAddress),
2243 port->read_urb->transfer_buffer,
2244 port->read_urb->
2245 transfer_buffer_length,
2246 qt_read_bulk_callback, port);
2247 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
2248 if (result)
2249 err("%s - failed restarting read urb, error %d",
2250 __func__, result);
2251 }
2252 }
2253 exit:
2254 up(&port->sem);
2255 return;
2256
2257 }
2258
2259 static int serial_break(struct tty_struct *tty, int break_state)
2260 {
2261 struct usb_serial_port *port = tty->driver_data;
2262 struct usb_serial *serial = get_usb_serial(port, __func__);
2263 u16 index, onoff;
2264 unsigned int result;
2265
2266 index = tty->index - serial->minor;
2267 if (!serial)
2268 return -ENODEV;
2269
2270 if (break_state == -1)
2271 onoff = 1;
2272 else
2273 onoff = 0;
2274
2275 down(&port->sem);
2276
2277 mydbg("%s - port %d\n", __func__, port->number);
2278
2279 if (!port->open_count) {
2280 mydbg("%s - port not open\n", __func__);
2281 goto exit;
2282 }
2283
2284 result =
2285 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2286 QT_BREAK_CONTROL, 0x40, onoff, index,
2287 NULL, 0, 300);
2288
2289 exit:
2290 up(&port->sem);
2291 return 0;
2292 }
2293
2294 static int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
2295 unsigned long arg)
2296 {
2297
2298 unsigned err;
2299 unsigned ucOPR_NewValue, uc_Value;
2300 int *p_Num_of_adapters, counts, index, *p_QMCR_Value;
2301 struct identity *p_Identity_of;
2302 struct identity Identity_of;
2303 struct usb_serial *lastserial, *serial;
2304
2305 mydbg(KERN_DEBUG "ioctl_serial_usb cmd =\n");
2306 if (_IOC_TYPE(cmd) != SERIALQT_PCI_IOC_MAGIC)
2307 return -ENOTTY;
2308 if (_IOC_NR(cmd) > SERIALQT_IOC_MAXNR)
2309 return -ENOTTY;
2310 mydbg(KERN_DEBUG "ioctl_serial_usb cmd = 0x%x\n", cmd);
2311 err = 0;
2312 switch (cmd) {
2313
2314 case SERIALQT_WRITE_QMCR:
2315 err = -ENOTTY;
2316 index = arg >> 16;
2317 counts = 0;
2318
2319 ucOPR_NewValue = arg;
2320
2321 err = EmulateWriteQMCR_Reg(index, ucOPR_NewValue);
2322 break;
2323
2324 case SERIALQT_READ_QMCR:
2325 err = -ENOTTY;
2326 p_QMCR_Value = (int *)arg;
2327 index = arg >> 16;
2328 counts = 0;
2329
2330 err = EmulateReadQMCR_Reg(index, &uc_Value);
2331 if (err == 0)
2332 err = put_user(uc_Value, p_QMCR_Value);
2333 break;
2334
2335 case SERIALQT_GET_NUMOF_UNITS:
2336 p_Num_of_adapters = (int *)arg;
2337 counts = 0; /* Initialize counts to zero */
2338 /* struct usb_serial *lastserial = serial_table[0], *serial; */
2339 lastserial = serial_table[0];
2340
2341 mydbg(KERN_DEBUG "SERIALQT_GET_NUMOF_UNITS \n");
2342 /* if first pointer is nonull, we at least have one box */
2343 if (lastserial)
2344 counts = 1; /* we at least have one box */
2345
2346 for (index = 1; index < SERIAL_TTY_MINORS; index++) {
2347 serial = serial_table[index];
2348 if (serial) {
2349 if (serial != lastserial) {
2350 /* we had a change in the array, hence
2351 * another box is there */
2352 lastserial = serial;
2353 counts++;
2354 }
2355 } else
2356 break;
2357 }
2358
2359 mydbg(KERN_DEBUG "ioctl_serial_usb writting counts = %d",
2360 counts);
2361
2362 err = put_user(counts, p_Num_of_adapters);
2363
2364 break;
2365 case SERIALQT_GET_THIS_UNIT:
2366 counts = 0;
2367 p_Identity_of = (struct identity *)arg;
2368 /* copy user structure to local variable */
2369 get_user(Identity_of.index, &p_Identity_of->index);
2370 mydbg(KERN_DEBUG "SERIALQT_GET_THIS_UNIT Identity_of.index\n");
2371 mydbg(KERN_DEBUG
2372 "SERIALQT_GET_THIS_UNIT Identity_of.index= 0x%x\n",
2373 Identity_of.index);
2374
2375 err = -ENOTTY;
2376 serial = find_the_box(Identity_of.index);
2377 if (serial) {
2378 err =
2379 put_user(serial->product,
2380 &p_Identity_of->n_identity);
2381
2382 }
2383 break;
2384
2385 case SERIALQT_IS422_EXTENDED:
2386 err = -ENOTTY;
2387 mydbg(KERN_DEBUG "SERIALQT_IS422_EXTENDED \n");
2388 index = arg >> 16;
2389
2390 counts = 0;
2391
2392 mydbg(KERN_DEBUG
2393 "SERIALQT_IS422_EXTENDED, looking Identity_of.indext = 0x%x\n",
2394 index);
2395 serial = find_the_box(index);
2396 if (serial) {
2397 mydbg("%s index = 0x%x, serial = 0x%p\n", __func__,
2398 index, serial);
2399 for (counts = 0; serqt_422_table[counts] != 0; counts++) {
2400
2401 mydbg
2402 ("%s serial->product = = 0x%x, serqt_422_table[counts] = 0x%x\n",
2403 __func__, serial->product,
2404 serqt_422_table[counts]);
2405 if (serial->product == serqt_422_table[counts]) {
2406 err = 0;
2407
2408 mydbg
2409 ("%s found match for 422extended\n",
2410 __func__);
2411 break;
2412 }
2413 }
2414 }
2415 break;
2416
2417 default:
2418 err = -ENOTTY;
2419 }
2420
2421 mydbg("%s returning err = 0x%x\n", __func__, err);
2422 return err;
2423 }
2424
2425 static struct usb_serial *find_the_box(unsigned int index)
2426 {
2427 struct usb_serial *lastserial, *foundserial, *serial;
2428 int counts = 0, index2;
2429 lastserial = serial_table[0];
2430 foundserial = NULL;
2431 for (index2 = 0; index2 < SERIAL_TTY_MINORS; index2++) {
2432 serial = serial_table[index2];
2433
2434 mydbg("%s index = 0x%x, index2 = 0x%x, serial = 0x%p\n",
2435 __func__, index, index2, serial);
2436
2437 if (serial) {
2438 /* first see if this is the unit we'er looking for */
2439 mydbg
2440 ("%s inside if(serial) counts = 0x%x , index = 0x%x\n",
2441 __func__, counts, index);
2442 if (counts == index) {
2443 /* we found the one we're looking for, copythe
2444 * product Id to user */
2445 mydbg("%s we found the one we're looking for serial = 0x%p\n",
2446 __func__, serial);
2447 foundserial = serial;
2448 break;
2449 }
2450
2451 if (serial != lastserial) {
2452 /* when we have a change in the pointer */
2453 lastserial = serial;
2454 counts++;
2455 }
2456 } else
2457 break; /* no matches */
2458 }
2459
2460 mydbg("%s returning foundserial = 0x%p\n", __func__, foundserial);
2461 return foundserial;
2462 }
2463
2464 static int EmulateWriteQMCR_Reg(int index, unsigned uc_value)
2465 {
2466
2467 __u16 ATC_Mode = 0;
2468 struct usb_serial *serial;
2469 int status;
2470 struct qt_get_device_data DeviceData;
2471 unsigned uc_temp = 0;
2472 mydbg("Inside %s, uc_value = 0x%x\n", __func__, uc_value);
2473
2474 DeviceData.porta = 0;
2475 DeviceData.portb = 0;
2476 serial = find_the_box(index);
2477 /* Determine Duplex mode */
2478 if (!(serial))
2479 return -ENOTTY;
2480 status = box_get_device(serial, &DeviceData);
2481 if (status < 0) {
2482 mydbg(__FILE__ "box_set_device failed\n");
2483 return status;
2484 }
2485
2486 uc_temp = uc_value & QMCR_HALF_DUPLEX_MASK;
2487 switch (uc_temp) {
2488 case QMCR_FULL_DUPLEX:
2489 DeviceData.porta &= ~DUPMODE_BITS;
2490 DeviceData.porta |= FULL_DUPLEX;
2491 ATC_Mode = ATC_DISABLED;
2492 break;
2493 case QMCR_HALF_DUPLEX_RTS:
2494 DeviceData.porta &= ~DUPMODE_BITS;
2495 DeviceData.porta |= HALF_DUPLEX_RTS;
2496 ATC_Mode = ATC_RTS_ENABLED;
2497 break;
2498 case QMCR_HALF_DUPLEX_DTR:
2499 DeviceData.porta &= ~DUPMODE_BITS;
2500 DeviceData.porta |= HALF_DUPLEX_DTR;
2501 ATC_Mode = ATC_DTR_ENABLED;
2502 break;
2503 default:
2504 break;
2505 }
2506
2507 uc_temp = uc_value & QMCR_CONNECTOR_MASK;
2508 switch (uc_temp) {
2509 case QMCR_MODEM_CONTROL:
2510 DeviceData.portb &= ~LOOPMODE_BITS; /* reset connection bits */
2511 DeviceData.portb |= MODEM_CTRL;
2512 break;
2513 case QMCR_ALL_LOOPBACK:
2514 DeviceData.portb &= ~LOOPMODE_BITS; /* reset connection bits */
2515 DeviceData.portb |= ALL_LOOPBACK;
2516 break;
2517 }
2518
2519 mydbg(__FILE__ "Calling box_set_device with failed\n");
2520 status = box_set_device(serial, &DeviceData);
2521 if (status < 0) {
2522 mydbg(__FILE__ "box_set_device failed\n");
2523 return status;
2524 }
2525
2526 /* This bit (otherwise unused) i'll used to detect whether ATC is
2527 * selected */
2528 if (uc_value & QMCR_RX_EN_MASK) {
2529
2530 mydbg(__FILE__
2531 "calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
2532 DeviceData.porta, DeviceData.portb);
2533 status = BoxSetATC(serial, ATC_Mode);
2534 if (status < 0) {
2535 mydbg(__FILE__ "BoxSetATC failed\n");
2536 return status;
2537 }
2538 } else {
2539
2540 mydbg(__FILE__
2541 "calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
2542 DeviceData.porta, DeviceData.portb);
2543 status = BoxSetATC(serial, ATC_DISABLED);
2544 if (status < 0) {
2545 mydbg(__FILE__ "BoxSetATC failed\n");
2546 return status;
2547 }
2548 }
2549
2550 return 0;
2551
2552 }
2553
2554 static int EmulateReadQMCR_Reg(int index, unsigned *uc_value)
2555 {
2556 struct usb_serial *serial;
2557 int status;
2558 struct qt_get_device_data DeviceData;
2559 __u8 uc_temp;
2560
2561 *uc_value = 0;
2562
2563 serial = find_the_box(index);
2564 if (!(serial))
2565 return -ENOTTY;
2566
2567 status = box_get_device(serial, &DeviceData);
2568 if (status < 0) {
2569 mydbg(__FILE__ "box_get_device failed\n");
2570 return status;
2571 }
2572 uc_temp = DeviceData.porta & DUPMODE_BITS;
2573 switch (uc_temp) {
2574 case FULL_DUPLEX:
2575 *uc_value |= QMCR_FULL_DUPLEX;
2576 break;
2577 case HALF_DUPLEX_RTS:
2578 *uc_value |= QMCR_HALF_DUPLEX_RTS;
2579 break;
2580 case HALF_DUPLEX_DTR:
2581 *uc_value |= QMCR_HALF_DUPLEX_DTR;
2582 break;
2583 default:
2584 break;
2585 }
2586
2587 /* I use this for ATC control se */
2588 uc_temp = DeviceData.portb & LOOPMODE_BITS;
2589
2590 switch (uc_temp) {
2591 case ALL_LOOPBACK:
2592 *uc_value |= QMCR_ALL_LOOPBACK;
2593 break;
2594 case MODEM_CTRL:
2595 *uc_value |= QMCR_MODEM_CONTROL;
2596 break;
2597 default:
2598 break;
2599
2600 }
2601 return 0;
2602
2603 }
2604
2605 static int __init serqt_usb_init(void)
2606 {
2607 int i, result;
2608 int status = 0;
2609
2610 mydbg("%s\n", __func__);
2611 tty_set_operations(&serial_tty_driver, &serial_ops);
2612 result = tty_register_driver(&serial_tty_driver);
2613 if (result) {
2614 mydbg("tty_register_driver failed error = 0x%x", result);
2615 return result;
2616 }
2617
2618 /* Initalize our global data */
2619 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
2620 serial_table[i] = NULL;
2621
2622 /* register this driver with the USB subsystem */
2623 result = usb_register(&serqt_usb_driver);
2624 if (result < 0) {
2625 err("usb_register failed for the " __FILE__
2626 " driver. Error number %d", result);
2627 return result;
2628 }
2629 status = 0; /* Dynamic assignment of major number */
2630 major_number =
2631 register_chrdev(status, "SerialQT_USB", &serialqt_usb_fops);
2632 if (major_number < 0) {
2633 mydbg(KERN_DEBUG "No devices found \n\n");
2634 return -EBUSY;
2635 } else
2636 mydbg(KERN_DEBUG "SerQT_USB major number assignment = %d \n\n",
2637 major_number);
2638
2639 printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION);
2640 return 0;
2641 }
2642
2643 static void __exit serqt_usb_exit(void)
2644 {
2645 /* deregister this driver with the USB subsystem */
2646 usb_deregister(&serqt_usb_driver);
2647 tty_unregister_driver(&serial_tty_driver);
2648 unregister_chrdev(major_number, "SerialQT_USB");
2649 }
2650
2651 module_init(serqt_usb_init);
2652 module_exit(serqt_usb_exit);
2653
2654 MODULE_AUTHOR(DRIVER_AUTHOR);
2655 MODULE_DESCRIPTION(DRIVER_DESC);
2656 MODULE_LICENSE("GPL");
(deprecated) Btrfs devel tree