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
7 #include <linux/sched.h>
8 #include <linux/slab.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>
18 /* Use our own dbg macro */
19 /* #define DEBUG_ON */
22 #define mydbg(const...) printk(const)
24 #define mydbg(const...)
27 /* parity check flag */
28 #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
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
36 #define RR_BITS 0x03 /* for clearing clock bits */
37 #define DUPMODE_BITS 0xc0
39 #define RS232_MODE 0x00
40 #define RTSCTS_TO_CONNECTOR 0x40
43 #define LOOPMODE_BITS 0x41 /* LOOP1 = b6, LOOP0 = b0 (PORT B) */
44 #define ALL_LOOPBACK 0x01
45 #define MODEM_CTRL 0x40
47 #define THISCHAR data[i]
48 #define NEXTCHAR data[i + 1]
49 #define THIRDCHAR data[i + 2]
50 #define FOURTHCHAR data[i + 3]
53 * Useful defintions for port A, Port B and Port C
55 #define FULLPWRBIT 0x00000080
56 #define NEXT_BOARD_POWER_BIT 0x00000004
58 #define SERIAL_LSR_OE 0x02
59 #define SERIAL_LSR_PE 0x04
60 #define SERIAL_LSR_FE 0x08
61 #define SERIAL_LSR_BI 0x10
63 #define SERIAL_LSR_TEMT 0x40
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
75 #define SERIAL_MCR_DTR 0x01
76 #define SERIAL_MCR_RTS 0x02
77 #define SERIAL_MCR_LOOP 0x10
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
85 #define SERIAL_8_DATA 0x03
86 #define SERIAL_7_DATA 0x02
87 #define SERIAL_6_DATA 0x01
88 #define SERIAL_5_DATA 0x00
90 #define SERIAL_ODD_PARITY 0X08
91 #define SERIAL_EVEN_PARITY 0X18
92 #define SERIAL_TWO_STOPB 0x04
93 #define SERIAL_ONE_STOPB 0x00
95 #define MAX_BAUD_RATE 460800
96 #define MAX_BAUD_REMAINDER 4608
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
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 */
118 #define USBD_TRANSFER_DIRECTION_IN 0xc0
119 #define USBD_TRANSFER_DIRECTION_OUT 0x40
121 #define ATC_DISABLED 0x00
122 #define ATC_RTS_ENABLED 0x02
123 #define ATC_DTR_ENABLED 0x01
125 #define RR_BITS 0x03 /* for clearing clock bits */
126 #define DUPMODE_BITS 0xc0
128 #define FULL_DUPLEX 0x00
129 #define HALF_DUPLEX_RTS 0x40
130 #define HALF_DUPLEX_DTR 0x80
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
138 #define QMCR_RX_EN_MASK 0x20
140 #define QMCR_ALL_LOOPBACK 0x10
141 #define QMCR_MODEM_CONTROL 0X00
143 #define SERIALQT_IOC_MAXNR 6
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 */
151 unsigned char *interrupt_in_buffer;
152 struct urb *interrupt_in_urb;
153 __u8 interrupt_in_endpointAddress;
155 unsigned char *bulk_in_buffer;
156 unsigned char *xfer_to_tty_buffer;
157 struct urb *read_urb;
158 __u8 bulk_in_endpointAddress;
160 unsigned char *bulk_out_buffer;
162 struct urb *write_urb;
163 __u8 bulk_out_endpointAddress;
165 wait_queue_head_t write_wait;
166 wait_queue_head_t wait;
167 struct work_struct work;
169 int open_count; /* number of times this port has been opened */
170 struct semaphore sem; /* locks this structure */
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 */
180 void *private; /* data private to the specific port */
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 */
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];
203 void *private; /* data private to the specific driver */
206 static inline int port_paranoia_check(struct usb_serial_port *port,
207 const char *function)
210 dbg("%s - port == NULL", function);
214 dbg("%s - port->serial == NULL\n", function);
218 dbg("%s - port->tty == NULL\n", function);
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)
230 dbg("%s - serial == NULL\n", function);
237 static inline struct usb_serial *get_usb_serial(struct usb_serial_port *port,
238 const char *function)
240 /* if no port was specified, or it fails a paranoia check */
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 */
252 struct qt_get_device_data {
258 struct qt_open_channel_data {
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);
270 static int serqt_probe(struct usb_interface *interface,
271 const struct usb_device_id *id);
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,
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);
292 static int qt_open(struct usb_serial_port *port, struct file *filp);
293 static int BoxSetPrebufferLevel(struct usb_serial *serial);
295 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode);
296 static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
297 unsigned short default_divisor,
298 unsigned char default_LCR);
300 static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
302 struct qt_open_channel_data *pDeviceData);
303 static void qt_close(struct usb_serial_port *port, struct file *filp);
304 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
305 unsigned short Register_Num, __u8 *pValue);
306 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
307 unsigned short Register_Num, unsigned short Value);
308 static void qt_write_bulk_callback(struct urb *urb);
309 static int qt_write(struct usb_serial_port *port, int from_user,
310 const unsigned char *buf, int count);
311 static void port_softint(struct work_struct *work);
312 static int qt_write_room(struct usb_serial_port *port);
313 static int qt_chars_in_buffer(struct usb_serial_port *port);
314 static int qt_ioctl(struct usb_serial_port *port, struct file *file,
315 unsigned int cmd, unsigned long arg);
316 static void qt_set_termios(struct usb_serial_port *port,
317 struct ktermios *old_termios);
318 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int UartNumber,
320 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber);
321 static int EmulateWriteQMCR_Reg(int index, unsigned uc_value);
322 static int EmulateReadQMCR_Reg(int index, unsigned *uc_value);
323 static struct usb_serial *find_the_box(unsigned int index);
324 static int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
327 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 Uart,
328 unsigned char stop_char, unsigned char start_char);
329 static void qt_read_bulk_callback(struct urb *urb);
331 static void port_sofrint(void *private);
333 static void return_serial(struct usb_serial *serial);
335 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
336 unsigned int set, unsigned int clear);
337 static int serial_tiocmget(struct tty_struct *tty, struct file *file);
339 static int qt_tiocmset(struct usb_serial_port *port, struct file *file,
342 static int qt_tiocmget(struct usb_serial_port *port, struct file *file);
344 /* Version Information */
345 #define DRIVER_VERSION "v2.14"
346 #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
347 #define DRIVER_DESC "Quatech USB to Serial Driver"
349 #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
350 #define DEVICE_ID_QUATECH_RS232_SINGLE_PORT 0xC020 /* SSU100 */
351 #define DEVICE_ID_QUATECH_RS422_SINGLE_PORT 0xC030 /* SSU200 */
352 #define DEVICE_ID_QUATECH_RS232_DUAL_PORT 0xC040 /* DSU100 */
353 #define DEVICE_ID_QUATECH_RS422_DUAL_PORT 0xC050 /* DSU200 */
354 #define DEVICE_ID_QUATECH_RS232_FOUR_PORT 0xC060 /* QSU100 */
355 #define DEVICE_ID_QUATECH_RS422_FOUR_PORT 0xC070 /* QSU200 */
356 #define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A 0xC080 /* ESU100A */
357 #define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B 0xC081 /* ESU100B */
358 #define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A 0xC0A0 /* ESU200A */
359 #define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B 0xC0A1 /* ESU200B */
360 #define DEVICE_ID_QUATECH_RS232_16_PORT_A 0xC090 /* HSU100A */
361 #define DEVICE_ID_QUATECH_RS232_16_PORT_B 0xC091 /* HSU100B */
362 #define DEVICE_ID_QUATECH_RS232_16_PORT_C 0xC092 /* HSU100C */
363 #define DEVICE_ID_QUATECH_RS232_16_PORT_D 0xC093 /* HSU100D */
364 #define DEVICE_ID_QUATECH_RS422_16_PORT_A 0xC0B0 /* HSU200A */
365 #define DEVICE_ID_QUATECH_RS422_16_PORT_B 0xC0B1 /* HSU200B */
366 #define DEVICE_ID_QUATECH_RS422_16_PORT_C 0xC0B2 /* HSU200C */
367 #define DEVICE_ID_QUATECH_RS422_16_PORT_D 0xC0B3 /* HSU200D */
369 /* table of Quatech devices */
370 static struct usb_device_id serqt_table[] = {
372 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_SINGLE_PORT)},
374 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_SINGLE_PORT)},
375 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_DUAL_PORT)},
376 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_DUAL_PORT)},
377 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_FOUR_PORT)},
378 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_FOUR_PORT)},
380 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A)},
382 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B)},
384 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A)},
386 (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B)},
387 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_A)},
388 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_B)},
389 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_C)},
390 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_D)},
391 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_A)},
392 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_B)},
393 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_C)},
394 {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_D)},
395 {} /* Terminating entry */
398 MODULE_DEVICE_TABLE(usb, serqt_table);
400 static int major_number;
401 static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
403 /* table of Quatech 422devices */
404 static unsigned int serqt_422_table[] = {
405 DEVICE_ID_QUATECH_RS422_SINGLE_PORT,
406 DEVICE_ID_QUATECH_RS422_DUAL_PORT,
407 DEVICE_ID_QUATECH_RS422_FOUR_PORT,
408 DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A,
409 DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B,
410 DEVICE_ID_QUATECH_RS422_16_PORT_A,
411 DEVICE_ID_QUATECH_RS422_16_PORT_B,
412 DEVICE_ID_QUATECH_RS422_16_PORT_C,
413 DEVICE_ID_QUATECH_RS422_16_PORT_D,
414 0 /* terminate with zero */
417 /* usb specific object needed to register this driver with the usb subsystem */
418 static struct usb_driver serqt_usb_driver = {
419 .name = "quatech-usb-serial",
420 .probe = serqt_probe,
421 .disconnect = serqt_usb_disconnect,
422 .id_table = serqt_table,
425 static struct ktermios *serial_termios[SERIAL_TTY_MINORS];
426 static struct ktermios *serial_termios_locked[SERIAL_TTY_MINORS];
428 static const struct tty_operations serial_ops = {
430 .close = serial_close,
431 .write = serial_write,
432 .write_room = serial_write_room,
433 .ioctl = serial_ioctl,
434 .set_termios = serial_set_termios,
435 .throttle = serial_throttle,
436 .unthrottle = serial_unthrottle,
437 .break_ctl = serial_break,
438 .chars_in_buffer = serial_chars_in_buffer,
439 .tiocmset = serial_tiocmset,
440 .tiocmget = serial_tiocmget,
443 static struct tty_driver serial_tty_driver = {
444 .magic = TTY_DRIVER_MAGIC,
445 .driver_name = "Quatech usb-serial",
447 .major = SERIAL_TTY_MAJOR,
449 .num = SERIAL_TTY_MINORS,
450 .type = TTY_DRIVER_TYPE_SERIAL,
451 .subtype = SERIAL_TYPE_NORMAL,
452 .flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV,
454 .termios = serial_termios,
455 .termios_locked = serial_termios_locked,
456 .init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL,
458 .init_termios.c_iflag = ICRNL | IXON,
459 .init_termios.c_oflag = OPOST,
461 .init_termios.c_lflag =
462 ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN,
465 /* fops for parent device */
466 static const struct file_operations serialqt_usb_fops = {
467 .ioctl = ioctl_serial_usb,
473 * Called by the usb core when a new device is connected that it thinks
474 * this driver might be interested in.
477 static int serqt_probe(struct usb_interface *interface,
478 const struct usb_device_id *id)
480 struct usb_device *dev = interface_to_usbdev(interface);
481 struct usb_serial *serial = NULL;
482 struct usb_serial_port *port;
483 struct usb_endpoint_descriptor *endpoint;
484 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
485 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
486 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
490 struct usb_host_interface *iface_desc;
491 int num_interrupt_in = 0;
493 int num_bulk_out = 0;
495 struct qt_get_device_data DeviceData;
498 mydbg("In %s\n", __func__);
500 /* let's find the endpoints needed */
501 /* check out the endpoints */
502 iface_desc = interface->cur_altsetting;;
503 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
504 endpoint = &iface_desc->endpoint[i].desc;
506 if ((endpoint->bEndpointAddress & 0x80) &&
507 ((endpoint->bmAttributes & 3) == 0x02)) {
508 /* we found a bulk in endpoint */
509 mydbg("found bulk in");
510 bulk_in_endpoint[num_bulk_in] = endpoint;
514 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
515 ((endpoint->bmAttributes & 3) == 0x02)) {
516 /* we found a bulk out endpoint */
517 mydbg("found bulk out\n");
518 bulk_out_endpoint[num_bulk_out] = endpoint;
522 if ((endpoint->bEndpointAddress & 0x80) &&
523 ((endpoint->bmAttributes & 3) == 0x03)) {
524 /* we found a interrupt in endpoint */
525 mydbg("found interrupt in\n");
526 interrupt_in_endpoint[num_interrupt_in] = endpoint;
531 /* found all that we need */
532 dev_info(&interface->dev, "Quatech converter detected\n");
533 num_ports = num_bulk_out;
534 if (num_ports == 0) {
535 err("Quatech device with no bulk out, not allowed.");
540 serial = get_free_serial(num_ports, &minor);
541 if (serial == NULL) {
542 err("No more free serial devices");
547 serial->interface = interface;
548 serial->minor = minor;
549 serial->num_ports = num_ports;
550 serial->num_bulk_in = num_bulk_in;
551 serial->num_bulk_out = num_bulk_out;
552 serial->num_interrupt_in = num_interrupt_in;
553 serial->vendor = dev->descriptor.idVendor;
554 serial->product = dev->descriptor.idProduct;
556 /* set up the endpoint information */
557 for (i = 0; i < num_bulk_in; ++i) {
558 endpoint = bulk_in_endpoint[i];
559 port = &serial->port[i];
560 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
561 if (!port->read_urb) {
562 err("No free urbs available");
565 buffer_size = endpoint->wMaxPacketSize;
566 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
567 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
568 port->xfer_to_tty_buffer = kmalloc(buffer_size, GFP_KERNEL);
569 if (!port->bulk_in_buffer) {
570 err("Couldn't allocate bulk_in_buffer");
573 usb_fill_bulk_urb(port->read_urb, dev,
575 endpoint->bEndpointAddress),
576 port->bulk_in_buffer, buffer_size,
577 qt_read_bulk_callback, port);
580 for (i = 0; i < num_bulk_out; ++i) {
581 endpoint = bulk_out_endpoint[i];
582 port = &serial->port[i];
583 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
584 if (!port->write_urb) {
585 err("No free urbs available");
588 buffer_size = endpoint->wMaxPacketSize;
589 port->bulk_out_size = buffer_size;
590 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
591 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
592 if (!port->bulk_out_buffer) {
593 err("Couldn't allocate bulk_out_buffer");
596 usb_fill_bulk_urb(port->write_urb, dev,
598 endpoint->bEndpointAddress),
599 port->bulk_out_buffer, buffer_size,
600 qt_write_bulk_callback, port);
604 /* For us numb of bulkin or out = number of ports */
605 mydbg("%s - setting up %d port structures for this device\n",
606 __func__, num_bulk_in);
607 for (i = 0; i < num_bulk_in; ++i) {
608 port = &serial->port[i];
609 port->number = i + serial->minor;
610 port->serial = serial;
612 INIT_WORK(&port->work, port_softint);
614 init_MUTEX(&port->sem);
617 status = box_get_device(serial, &DeviceData);
619 mydbg(__FILE__ "box_get_device failed");
623 mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
625 DeviceData.portb &= ~FULLPWRBIT;
626 mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
628 status = box_set_device(serial, &DeviceData);
630 mydbg(__FILE__ "box_set_device failed\n");
634 /* initialize the devfs nodes for this device and let the user know what ports we are bound to */
635 for (i = 0; i < serial->num_ports; ++i) {
636 dev_info(&interface->dev,
637 "Converter now attached to ttyUSB%d (or usb/tts/%d for devfs)",
638 serial->port[i].number, serial->port[i].number);
641 /* usb_serial_console_init (debug, minor); */
643 /***********TAG add start next board here ****/
644 status = box_get_device(serial, &DeviceData);
646 mydbg(__FILE__ "box_get_device failed");
650 * and before we power up lets initialiaze parnent device stuff here before
651 * we set thmem via any other method such as the property pages
653 switch (serial->product) {
654 case DEVICE_ID_QUATECH_RS232_SINGLE_PORT:
655 case DEVICE_ID_QUATECH_RS232_DUAL_PORT:
656 case DEVICE_ID_QUATECH_RS232_FOUR_PORT:
657 case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A:
658 case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B:
659 case DEVICE_ID_QUATECH_RS232_16_PORT_A:
660 case DEVICE_ID_QUATECH_RS232_16_PORT_B:
661 case DEVICE_ID_QUATECH_RS232_16_PORT_C:
662 case DEVICE_ID_QUATECH_RS232_16_PORT_D:
663 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
664 DeviceData.porta |= CLKS_X4;
665 DeviceData.portb &= ~(LOOPMODE_BITS);
666 DeviceData.portb |= RS232_MODE;
669 case DEVICE_ID_QUATECH_RS422_SINGLE_PORT:
670 case DEVICE_ID_QUATECH_RS422_DUAL_PORT:
671 case DEVICE_ID_QUATECH_RS422_FOUR_PORT:
672 case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A:
673 case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B:
674 case DEVICE_ID_QUATECH_RS422_16_PORT_A:
675 case DEVICE_ID_QUATECH_RS422_16_PORT_B:
676 case DEVICE_ID_QUATECH_RS422_16_PORT_C:
677 case DEVICE_ID_QUATECH_RS422_16_PORT_D:
678 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
679 DeviceData.porta |= CLKS_X4;
680 DeviceData.portb &= ~(LOOPMODE_BITS);
681 DeviceData.portb |= ALL_LOOPBACK;
684 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
685 DeviceData.porta |= CLKS_X4;
686 DeviceData.portb &= ~(LOOPMODE_BITS);
687 DeviceData.portb |= RS232_MODE;
691 status = BoxSetPrebufferLevel(serial); /* sets to default vaue */
693 mydbg(__FILE__ "BoxSetPrebufferLevel failed\n");
697 status = BoxSetATC(serial, ATC_DISABLED);
699 mydbg(__FILE__ "BoxSetATC failed\n");
702 /**********************************************************/
703 mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
705 DeviceData.portb |= NEXT_BOARD_POWER_BIT;
706 mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
708 status = box_set_device(serial, &DeviceData);
710 mydbg(__FILE__ "box_set_device failed\n");
714 mydbg("Exit Success %s\n", __func__);
716 usb_set_intfdata(interface, serial);
721 for (i = 0; i < num_bulk_in; ++i) {
722 port = &serial->port[i];
723 usb_free_urb(port->read_urb);
724 kfree(port->bulk_in_buffer);
726 for (i = 0; i < num_bulk_out; ++i) {
727 port = &serial->port[i];
728 usb_free_urb(port->write_urb);
729 kfree(port->bulk_out_buffer);
730 kfree(port->xfer_to_tty_buffer);
732 for (i = 0; i < num_interrupt_in; ++i) {
733 port = &serial->port[i];
734 usb_free_urb(port->interrupt_in_urb);
735 kfree(port->interrupt_in_buffer);
738 /* return the minor range that this device had */
739 return_serial(serial);
740 mydbg("Exit fail %s\n", __func__);
742 /* free up any memory that we allocated */
748 * returns the serial_table array pointers that are taken
749 * up in consecutive positions for each port to a common usb_serial structure
752 static void return_serial(struct usb_serial *serial)
756 mydbg("%s\n", __func__);
761 for (i = 0; i < serial->num_ports; ++i)
762 serial_table[serial->minor + i] = NULL;
768 * Finds the first locatio int the serial_table array where it can fit
769 * num_ports number of consecutive points to a common usb_serial
770 * structure,allocates a stucture points to it in all the structures, and
771 * returns the index to the first location in the array in the "minor"
774 static struct usb_serial *get_free_serial(int num_ports, int *minor)
776 struct usb_serial *serial = NULL;
780 mydbg("%s %d\n", __func__, num_ports);
783 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
789 * find a spot in the array where you can fit consecutive
790 * positions to put the pointers to the usb_serail allocated
791 * structure for all the minor numbers (ie. ports)
793 for (j = 1; j <= num_ports - 1; ++j)
794 if (serial_table[i + j])
799 serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL);
801 err("%s - Out of memory", __func__);
804 memset(serial, 0, sizeof(struct usb_serial));
805 serial_table[i] = serial;
807 mydbg("%s - minor base = %d\n", __func__, *minor);
810 * copy in the pointer into the array starting a the *minor
811 * position minor is the index into the array.
814 (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
815 serial_table[i] = serial;
821 static int flip_that(struct tty_struct *tty, __u16 UartNumber,
822 struct usb_serial *serial)
824 tty_flip_buffer_push(tty);
825 tty_schedule_flip(tty);
829 /* Handles processing and moving data to the tty layer */
830 static void port_sofrint(void *private)
832 struct usb_serial_port *port = (struct usb_serial_port *)private;
833 struct usb_serial *serial = get_usb_serial(port, __func__);
834 struct tty_struct *tty = port->tty;
835 unsigned char *data = port->read_urb->transfer_buffer;
836 unsigned int UartNumber;
837 struct urb *urb = port->read_urb;
838 unsigned int RxCount = urb->actual_length;
842 /* UartNumber = MINOR(port->tty->device) - serial->minor; */
843 UartNumber = tty->index - serial->minor;
845 mydbg("%s - port %d\n", __func__, port->number);
846 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
848 if (port_paranoia_check(port, __func__) != 0) {
849 mydbg("%s - port_paranoia_check, exiting\n", __func__);
850 port->ReadBulkStopped = 1;
855 mydbg("%s - bad serial pointer, exiting\n", __func__);
858 if (port->closePending == 1) {
859 /* Were closing , stop reading */
860 mydbg("%s - (port->closepending == 1\n", __func__);
861 port->ReadBulkStopped = 1;
866 * RxHolding is asserted by throttle, if we assert it, we're not
867 * receiving any more characters and let the box handle the flow
870 if (port->RxHolding == 1) {
871 port->ReadBulkStopped = 1;
876 port->ReadBulkStopped = 1;
878 mydbg("%s - nonzero read bulk status received: %d\n",
879 __func__, urb->status);
884 mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
886 if (tty && RxCount) {
888 for (i = 0; i < RxCount; ++i) {
889 /* Look ahead code here */
890 if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b)
891 && (NEXTCHAR == 0x1b)) {
895 /* Line status change 4th byte must follow */
896 if (i > (RxCount - 4)) {
897 mydbg("Illegal escape sequences in received data\n");
900 ProcessLineStatus(port, FOURTHCHAR);
906 /* Modem status status change 4th byte must follow */
907 mydbg("Modem status status. \n");
908 if (i > (RxCount - 4)) {
910 ("Illegal escape sequences in received data\n");
913 ProcessModemStatus(port, FOURTHCHAR);
918 mydbg("No status sequence. \n");
920 ProcessRxChar(port, THISCHAR);
921 ProcessRxChar(port, NEXTCHAR);
929 if (tty && urb->actual_length) {
930 tty_buffer_request_room(tty, 1);
931 tty_insert_flip_string(tty, (data + i), 1);
935 tty_flip_buffer_push(tty);
938 /* Continue trying to always read */
939 usb_fill_bulk_urb(port->read_urb, serial->dev,
940 usb_rcvbulkpipe(serial->dev,
941 port->bulk_in_endpointAddress),
942 port->read_urb->transfer_buffer,
943 port->read_urb->transfer_buffer_length,
944 qt_read_bulk_callback, port);
945 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
947 mydbg("%s - failed resubmitting read urb, error %d",
951 flip_that(tty, UartNumber, serial);
958 static void qt_read_bulk_callback(struct urb *urb)
961 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
964 port->ReadBulkStopped = 1;
965 mydbg("%s - nonzero write bulk status received: %d\n",
966 __func__, urb->status);
970 port_sofrint((void *)port);
971 schedule_work(&port->work);
974 static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data)
976 struct tty_struct *tty;
977 struct urb *urb = port->read_urb;
979 /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
981 if (tty && urb->actual_length) {
982 tty_buffer_request_room(tty, 1);
983 tty_insert_flip_string(tty, &Data, 1);
984 /* tty_flip_buffer_push(tty); */
990 static void ProcessLineStatus(struct usb_serial_port *port,
991 unsigned char line_status)
995 line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
1000 static void ProcessModemStatus(struct usb_serial_port *port,
1001 unsigned char modem_status)
1004 port->shadowMSR = modem_status;
1005 wake_up_interruptible(&port->wait);
1009 static void serqt_usb_disconnect(struct usb_interface *interface)
1011 struct usb_serial *serial = usb_get_intfdata(interface);
1012 /* struct device *dev = &interface->dev; */
1013 struct usb_serial_port *port;
1016 mydbg("%s\n", __func__);
1021 for (i = 0; i < serial->num_ports; ++i)
1022 serial->port[i].open_count = 0;
1024 for (i = 0; i < serial->num_bulk_in; ++i) {
1025 port = &serial->port[i];
1026 usb_unlink_urb(port->read_urb);
1027 usb_free_urb(port->read_urb);
1028 kfree(port->bulk_in_buffer);
1030 for (i = 0; i < serial->num_bulk_out; ++i) {
1031 port = &serial->port[i];
1032 usb_unlink_urb(port->write_urb);
1033 usb_free_urb(port->write_urb);
1034 kfree(port->bulk_out_buffer);
1036 for (i = 0; i < serial->num_interrupt_in; ++i) {
1037 port = &serial->port[i];
1038 usb_unlink_urb(port->interrupt_in_urb);
1039 usb_free_urb(port->interrupt_in_urb);
1040 kfree(port->interrupt_in_buffer);
1043 /* return the minor range that this device had */
1044 return_serial(serial);
1046 /* free up any memory that we allocated */
1050 dev_info(&interface->dev, "device disconnected");
1055 static struct usb_serial *get_serial_by_minor(unsigned int minor)
1057 return serial_table[minor];
1060 /*****************************************************************************
1061 * Driver tty interface functions
1062 *****************************************************************************/
1063 static int serial_open(struct tty_struct *tty, struct file *filp)
1065 struct usb_serial *serial;
1066 struct usb_serial_port *port;
1067 unsigned int portNumber;
1070 mydbg("%s\n", __func__);
1072 /* initialize the pointer incase something fails */
1073 tty->driver_data = NULL;
1075 /* get the serial object associated with this tty pointer */
1076 /* serial = get_serial_by_minor (MINOR(tty->device)); */
1078 /* get the serial object associated with this tty pointer */
1079 serial = get_serial_by_minor(tty->index);
1081 if (serial_paranoia_check(serial, __func__))
1084 /* set up our port structure making the tty driver remember our port object, and us it */
1085 portNumber = tty->index - serial->minor;
1086 port = &serial->port[portNumber];
1087 tty->driver_data = port;
1093 if (port->open_count == 1) {
1094 port->closePending = 0;
1095 mydbg("%s port->closepending = 0\n", __func__);
1097 port->RxHolding = 0;
1098 mydbg("%s port->RxHolding = 0\n", __func__);
1100 retval = qt_open(port, filp);
1104 port->open_count = 0;
1105 mydbg("%s returning port->closePending = %d\n", __func__,
1106 port->closePending);
1112 /*****************************************************************************
1113 *device's specific driver functions
1114 *****************************************************************************/
1115 static int qt_open(struct usb_serial_port *port, struct file *filp)
1117 struct usb_serial *serial = port->serial;
1119 unsigned int UartNumber;
1120 struct qt_get_device_data DeviceData;
1121 struct qt_open_channel_data ChannelData;
1122 unsigned short default_divisor = 0x30; /* gives 9600 baud rate */
1123 unsigned char default_LCR = SERIAL_8_DATA; /* 8, none , 1 */
1126 if (port_paranoia_check(port, __func__))
1129 mydbg("%s - port %d\n", __func__, port->number);
1131 /* force low_latency on so that our tty_push actually forces the data through,
1132 otherwise it is scheduled, and with high data rates (like with OHCI) data
1135 port->tty->low_latency = 0;
1137 UartNumber = port->tty->index - serial->minor;
1139 status = box_get_device(serial, &DeviceData);
1141 mydbg(__FILE__ "box_get_device failed\n");
1144 serial->num_OpenCount++;
1145 mydbg("%s serial->num_OpenCount = %d\n", __func__,
1146 serial->num_OpenCount);
1147 /* Open uart channel */
1149 /* Port specific setups */
1150 status = BoxOPenCloseChannel(serial, UartNumber, 1, &ChannelData);
1152 mydbg(__FILE__ "BoxOPenCloseChannel failed\n");
1155 mydbg(__FILE__ "BoxOPenCloseChannel completed.\n");
1157 port->shadowLSR = ChannelData.line_status &
1158 (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
1160 port->shadowMSR = ChannelData.modem_status &
1161 (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
1163 /* Set Baud rate to default and turn off (default)flow control here */
1164 status = BoxSetUart(serial, UartNumber, default_divisor, default_LCR);
1166 mydbg(__FILE__ "BoxSetUart failed\n");
1169 mydbg(__FILE__ "BoxSetUart completed.\n");
1171 /* Put this here to make it responsive to stty and defauls set by the tty layer */
1172 qt_set_termios(port, NULL);
1174 /* Initialize the wait que head */
1175 init_waitqueue_head(&(port->wait));
1177 /* if we have a bulk endpoint, start reading from it */
1178 if (serial->num_bulk_in) {
1179 /* Start reading from the device */
1180 usb_fill_bulk_urb(port->read_urb, serial->dev,
1181 usb_rcvbulkpipe(serial->dev,
1183 bulk_in_endpointAddress),
1184 port->read_urb->transfer_buffer,
1185 port->read_urb->transfer_buffer_length,
1186 qt_read_bulk_callback, port);
1188 port->ReadBulkStopped = 0;
1190 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1193 err("%s - failed resubmitting read urb, error %d\n",
1195 port->ReadBulkStopped = 1;
1203 static void serial_close(struct tty_struct *tty, struct file *filp)
1205 struct usb_serial_port *port =
1206 (struct usb_serial_port *)tty->driver_data;
1207 struct usb_serial *serial = get_usb_serial(port, __func__);
1214 mydbg("%s - port %d\n", __func__, port->number);
1216 /* if disconnect beat us to the punch here, there's nothing to do */
1217 if (tty->driver_data) {
1218 if (!port->open_count) {
1219 mydbg("%s - port not opened\n", __func__);
1224 if (port->open_count <= 0) {
1225 port->closePending = 1;
1226 mydbg("%s - port->closePending = 1\n", __func__);
1229 qt_close(port, filp);
1230 port->open_count = 0;
1239 mydbg("%s - %d return\n", __func__, port->number);
1243 static void qt_close(struct usb_serial_port *port, struct file *filp)
1245 unsigned long jift = jiffies + 10 * HZ;
1246 __u8 LSR_Value, MCR_Value;
1247 struct usb_serial *serial = port->serial;
1249 unsigned int UartNumber;
1251 struct qt_open_channel_data ChannelData;
1255 mydbg("%s - port %d\n", __func__, port->number);
1256 UartNumber = port->tty->index - serial->minor;
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);
1264 /* wait up to 30 seconds for transmitter to empty */
1266 status = BoxGetRegister(serial, UartNumber, LINE_STATUS_REGISTER, &LSR_Value);
1268 mydbg(__FILE__ "box_get_device failed\n");
1272 if ((LSR_Value & SERIAL_LSR_TEMT)
1273 && (port->ReadBulkStopped == 1))
1278 while (jiffies <= jift)
1282 mydbg("%s - port %d timout of checking transmitter empty\n",
1283 __func__, port->number);
1285 mydbg("%s - port %d checking transmitter empty succeded\n",
1286 __func__, port->number);
1289 BoxGetRegister(serial, UartNumber, MODEM_CONTROL_REGISTER,
1291 mydbg(__FILE__ "BoxGetRegister MCR = 0x%x.\n", MCR_Value);
1294 MCR_Value &= ~(SERIAL_MCR_DTR | SERIAL_MCR_RTS);
1295 /* status = BoxSetRegister(serial, UartNumber, MODEM_CONTROL_REGISTER, MCR_Value); */
1298 /* Close uart channel */
1299 status = BoxOPenCloseChannel(serial, UartNumber, 0, &ChannelData);
1301 mydbg("%s - port %d BoxOPenCloseChannel failed.\n",
1302 __func__, port->number);
1304 serial->num_OpenCount--;
1308 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
1311 struct usb_serial_port *port =
1312 (struct usb_serial_port *)tty->driver_data;
1313 struct usb_serial *serial;
1314 int retval = -EINVAL;
1315 unsigned int UartNumber;
1318 serial = get_usb_serial(port, __func__);
1321 /* This can happen if we get disconnected a */
1322 if (port->open_count == 0)
1324 UartNumber = port->tty->index - serial->minor;
1326 mydbg("%s - port %d, %d byte(s)\n", __func__, port->number, count);
1327 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1329 if (!port->open_count) {
1330 mydbg("%s - port not opened\n", __func__);
1334 retval = qt_write(port, from_user, buf, count);
1340 static int qt_write(struct usb_serial_port *port, int from_user,
1341 const unsigned char *buf, int count)
1344 unsigned int UartNumber;
1346 struct usb_serial *serial = get_usb_serial(port, __func__);
1350 mydbg("%s - port %d\n", __func__, port->number);
1353 mydbg("%s - write request of 0 bytes\n", __func__);
1357 UartNumber = port->tty->index - serial->minor;
1358 /* only do something if we have a bulk out endpoint */
1359 if (serial->num_bulk_out) {
1360 if (port->write_urb->status == -EINPROGRESS) {
1361 mydbg("%s - already writing\n", __func__);
1366 (count > port->bulk_out_size) ? port->bulk_out_size : count;
1370 (port->write_urb->transfer_buffer, buf, count))
1373 memcpy(port->write_urb->transfer_buffer, buf, count);
1376 /* usb_serial_debug_data(__FILE__, __func__, count, port->write_urb->transfer_buffer); */
1378 /* set up our urb */
1380 usb_fill_bulk_urb(port->write_urb, serial->dev,
1381 usb_sndbulkpipe(serial->dev,
1383 bulk_out_endpointAddress),
1384 port->write_urb->transfer_buffer, count,
1385 qt_write_bulk_callback, port);
1387 /* send the data out the bulk port */
1388 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1390 mydbg("%s - failed submitting write urb, error %d\n",
1398 /* no bulk out, so return 0 bytes written */
1402 static void qt_write_bulk_callback(struct urb *urb)
1404 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1405 struct usb_serial *serial = get_usb_serial(port, __func__);
1407 mydbg("%s - port %d\n", __func__, port->number);
1410 mydbg("%s - bad serial pointer, exiting\n", __func__);
1415 mydbg("%s - nonzero write bulk status received: %d\n",
1416 __func__, urb->status);
1419 port_softint(&port->work);
1420 schedule_work(&port->work);
1425 static void port_softint(struct work_struct *work)
1427 struct usb_serial_port *port =
1428 container_of(work, struct usb_serial_port, work);
1429 struct usb_serial *serial = get_usb_serial(port, __func__);
1430 struct tty_struct *tty;
1432 mydbg("%s - port %d\n", __func__, port->number);
1441 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP))
1442 && tty->ldisc.write_wakeup) {
1443 mydbg("%s - write wakeup call.\n", __func__);
1444 (tty->ldisc.write_wakeup) (tty);
1448 wake_up_interruptible(&tty->write_wait);
1450 static int serial_write_room(struct tty_struct *tty)
1452 struct usb_serial_port *port =
1453 (struct usb_serial_port *)tty->driver_data;
1454 struct usb_serial *serial = get_usb_serial(port, __func__);
1455 int retval = -EINVAL;
1462 mydbg("%s - port %d\n", __func__, port->number);
1464 if (!port->open_count) {
1465 mydbg("%s - port not open\n", __func__);
1469 retval = qt_write_room(port);
1475 static int qt_write_room(struct usb_serial_port *port)
1477 struct usb_serial *serial = port->serial;
1479 if (port->closePending == 1) {
1480 mydbg("%s - port->closePending == 1\n", __func__);
1484 mydbg("%s - port %d\n", __func__, port->number);
1486 if (serial->num_bulk_out) {
1487 if (port->write_urb->status != -EINPROGRESS)
1488 room = port->bulk_out_size;
1491 mydbg("%s - returns %d\n", __func__, room);
1494 static int serial_chars_in_buffer(struct tty_struct *tty)
1496 struct usb_serial_port *port =
1497 (struct usb_serial_port *)tty->driver_data;
1498 struct usb_serial *serial = get_usb_serial(port, __func__);
1499 int retval = -EINVAL;
1506 mydbg("%s = port %d\n", __func__, port->number);
1508 if (!port->open_count) {
1509 mydbg("%s - port not open\n", __func__);
1513 retval = qt_chars_in_buffer(port);
1520 static int qt_chars_in_buffer(struct usb_serial_port *port)
1522 struct usb_serial *serial = port->serial;
1525 mydbg("%s - port %d\n", __func__, port->number);
1527 if (serial->num_bulk_out) {
1528 if (port->write_urb->status == -EINPROGRESS)
1529 chars = port->write_urb->transfer_buffer_length;
1532 mydbg("%s - returns %d\n", __func__, chars);
1536 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
1537 unsigned int set, unsigned int clear)
1540 struct usb_serial_port *port =
1541 (struct usb_serial_port *)tty->driver_data;
1542 struct usb_serial *serial = get_usb_serial(port, __func__);
1543 int retval = -ENODEV;
1544 unsigned int UartNumber;
1545 mydbg("In %s \n", __func__);
1550 UartNumber = port->tty->index - serial->minor;
1554 mydbg("%s - port %d \n", __func__, port->number);
1555 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1557 if (!port->open_count) {
1558 mydbg("%s - port not open\n", __func__);
1562 retval = qt_tiocmset(port, file, set);
1569 static int qt_tiocmset(struct usb_serial_port *port, struct file *file,
1575 unsigned int UartNumber;
1577 struct usb_serial *serial = get_usb_serial(port, __func__);
1581 mydbg("%s - port %d\n", __func__, port->number);
1583 /**************************************************************************************/
1586 UartNumber = port->tty->index - serial->minor;
1588 BoxGetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER,
1594 * Turn off the RTS and DTR and loopbcck and then only turn on what was
1597 MCR_Value &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
1598 if (value & TIOCM_RTS)
1599 MCR_Value |= SERIAL_MCR_RTS;
1600 if (value & TIOCM_DTR)
1601 MCR_Value |= SERIAL_MCR_DTR;
1602 if (value & TIOCM_LOOP)
1603 MCR_Value |= SERIAL_MCR_LOOP;
1606 BoxSetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER,
1614 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
1617 struct usb_serial_port *port =
1618 (struct usb_serial_port *)tty->driver_data;
1620 struct usb_serial *serial = get_usb_serial(port, __func__);
1621 int retval = -ENODEV;
1622 unsigned int UartNumber;
1623 mydbg("In %s \n", __func__);
1628 UartNumber = port->tty->index - serial->minor;
1632 mydbg("%s - port %d\n", __func__, port->number);
1633 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1635 if (!port->open_count) {
1636 mydbg("%s - port not open\n", __func__);
1640 retval = qt_tiocmget(port, file);
1647 static int qt_tiocmget(struct usb_serial_port *port, struct file *file)
1652 unsigned int result = 0;
1654 unsigned int UartNumber;
1655 struct tty_struct *tty;
1657 struct usb_serial *serial = get_usb_serial(port, __func__);
1662 mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
1664 /**************************************************************************************/
1667 UartNumber = port->tty->index - serial->minor;
1669 BoxGetRegister(port->serial, UartNumber, MODEM_CONTROL_REGISTER,
1673 BoxGetRegister(port->serial, UartNumber,
1674 MODEM_STATUS_REGISTER, &MSR_Value);
1679 result = ((MCR_Value & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1681 | ((MCR_Value & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1683 | ((MSR_Value & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1685 | ((MSR_Value & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1686 /* Carrier detect is set */
1687 | ((MSR_Value & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1688 /* Ring indicator set */
1689 | ((MSR_Value & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1697 static int serial_ioctl(struct tty_struct *tty, struct file *file,
1698 unsigned int cmd, unsigned long arg)
1701 struct usb_serial_port *port =
1702 (struct usb_serial_port *)tty->driver_data;
1703 struct usb_serial *serial = get_usb_serial(port, __func__);
1704 int retval = -ENODEV;
1705 unsigned int UartNumber;
1706 mydbg("In %s \n", __func__);
1711 UartNumber = port->tty->index - serial->minor;
1715 mydbg("%s - port %d, cmd 0x%.4x\n", __func__, port->number, cmd);
1716 mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1718 if (!port->open_count) {
1719 mydbg("%s - port not open\n", __func__);
1723 retval = qt_ioctl(port, file, cmd, arg);
1729 static int qt_ioctl(struct usb_serial_port *port, struct file *file,
1730 unsigned int cmd, unsigned long arg)
1734 unsigned short Prev_MSR_Value;
1735 unsigned int value, result = 0;
1737 unsigned int UartNumber;
1738 struct tty_struct *tty;
1740 struct usb_serial *serial = get_usb_serial(port, __func__);
1745 mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
1748 UartNumber = port->tty->index - serial->minor;
1750 if (cmd == TIOCMGET) {
1751 MCR_Value = port->shadowMCR;
1752 MSR_Value = port->shadowMSR;
1755 result = ((MCR_Value & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1757 | ((MCR_Value & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1759 | ((MSR_Value & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1761 | ((MSR_Value & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1762 /* Carrier detect is set */
1763 | ((MSR_Value & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1764 /* Ring indicator set */
1765 | ((MSR_Value & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1768 ((unsigned int *)arg, &result,
1769 sizeof(unsigned int)))
1776 /* TIOCMBIS, TIOCMBIC, AND TIOCMSET */
1777 if (cmd == TIOCMBIS || cmd == TIOCMBIC || cmd == TIOCMSET) {
1779 BoxGetRegister(port->serial, UartNumber,
1780 MODEM_CONTROL_REGISTER, &MCR_Value);
1784 (&value, (unsigned int *)arg, sizeof(unsigned int)))
1789 if (value & TIOCM_RTS)
1790 MCR_Value |= SERIAL_MCR_RTS;
1791 if (value & TIOCM_DTR)
1792 MCR_Value |= SERIAL_MCR_DTR;
1793 if (value & TIOCM_LOOP)
1794 MCR_Value |= SERIAL_MCR_LOOP;
1797 if (value & TIOCM_RTS)
1798 MCR_Value &= ~SERIAL_MCR_RTS;
1799 if (value & TIOCM_DTR)
1800 MCR_Value &= ~SERIAL_MCR_DTR;
1801 if (value & TIOCM_LOOP)
1802 MCR_Value &= ~SERIAL_MCR_LOOP;
1806 * Turn off the RTS and DTR and loopbcck and then only
1807 * turn on what was asked for
1810 ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR |
1812 if (value & TIOCM_RTS)
1813 MCR_Value |= SERIAL_MCR_RTS;
1814 if (value & TIOCM_DTR)
1815 MCR_Value |= SERIAL_MCR_DTR;
1816 if (value & TIOCM_LOOP)
1817 MCR_Value |= SERIAL_MCR_LOOP;
1824 BoxSetRegister(port->serial, UartNumber,
1825 MODEM_CONTROL_REGISTER, MCR_Value);
1829 port->shadowMCR = MCR_Value;
1834 /**************************************************************************************/
1835 /** TIOCMBIS, TIOCMBIC, AND TIOCMSET end
1837 /**************************************************************************************/
1839 if (cmd == TIOCMIWAIT) {
1840 DECLARE_WAITQUEUE(wait, current);
1841 Prev_MSR_Value = port->shadowMSR & SERIAL_MSR_MASK;
1843 add_wait_queue(&port->wait, &wait);
1844 set_current_state(TASK_INTERRUPTIBLE);
1846 remove_wait_queue(&port->wait, &wait);
1847 /* see if a signal woke us up */
1848 if (signal_pending(current))
1849 return -ERESTARTSYS;
1850 MSR_Value = port->shadowMSR & SERIAL_MSR_MASK;
1851 if (MSR_Value == Prev_MSR_Value)
1852 return -EIO; /* no change error */
1854 if ((arg & TIOCM_RNG
1855 && ((Prev_MSR_Value & SERIAL_MSR_RI) ==
1856 (MSR_Value & SERIAL_MSR_RI)))
1858 && ((Prev_MSR_Value & SERIAL_MSR_DSR) ==
1859 (MSR_Value & SERIAL_MSR_DSR)))
1861 && ((Prev_MSR_Value & SERIAL_MSR_CD) ==
1862 (MSR_Value & SERIAL_MSR_CD)))
1864 && ((Prev_MSR_Value & SERIAL_MSR_CTS) ==
1865 (MSR_Value & SERIAL_MSR_CTS)))) {
1872 mydbg("%s -No ioctl for that one. port = %d\n", __func__,
1875 return -ENOIOCTLCMD;
1878 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
1880 struct usb_serial_port *port =
1881 (struct usb_serial_port *)tty->driver_data;
1882 struct usb_serial *serial = get_usb_serial(port, __func__);
1889 mydbg("%s - port %d\n", __func__, port->number);
1891 if (!port->open_count) {
1892 mydbg("%s - port not open\n", __func__);
1896 /* pass on to the driver specific version of this function if it is available */
1897 qt_set_termios(port, old);
1903 static void qt_set_termios(struct usb_serial_port *port,
1904 struct ktermios *old_termios)
1907 int baud, divisor, remainder;
1908 unsigned char LCR_change_to = 0;
1909 struct tty_struct *tty;
1911 struct usb_serial *serial;
1915 mydbg("%s - port %d\n", __func__, port->number);
1917 tmp = port->tty->index;
1918 mydbg("%s - MINOR(port->tty->index) = %d\n", __func__, tmp);
1920 serial = port->serial;
1921 tmp2 = serial->minor;
1922 mydbg("%s - serial->minor = %d\n", __func__, tmp2);
1924 UartNumber = port->tty->index - serial->minor;
1928 cflag = tty->termios->c_cflag;
1931 if ((cflag == old_termios->c_cflag)
1932 && (RELEVANT_IFLAG(tty->termios->c_iflag) ==
1933 RELEVANT_IFLAG(old_termios->c_iflag))) {
1934 mydbg("%s - Nothing to change\n", __func__);
1940 mydbg("%s - 3\n", __func__);
1944 LCR_change_to |= SERIAL_5_DATA;
1947 LCR_change_to |= SERIAL_6_DATA;
1950 LCR_change_to |= SERIAL_7_DATA;
1954 LCR_change_to |= SERIAL_8_DATA;
1959 if (cflag & PARENB) {
1961 LCR_change_to |= SERIAL_ODD_PARITY;
1963 LCR_change_to |= SERIAL_EVEN_PARITY;
1966 LCR_change_to |= SERIAL_TWO_STOPB;
1968 LCR_change_to |= SERIAL_TWO_STOPB;
1970 mydbg("%s - 4\n", __func__);
1971 /* Thats the LCR stuff, go ahead and set it */
1972 baud = tty_get_baud_rate(tty);
1974 /* pick a default, any default... */
1978 mydbg("%s - got baud = %d\n", __func__, baud);
1980 divisor = MAX_BAUD_RATE / baud;
1981 remainder = MAX_BAUD_RATE % baud;
1982 /* Round to nearest divisor */
1983 if (((remainder * 2) >= baud) && (baud != 110))
1987 * Set Baud rate to default and turn off (default)flow control here
1990 BoxSetUart(serial, UartNumber, (unsigned short)divisor,
1993 mydbg(__FILE__ "BoxSetUart failed\n");
1997 /* Now determine flow control */
1998 if (cflag & CRTSCTS) {
1999 mydbg("%s - Enabling HW flow control port %d\n", __func__,
2002 /* Enable RTS/CTS flow control */
2003 status = BoxSetHW_FlowCtrl(serial, UartNumber, 1);
2006 mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
2010 /* Disable RTS/CTS flow control */
2011 mydbg("%s - disabling HW flow control port %d\n", __func__,
2014 status = BoxSetHW_FlowCtrl(serial, UartNumber, 0);
2016 mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
2022 /* if we are implementing XON/XOFF, set the start and stop character in
2024 if (I_IXOFF(tty) || I_IXON(tty)) {
2025 unsigned char stop_char = STOP_CHAR(tty);
2026 unsigned char start_char = START_CHAR(tty);
2028 BoxSetSW_FlowCtrl(serial, UartNumber, stop_char,
2031 mydbg(__FILE__ "BoxSetSW_FlowCtrl (enabled) failed\n");
2034 /* disable SW flow control */
2035 status = BoxDisable_SW_FlowCtrl(serial, UartNumber);
2037 mydbg(__FILE__ "BoxSetSW_FlowCtrl (diabling) failed\n");
2043 /****************************************************************************
2045 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
2046 * If successful, fills in the pValue with the register value asked for
2047 ****************************************************************************/
2048 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
2049 unsigned short Register_Num, __u8 *pValue)
2052 __u16 current_length;
2054 current_length = sizeof(struct qt_get_device_data);
2057 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
2058 QT_GET_SET_REGISTER, 0xC0, Register_Num,
2059 Uart_Number, (void *)pValue, sizeof(*pValue), 300);
2064 /****************************************************************************
2066 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
2067 * If successful, fills in the pValue with the register value asked for
2068 ****************************************************************************/
2069 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
2070 unsigned short Register_Num, unsigned short Value)
2073 unsigned short RegAndByte;
2076 RegAndByte = RegAndByte << 8;
2077 RegAndByte = RegAndByte + Register_Num;
2080 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2081 QT_GET_SET_REGISTER, 0xC0, Register_Num,
2082 Uart_Number, NULL, 0, 300);
2086 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2087 QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number,
2095 * Issue a GET_DEVICE vendor-specific request on the default control pipe If
2096 * successful, fills in the qt_get_device_data structure pointed to by
2097 * device_data, otherwise return a negative error number of the problem.
2099 static int box_get_device(struct usb_serial *serial,
2100 struct qt_get_device_data *device_data)
2103 __u16 current_length;
2104 unsigned char *transfer_buffer;
2106 current_length = sizeof(struct qt_get_device_data);
2107 transfer_buffer = kmalloc(current_length, GFP_KERNEL);
2108 if (!transfer_buffer)
2111 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
2112 QT_SET_GET_DEVICE, 0xc0, 0, 0,
2113 transfer_buffer, current_length, 300);
2115 memcpy(device_data, transfer_buffer, current_length);
2116 kfree(transfer_buffer);
2123 * Issue a SET_DEVICE vendor-specific request on the default control pipe If
2124 * successful returns the number of bytes written, otherwise it returns a
2125 * negative error number of the problem.
2127 static int box_set_device(struct usb_serial *serial,
2128 struct qt_get_device_data *device_data)
2134 PortSettings = ((__u16) (device_data->portb));
2135 PortSettings = (PortSettings << 8);
2136 PortSettings += ((__u16) (device_data->porta));
2138 length = sizeof(struct qt_get_device_data);
2139 mydbg("%s - PortSettings = 0x%x\n", __func__, PortSettings);
2141 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2142 QT_SET_GET_DEVICE, 0x40, PortSettings,
2147 /****************************************************************************
2148 * BoxOPenCloseChannel
2149 * This funciotn notifies the device that the device driver wishes to open a particular UART channel. its
2150 * purpose is to allow the device driver and the device to synchronize state information.
2151 * OpenClose = 1 for open , 0 for close
2152 ****************************************************************************/
2153 static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
2155 struct qt_open_channel_data *pDeviceData)
2161 length = sizeof(struct qt_open_channel_data);
2164 if (OpenClose == 1) {
2165 Direcion = USBD_TRANSFER_DIRECTION_IN;
2166 pipe = usb_rcvctrlpipe(serial->dev, 0);
2168 usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
2169 Direcion, OpenClose, Uart_Number,
2170 pDeviceData, length, 300);
2173 Direcion = USBD_TRANSFER_DIRECTION_OUT;
2174 pipe = usb_sndctrlpipe(serial->dev, 0);
2176 usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
2177 Direcion, OpenClose, Uart_Number, NULL, 0,
2185 /****************************************************************************
2186 * BoxSetPrebufferLevel
2187 TELLS BOX WHEN TO ASSERT FLOW CONTROL
2188 ****************************************************************************/
2189 static int BoxSetPrebufferLevel(struct usb_serial *serial)
2192 __u16 buffer_length;
2194 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
2195 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2196 QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
2197 buffer_length, 0, NULL, 0, 300);
2201 /****************************************************************************
2203 TELLS BOX WHEN TO ASSERT automatic transmitter control
2204 ****************************************************************************/
2205 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
2208 __u16 buffer_length;
2210 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
2213 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2214 QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
2219 /****************************************************************************
2221 * issuse a SET_UART vendor-spcific request on the default control pipe
2222 * If successful sets baud rate divisor and LCR value
2223 ****************************************************************************/
2224 static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
2225 unsigned short default_divisor, unsigned char default_LCR)
2228 unsigned short UartNumandLCR;
2230 UartNumandLCR = (default_LCR << 8) + Uart_Number;
2233 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2234 QT_GET_SET_UART, 0x40, default_divisor,
2235 UartNumandLCR, NULL, 0, 300);
2240 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int UartNumber,
2244 __u8 MSR_Value = 0, MOUT_Value = 0;
2245 struct usb_serial_port *port;
2246 unsigned int status;
2248 port = serial->port;
2251 /* flow control, box will clear RTS line to prevent remote */
2252 MCR_Value = SERIAL_MCR_RTS;
2253 } /* device from xmitting more chars */
2255 /* no flow control to remote device */
2259 MOUT_Value = MCR_Value << 8;
2262 /* flow control, box will inhibit xmit data if CTS line is
2264 MSR_Value = SERIAL_MSR_CTS;
2266 /* Box will not inhimbe xmit data due to CTS line */
2269 MOUT_Value |= MSR_Value;
2272 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2273 QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
2274 UartNumber, NULL, 0, 300);
2279 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber,
2280 unsigned char stop_char, unsigned char start_char)
2285 nSWflowout = start_char << 8;
2286 nSWflowout = (unsigned short)stop_char;
2289 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2290 QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
2291 UartNumber, NULL, 0, 300);
2295 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 UartNumber)
2300 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2301 QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber,
2307 static void serial_throttle(struct tty_struct *tty)
2309 struct usb_serial_port *port =
2310 (struct usb_serial_port *)tty->driver_data;
2311 struct usb_serial *serial = get_usb_serial(port, __func__);
2312 mydbg("%s - port %d\n", __func__, port->number);
2319 if (!port->open_count) {
2320 mydbg("%s - port not open\n", __func__);
2323 /* shut down any bulk reads that may be going on */
2324 /* usb_unlink_urb (port->read_urb); */
2325 /* pass on to the driver specific version of this function */
2326 port->RxHolding = 1;
2327 mydbg("%s - port->RxHolding = 1\n", __func__);
2334 static void serial_unthrottle(struct tty_struct *tty)
2336 struct usb_serial_port *port =
2337 (struct usb_serial_port *)tty->driver_data;
2338 struct usb_serial *serial = get_usb_serial(port, __func__);
2339 unsigned int result;
2345 mydbg("%s - port %d\n", __func__, port->number);
2347 if (!port->open_count) {
2348 mydbg("%s - port not open\n", __func__);
2352 if (port->RxHolding == 1) {
2353 mydbg("%s -port->RxHolding == 1\n", __func__);
2355 port->RxHolding = 0;
2356 mydbg("%s - port->RxHolding = 0\n", __func__);
2358 /* if we have a bulk endpoint, start it up */
2359 if ((serial->num_bulk_in) && (port->ReadBulkStopped == 1)) {
2360 /* Start reading from the device */
2361 usb_fill_bulk_urb(port->read_urb, serial->dev,
2362 usb_rcvbulkpipe(serial->dev,
2364 bulk_in_endpointAddress),
2365 port->read_urb->transfer_buffer,
2367 transfer_buffer_length,
2368 qt_read_bulk_callback, port);
2369 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
2371 err("%s - failed restarting read urb, error %d",
2381 static int serial_break(struct tty_struct *tty, int break_state)
2383 struct usb_serial_port *port =
2384 (struct usb_serial_port *)tty->driver_data;
2385 struct usb_serial *serial = get_usb_serial(port, __func__);
2386 __u16 UartNumber, Break_Value;
2387 unsigned int result;
2389 UartNumber = port->tty->index - serial->minor;
2393 if (break_state == -1)
2400 mydbg("%s - port %d\n", __func__, port->number);
2402 if (!port->open_count) {
2403 mydbg("%s - port not open\n", __func__);
2408 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2409 QT_BREAK_CONTROL, 0x40, Break_Value, UartNumber,
2417 static int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
2422 unsigned ucOPR_NewValue, uc_Value;
2423 int *p_Num_of_adapters, counts, index, *p_QMCR_Value;
2424 struct identity *p_Identity_of;
2425 struct identity Identity_of;
2426 struct usb_serial *lastserial, *serial;
2428 mydbg(KERN_DEBUG "ioctl_serial_usb cmd =\n");
2429 if (_IOC_TYPE(cmd) != SERIALQT_PCI_IOC_MAGIC)
2431 if (_IOC_NR(cmd) > SERIALQT_IOC_MAXNR)
2433 mydbg(KERN_DEBUG "ioctl_serial_usb cmd = 0x%x\n", cmd);
2437 case SERIALQT_WRITE_QMCR:
2442 ucOPR_NewValue = arg;
2444 err = EmulateWriteQMCR_Reg(index, ucOPR_NewValue);
2447 case SERIALQT_READ_QMCR:
2449 p_QMCR_Value = (int *)arg;
2453 err = EmulateReadQMCR_Reg(index, &uc_Value);
2455 err = put_user(uc_Value, p_QMCR_Value);
2458 case SERIALQT_GET_NUMOF_UNITS:
2459 p_Num_of_adapters = (int *)arg;
2460 counts = 0; /* Initialize counts to zero */
2461 /* struct usb_serial *lastserial = serial_table[0], *serial; */
2462 lastserial = serial_table[0];
2464 mydbg(KERN_DEBUG "SERIALQT_GET_NUMOF_UNITS \n");
2465 /* if first pointer is nonull, we at least have one box */
2467 counts = 1; /* we at least have one box */
2469 for (index = 1; index < SERIAL_TTY_MINORS; index++) {
2470 serial = serial_table[index];
2472 if (serial != lastserial) {
2473 /* we had a change in the array, hence
2474 * another box is there */
2475 lastserial = serial;
2482 mydbg(KERN_DEBUG "ioctl_serial_usb writting counts = %d",
2485 err = put_user(counts, p_Num_of_adapters);
2488 case SERIALQT_GET_THIS_UNIT:
2490 p_Identity_of = (struct identity *)arg;
2491 /* copy user structure to local variable */
2492 get_user(Identity_of.index, &p_Identity_of->index);
2493 mydbg(KERN_DEBUG "SERIALQT_GET_THIS_UNIT Identity_of.index\n");
2495 "SERIALQT_GET_THIS_UNIT Identity_of.index= 0x%x\n",
2499 serial = find_the_box(Identity_of.index);
2502 put_user(serial->product,
2503 &p_Identity_of->n_identity);
2508 case SERIALQT_IS422_EXTENDED:
2510 mydbg(KERN_DEBUG "SERIALQT_IS422_EXTENDED \n");
2516 "SERIALQT_IS422_EXTENDED, looking Identity_of.indext = 0x%x\n",
2518 serial = find_the_box(index);
2520 mydbg("%s index = 0x%x, serial = 0x%p\n", __func__,
2522 for (counts = 0; serqt_422_table[counts] != 0; counts++) {
2525 ("%s serial->product = = 0x%x, serqt_422_table[counts] = 0x%x\n",
2526 __func__, serial->product,
2527 serqt_422_table[counts]);
2528 if (serial->product == serqt_422_table[counts]) {
2532 ("%s found match for 422extended\n",
2544 mydbg("%s returning err = 0x%x\n", __func__, err);
2548 static struct usb_serial *find_the_box(unsigned int index)
2550 struct usb_serial *lastserial, *foundserial, *serial;
2551 int counts = 0, index2;
2552 lastserial = serial_table[0];
2554 for (index2 = 0; index2 < SERIAL_TTY_MINORS; index2++) {
2555 serial = serial_table[index2];
2557 mydbg("%s index = 0x%x, index2 = 0x%x, serial = 0x%p\n",
2558 __func__, index, index2, serial);
2561 /* first see if this is the unit we'er looking for */
2563 ("%s inside if(serial) counts = 0x%x , index = 0x%x\n",
2564 __func__, counts, index);
2565 if (counts == index) {
2566 /* we found the one we're looking for, copythe
2567 * product Id to user */
2568 mydbg("%s we found the one we're looking for serial = 0x%p\n",
2570 foundserial = serial;
2574 if (serial != lastserial) {
2575 /* when we have a change in the pointer */
2576 lastserial = serial;
2580 break; /* no matches */
2583 mydbg("%s returning foundserial = 0x%p\n", __func__, foundserial);
2587 static int EmulateWriteQMCR_Reg(int index, unsigned uc_value)
2591 struct usb_serial *serial;
2593 struct qt_get_device_data DeviceData;
2594 unsigned uc_temp = 0;
2595 mydbg("Inside %s, uc_value = 0x%x\n", __func__, uc_value);
2597 DeviceData.porta = 0;
2598 DeviceData.portb = 0;
2599 serial = find_the_box(index);
2600 /* Determine Duplex mode */
2603 status = box_get_device(serial, &DeviceData);
2605 mydbg(__FILE__ "box_set_device failed\n");
2609 uc_temp = uc_value & QMCR_HALF_DUPLEX_MASK;
2611 case QMCR_FULL_DUPLEX:
2612 DeviceData.porta &= ~DUPMODE_BITS;
2613 DeviceData.porta |= FULL_DUPLEX;
2614 ATC_Mode = ATC_DISABLED;
2616 case QMCR_HALF_DUPLEX_RTS:
2617 DeviceData.porta &= ~DUPMODE_BITS;
2618 DeviceData.porta |= HALF_DUPLEX_RTS;
2619 ATC_Mode = ATC_RTS_ENABLED;
2621 case QMCR_HALF_DUPLEX_DTR:
2622 DeviceData.porta &= ~DUPMODE_BITS;
2623 DeviceData.porta |= HALF_DUPLEX_DTR;
2624 ATC_Mode = ATC_DTR_ENABLED;
2630 uc_temp = uc_value & QMCR_CONNECTOR_MASK;
2632 case QMCR_MODEM_CONTROL:
2633 DeviceData.portb &= ~LOOPMODE_BITS; /* reset connection bits */
2634 DeviceData.portb |= MODEM_CTRL;
2636 case QMCR_ALL_LOOPBACK:
2637 DeviceData.portb &= ~LOOPMODE_BITS; /* reset connection bits */
2638 DeviceData.portb |= ALL_LOOPBACK;
2642 mydbg(__FILE__ "Calling box_set_device with failed\n");
2643 status = box_set_device(serial, &DeviceData);
2645 mydbg(__FILE__ "box_set_device failed\n");
2649 /* This bit (otherwise unused) i'll used to detect whether ATC is
2651 if (uc_value & QMCR_RX_EN_MASK) {
2654 "calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
2655 DeviceData.porta, DeviceData.portb);
2656 status = BoxSetATC(serial, ATC_Mode);
2658 mydbg(__FILE__ "BoxSetATC failed\n");
2664 "calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
2665 DeviceData.porta, DeviceData.portb);
2666 status = BoxSetATC(serial, ATC_DISABLED);
2668 mydbg(__FILE__ "BoxSetATC failed\n");
2677 static int EmulateReadQMCR_Reg(int index, unsigned *uc_value)
2679 struct usb_serial *serial;
2681 struct qt_get_device_data DeviceData;
2686 serial = find_the_box(index);
2690 status = box_get_device(serial, &DeviceData);
2692 mydbg(__FILE__ "box_get_device failed\n");
2695 uc_temp = DeviceData.porta & DUPMODE_BITS;
2698 *uc_value |= QMCR_FULL_DUPLEX;
2700 case HALF_DUPLEX_RTS:
2701 *uc_value |= QMCR_HALF_DUPLEX_RTS;
2703 case HALF_DUPLEX_DTR:
2704 *uc_value |= QMCR_HALF_DUPLEX_DTR;
2710 /* I use this for ATC control se */
2711 uc_temp = DeviceData.portb & LOOPMODE_BITS;
2715 *uc_value |= QMCR_ALL_LOOPBACK;
2718 *uc_value |= QMCR_MODEM_CONTROL;
2728 static int __init serqt_usb_init(void)
2733 mydbg("%s\n", __func__);
2734 tty_set_operations(&serial_tty_driver, &serial_ops);
2735 result = tty_register_driver(&serial_tty_driver);
2737 mydbg("tty_register_driver failed error = 0x%x", result);
2741 /* Initalize our global data */
2742 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
2743 serial_table[i] = NULL;
2745 /* register this driver with the USB subsystem */
2746 result = usb_register(&serqt_usb_driver);
2748 err("usb_register failed for the " __FILE__
2749 " driver. Error number %d", result);
2752 status = 0; /* Dynamic assignment of major number */
2754 register_chrdev(status, "SerialQT_USB", &serialqt_usb_fops);
2755 if (major_number < 0) {
2756 mydbg(KERN_DEBUG "No devices found \n\n");
2759 mydbg(KERN_DEBUG "SerQT_USB major number assignment = %d \n\n",
2762 printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION);
2766 static void __exit serqt_usb_exit(void)
2768 /* deregister this driver with the USB subsystem */
2769 usb_deregister(&serqt_usb_driver);
2770 tty_unregister_driver(&serial_tty_driver);
2771 unregister_chrdev(major_number, "SerialQT_USB");
2774 module_init(serqt_usb_init);
2775 module_exit(serqt_usb_exit);
2777 MODULE_AUTHOR(DRIVER_AUTHOR);
2778 MODULE_DESCRIPTION(DRIVER_DESC);
2779 MODULE_LICENSE("GPL");