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