projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'usb-3.6' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / serqt_usb2 / serqt_usb2.c
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/errno.h>
8 #include <linux/init.h>
9 #include <linux/slab.h>
10 #include <linux/tty.h>
11 #include <linux/tty_driver.h>
12 #include <linux/tty_flip.h>
13 #include <linux/module.h>
14 #include <linux/serial.h>
15 #include <linux/usb.h>
16 #include <linux/usb/serial.h>
17 #include <linux/uaccess.h>
18
19 /* Version Information */
20 #define DRIVER_VERSION "v2.14"
21 #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
22 #define DRIVER_DESC "Quatech USB to Serial Driver"
23
24 #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
25 #define QUATECH_SSU200 0xC030 /* SSU200 */
26 #define QUATECH_DSU100 0xC040 /* DSU100 */
27 #define QUATECH_DSU200 0xC050 /* DSU200 */
28 #define QUATECH_QSU100 0xC060 /* QSU100 */
29 #define QUATECH_QSU200 0xC070 /* QSU200 */
30 #define QUATECH_ESU100A 0xC080 /* ESU100A */
31 #define QUATECH_ESU100B 0xC081 /* ESU100B */
32 #define QUATECH_ESU200A 0xC0A0 /* ESU200A */
33 #define QUATECH_ESU200B 0xC0A1 /* ESU200B */
34 #define QUATECH_HSU100A 0xC090 /* HSU100A */
35 #define QUATECH_HSU100B 0xC091 /* HSU100B */
36 #define QUATECH_HSU100C 0xC092 /* HSU100C */
37 #define QUATECH_HSU100D 0xC093 /* HSU100D */
38 #define QUATECH_HSU200A 0xC0B0 /* HSU200A */
39 #define QUATECH_HSU200B 0xC0B1 /* HSU200B */
40 #define QUATECH_HSU200C 0xC0B2 /* HSU200C */
41 #define QUATECH_HSU200D 0xC0B3 /* HSU200D */
42
43 #define QT_SET_GET_DEVICE 0xc2
44 #define QT_OPEN_CLOSE_CHANNEL 0xca
45 #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
46 #define QT_SET_ATF 0xcd
47 #define QT_GET_SET_REGISTER 0xc0
48 #define QT_GET_SET_UART 0xc1
49 #define QT_HW_FLOW_CONTROL_MASK 0xc5
50 #define QT_SW_FLOW_CONTROL_MASK 0xc6
51 #define QT_SW_FLOW_CONTROL_DISABLE 0xc7
52 #define QT_BREAK_CONTROL 0xc8
53
54 #define USBD_TRANSFER_DIRECTION_IN 0xc0
55 #define USBD_TRANSFER_DIRECTION_OUT 0x40
56
57 #define MAX_BAUD_RATE 460800
58 #define MAX_BAUD_REMAINDER 4608
59
60 #define DIV_LATCH_LS 0x00
61 #define XMT_HOLD_REGISTER 0x00
62 #define XVR_BUFFER_REGISTER 0x00
63 #define DIV_LATCH_MS 0x01
64 #define FIFO_CONTROL_REGISTER 0x02
65 #define LINE_CONTROL_REGISTER 0x03
66 #define MODEM_CONTROL_REGISTER 0x04
67 #define LINE_STATUS_REGISTER 0x05
68 #define MODEM_STATUS_REGISTER 0x06
69
70 #define SERIAL_MCR_DTR 0x01
71 #define SERIAL_MCR_RTS 0x02
72 #define SERIAL_MCR_LOOP 0x10
73
74 #define SERIAL_MSR_CTS 0x10
75 #define SERIAL_MSR_CD 0x80
76 #define SERIAL_MSR_RI 0x40
77 #define SERIAL_MSR_DSR 0x20
78 #define SERIAL_MSR_MASK 0xf0
79
80 #define SERIAL_8_DATA 0x03
81 #define SERIAL_7_DATA 0x02
82 #define SERIAL_6_DATA 0x01
83 #define SERIAL_5_DATA 0x00
84
85 #define SERIAL_ODD_PARITY 0X08
86 #define SERIAL_EVEN_PARITY 0X18
87 #define SERIAL_TWO_STOPB 0x04
88 #define SERIAL_ONE_STOPB 0x00
89
90 #define DEFAULT_DIVISOR 0x30 /* gives 9600 baud rate */
91 #define DEFAULT_LCR SERIAL_8_DATA /* 8, none , 1 */
92
93 #define FULLPWRBIT 0x00000080
94 #define NEXT_BOARD_POWER_BIT 0x00000004
95
96 #define SERIAL_LSR_OE 0x02
97 #define SERIAL_LSR_PE 0x04
98 #define SERIAL_LSR_FE 0x08
99 #define SERIAL_LSR_BI 0x10
100
101 #define SERIAL_MSR_CTS 0x10
102 #define SERIAL_MSR_CD 0x80
103 #define SERIAL_MSR_RI 0x40
104 #define SERIAL_MSR_DSR 0x20
105 #define SERIAL_MSR_MASK 0xf0
106
107 #define PREFUFF_LEVEL_CONSERVATIVE 128
108 #define ATC_DISABLED 0x0
109
110 #define RR_BITS 0x03 /* for clearing clock bits */
111 #define DUPMODE_BITS 0xc0
112 #define CLKS_X4 0x02
113
114 #define LOOPMODE_BITS 0x41 /* LOOP1 = b6, LOOP0 = b0 (PORT B) */
115 #define ALL_LOOPBACK 0x01
116 #define MODEM_CTRL 0x40
117 #define RS232_MODE 0x00
118
119 static const struct usb_device_id id_table[] = {
120 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU200)},
121 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100)},
122 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU200)},
123 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100)},
124 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU200)},
125 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100A)},
126 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100B)},
127 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200A)},
128 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200B)},
129 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100A)},
130 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100B)},
131 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100C)},
132 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100D)},
133 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200A)},
134 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200B)},
135 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200C)},
136 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200D)},
137 {} /* Terminating entry */
138 };
139 MODULE_DEVICE_TABLE(usb, id_table);
140
141 struct qt_get_device_data {
142 __u8 porta;
143 __u8 portb;
144 __u8 portc;
145 };
146
147 struct qt_open_channel_data {
148 __u8 line_status;
149 __u8 modem_status;
150 };
151
152 struct quatech_port {
153 int port_num; /* number of the port */
154 struct urb *write_urb; /* write URB for this port */
155 struct urb *read_urb; /* read URB for this port */
156 struct urb *int_urb;
157
158 __u8 shadowLCR; /* last LCR value received */
159 __u8 shadowMCR; /* last MCR value received */
160 __u8 shadowMSR; /* last MSR value received */
161 __u8 shadowLSR; /* last LSR value received */
162 char open_ports;
163
164 /* Used for TIOCMIWAIT */
165 wait_queue_head_t msr_wait;
166 char prev_status, diff_status;
167
168 wait_queue_head_t wait;
169
170 struct async_icount icount;
171
172 struct usb_serial_port *port; /* owner of this object */
173 struct qt_get_device_data DeviceData;
174 struct mutex lock;
175 bool read_urb_busy;
176 int RxHolding;
177 int ReadBulkStopped;
178 char closePending;
179 };
180
181 static int port_paranoia_check(struct usb_serial_port *port,
182 const char *function)
183 {
184 if (!port) {
185 pr_debug("%s - port == NULL", function);
186 return -1;
187 }
188 if (!port->serial) {
189 pr_debug("%s - port->serial == NULL\n", function);
190 return -1;
191 }
192
193 return 0;
194 }
195
196 static int serial_paranoia_check(struct usb_serial *serial,
197 const char *function)
198 {
199 if (!serial) {
200 pr_debug("%s - serial == NULL\n", function);
201 return -1;
202 }
203
204 if (!serial->type) {
205 pr_debug("%s - serial->type == NULL!", function);
206 return -1;
207 }
208
209 return 0;
210 }
211
212 static inline struct quatech_port *qt_get_port_private(struct usb_serial_port
213 *port)
214 {
215 return (struct quatech_port *)usb_get_serial_port_data(port);
216 }
217
218 static inline void qt_set_port_private(struct usb_serial_port *port,
219 struct quatech_port *data)
220 {
221 usb_set_serial_port_data(port, (void *)data);
222 }
223
224 static struct usb_serial *get_usb_serial(struct usb_serial_port *port,
225 const char *function)
226 {
227 /* if no port was specified, or it fails a paranoia check */
228 if (!port ||
229 port_paranoia_check(port, function) ||
230 serial_paranoia_check(port->serial, function)) {
231 /*
232 * then say that we dont have a valid usb_serial thing,
233 * which will end up genrating -ENODEV return values
234 */
235 return NULL;
236 }
237
238 return port->serial;
239 }
240
241 static void ProcessLineStatus(struct quatech_port *qt_port,
242 unsigned char line_status)
243 {
244
245 qt_port->shadowLSR =
246 line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
247 SERIAL_LSR_BI);
248 }
249
250 static void ProcessModemStatus(struct quatech_port *qt_port,
251 unsigned char modem_status)
252 {
253
254 qt_port->shadowMSR = modem_status;
255 wake_up_interruptible(&qt_port->wait);
256 }
257
258 static void ProcessRxChar(struct tty_struct *tty, struct usb_serial_port *port,
259 unsigned char data)
260 {
261 struct urb *urb = port->read_urb;
262 if (urb->actual_length)
263 tty_insert_flip_char(tty, data, TTY_NORMAL);
264 }
265
266 static void qt_write_bulk_callback(struct urb *urb)
267 {
268 struct tty_struct *tty;
269 int status;
270 struct quatech_port *quatech_port;
271
272 status = urb->status;
273
274 if (status) {
275 dev_dbg(&urb->dev->dev, "nonzero write bulk status received:%d\n", status);
276 return;
277 }
278
279 quatech_port = urb->context;
280
281 tty = tty_port_tty_get(&quatech_port->port->port);
282
283 if (tty)
284 tty_wakeup(tty);
285 tty_kref_put(tty);
286 }
287
288 static void qt_interrupt_callback(struct urb *urb)
289 {
290 /* FIXME */
291 }
292
293 static void qt_read_bulk_callback(struct urb *urb)
294 {
295
296 struct usb_serial_port *port = urb->context;
297 struct usb_serial *serial = get_usb_serial(port, __func__);
298 struct quatech_port *qt_port = qt_get_port_private(port);
299 unsigned char *data;
300 struct tty_struct *tty;
301 unsigned int index;
302 unsigned int RxCount;
303 int i, result;
304 int flag, flag_data;
305
306 if (urb->status) {
307 qt_port->ReadBulkStopped = 1;
308 dev_dbg(&urb->dev->dev, "%s - nonzero write bulk status received: %d\n",
309 __func__, urb->status);
310 return;
311 }
312
313 tty = tty_port_tty_get(&port->port);
314 if (!tty)
315 return;
316
317 data = urb->transfer_buffer;
318
319 RxCount = urb->actual_length;
320
321 /* index = MINOR(port->tty->device) - serial->minor; */
322 index = tty->index - serial->minor;
323
324 dev_dbg(&port->dev, "%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding);
325
326 if (port_paranoia_check(port, __func__) != 0) {
327 qt_port->ReadBulkStopped = 1;
328 goto exit;
329 }
330
331 if (!serial)
332 goto exit;
333
334 if (qt_port->closePending == 1) {
335 /* Were closing , stop reading */
336 dev_dbg(&port->dev, "%s - (qt_port->closepending == 1\n", __func__);
337 qt_port->ReadBulkStopped = 1;
338 goto exit;
339 }
340
341 /*
342 * RxHolding is asserted by throttle, if we assert it, we're not
343 * receiving any more characters and let the box handle the flow
344 * control
345 */
346 if (qt_port->RxHolding == 1) {
347 qt_port->ReadBulkStopped = 1;
348 goto exit;
349 }
350
351 if (urb->status) {
352 qt_port->ReadBulkStopped = 1;
353
354 dev_dbg(&port->dev, "%s - nonzero read bulk status received: %d\n",
355 __func__, urb->status);
356 goto exit;
357 }
358
359 if (RxCount) {
360 flag_data = 0;
361 for (i = 0; i < RxCount; ++i) {
362 /* Look ahead code here */
363 if ((i <= (RxCount - 3)) && (data[i] == 0x1b)
364 && (data[i + 1] == 0x1b)) {
365 flag = 0;
366 switch (data[i + 2]) {
367 case 0x00:
368 /* line status change 4th byte must follow */
369 if (i > (RxCount - 4)) {
370 dev_dbg(&port->dev, "Illegal escape seuences in received data\n");
371 break;
372 }
373 ProcessLineStatus(qt_port, data[i + 3]);
374 i += 3;
375 flag = 1;
376 break;
377
378 case 0x01:
379 /* Modem status status change 4th byte must follow */
380 dev_dbg(&port->dev, "Modem status status.\n");
381 if (i > (RxCount - 4)) {
382 dev_dbg(&port->dev, "Illegal escape sequences in received data\n");
383 break;
384 }
385 ProcessModemStatus(qt_port,
386 data[i + 3]);
387 i += 3;
388 flag = 1;
389 break;
390 case 0xff:
391 dev_dbg(&port->dev, "No status sequence.\n");
392
393 if (tty) {
394 ProcessRxChar(tty, port, data[i]);
395 ProcessRxChar(tty, port, data[i + 1]);
396 }
397 i += 2;
398 break;
399 }
400 if (flag == 1)
401 continue;
402 }
403
404 if (tty && urb->actual_length)
405 tty_insert_flip_char(tty, data[i], TTY_NORMAL);
406
407 }
408 tty_flip_buffer_push(tty);
409 }
410
411 /* Continue trying to always read */
412 usb_fill_bulk_urb(port->read_urb, serial->dev,
413 usb_rcvbulkpipe(serial->dev,
414 port->bulk_in_endpointAddress),
415 port->read_urb->transfer_buffer,
416 port->read_urb->transfer_buffer_length,
417 qt_read_bulk_callback, port);
418 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
419 if (result)
420 dev_dbg(&port->dev, "%s - failed resubmitting read urb, error %d",
421 __func__, result);
422 else {
423 if (RxCount) {
424 tty_flip_buffer_push(tty);
425 tty_schedule_flip(tty);
426 }
427 }
428
429 schedule_work(&port->work);
430 exit:
431 tty_kref_put(tty);
432 }
433
434 /*
435 * qt_get_device
436 * Issue a GET_DEVICE vendor-specific request on the default control pipe If
437 * successful, fills in the qt_get_device_data structure pointed to by
438 * device_data, otherwise return a negative error number of the problem.
439 */
440
441 static int qt_get_device(struct usb_serial *serial,
442 struct qt_get_device_data *device_data)
443 {
444 int result;
445 unsigned char *transfer_buffer;
446
447 transfer_buffer =
448 kmalloc(sizeof(struct qt_get_device_data), GFP_KERNEL);
449 if (!transfer_buffer)
450 return -ENOMEM;
451
452 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
453 QT_SET_GET_DEVICE, 0xc0, 0, 0,
454 transfer_buffer,
455 sizeof(struct qt_get_device_data), 300);
456 if (result > 0)
457 memcpy(device_data, transfer_buffer,
458 sizeof(struct qt_get_device_data));
459 kfree(transfer_buffer);
460
461 return result;
462 }
463
464 /****************************************************************************
465 * BoxSetPrebufferLevel
466 TELLS BOX WHEN TO ASSERT FLOW CONTROL
467 ****************************************************************************/
468 static int BoxSetPrebufferLevel(struct usb_serial *serial)
469 {
470 int result;
471 __u16 buffer_length;
472
473 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
474 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
475 QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
476 buffer_length, 0, NULL, 0, 300);
477 return result;
478 }
479
480 /****************************************************************************
481 * BoxSetATC
482 TELLS BOX WHEN TO ASSERT automatic transmitter control
483 ****************************************************************************/
484 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
485 {
486 int result;
487 __u16 buffer_length;
488
489 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
490
491 result =
492 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
493 QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
494
495 return result;
496 }
497
498 /**
499 * qt_set_device
500 * Issue a SET_DEVICE vendor-specific request on the default control pipe If
501 * successful returns the number of bytes written, otherwise it returns a
502 * negative error number of the problem.
503 */
504 static int qt_set_device(struct usb_serial *serial,
505 struct qt_get_device_data *device_data)
506 {
507 int result;
508 __u16 length;
509 __u16 PortSettings;
510
511 PortSettings = ((__u16) (device_data->portb));
512 PortSettings = (PortSettings << 8);
513 PortSettings += ((__u16) (device_data->porta));
514
515 length = sizeof(struct qt_get_device_data);
516
517 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
518 QT_SET_GET_DEVICE, 0x40, PortSettings,
519 0, NULL, 0, 300);
520 return result;
521 }
522
523 static int qt_open_channel(struct usb_serial *serial, __u16 Uart_Number,
524 struct qt_open_channel_data *pDeviceData)
525 {
526 int result;
527
528 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
529 QT_OPEN_CLOSE_CHANNEL,
530 USBD_TRANSFER_DIRECTION_IN, 1, Uart_Number,
531 pDeviceData,
532 sizeof(struct qt_open_channel_data), 300);
533
534 return result;
535
536 }
537
538 static int qt_close_channel(struct usb_serial *serial, __u16 Uart_Number)
539 {
540 int result;
541
542 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
543 QT_OPEN_CLOSE_CHANNEL,
544 USBD_TRANSFER_DIRECTION_OUT, 0, Uart_Number,
545 NULL, 0, 300);
546
547 return result;
548
549 }
550
551 /****************************************************************************
552 * BoxGetRegister
553 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
554 * If successful, fills in the pValue with the register value asked for
555 ****************************************************************************/
556 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
557 unsigned short Register_Num, __u8 *pValue)
558 {
559 int result;
560 __u16 current_length;
561
562 current_length = sizeof(struct qt_get_device_data);
563
564 result =
565 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
566 QT_GET_SET_REGISTER, 0xC0, Register_Num,
567 Uart_Number, (void *)pValue, sizeof(*pValue), 300);
568
569 return result;
570 }
571
572 /****************************************************************************
573 * BoxSetRegister
574 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
575 * If successful, fills in the pValue with the register value asked for
576 ****************************************************************************/
577 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
578 unsigned short Register_Num, unsigned short Value)
579 {
580 int result;
581 unsigned short RegAndByte;
582
583 RegAndByte = Value;
584 RegAndByte = RegAndByte << 8;
585 RegAndByte = RegAndByte + Register_Num;
586
587 /*
588 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
589 QT_GET_SET_REGISTER, 0xC0, Register_Num,
590 Uart_Number, NULL, 0, 300);
591 */
592
593 result =
594 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
595 QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number,
596 NULL, 0, 300);
597
598 return result;
599 }
600
601 /*
602 * qt_setuart
603 * issues a SET_UART vendor-specific request on the default control pipe
604 * If successful sets baud rate divisor and LCR value
605 */
606 static int qt_setuart(struct usb_serial *serial, unsigned short Uart_Number,
607 unsigned short default_divisor, unsigned char default_LCR)
608 {
609 int result;
610 unsigned short UartNumandLCR;
611
612 UartNumandLCR = (default_LCR << 8) + Uart_Number;
613
614 result =
615 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
616 QT_GET_SET_UART, 0x40, default_divisor,
617 UartNumandLCR, NULL, 0, 300);
618
619 return result;
620 }
621
622 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
623 int bSet)
624 {
625 __u8 mcr = 0;
626 __u8 msr = 0, MOUT_Value = 0;
627 unsigned int status;
628
629 if (bSet == 1) {
630 /* flow control, box will clear RTS line to prevent remote */
631 mcr = SERIAL_MCR_RTS;
632 } /* device from xmitting more chars */
633 else {
634 /* no flow control to remote device */
635 mcr = 0;
636
637 }
638 MOUT_Value = mcr << 8;
639
640 if (bSet == 1) {
641 /* flow control, box will inhibit xmit data if CTS line is
642 * asserted */
643 msr = SERIAL_MSR_CTS;
644 } else {
645 /* Box will not inhimbe xmit data due to CTS line */
646 msr = 0;
647 }
648 MOUT_Value |= msr;
649
650 status =
651 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
652 QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
653 index, NULL, 0, 300);
654 return status;
655
656 }
657
658 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 index,
659 unsigned char stop_char, unsigned char start_char)
660 {
661 __u16 nSWflowout;
662 int result;
663
664 nSWflowout = start_char << 8;
665 nSWflowout = (unsigned short)stop_char;
666
667 result =
668 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
669 QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
670 index, NULL, 0, 300);
671 return result;
672
673 }
674
675 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index)
676 {
677 int result;
678
679 result =
680 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
681 QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index,
682 NULL, 0, 300);
683 return result;
684
685 }
686
687 static int qt_startup(struct usb_serial *serial)
688 {
689 struct device *dev = &serial->dev->dev;
690 struct usb_serial_port *port;
691 struct quatech_port *qt_port;
692 struct qt_get_device_data DeviceData;
693 int i;
694 int status;
695
696 /* Now setup per port private data */
697 for (i = 0; i < serial->num_ports; i++) {
698 port = serial->port[i];
699 qt_port = kzalloc(sizeof(*qt_port), GFP_KERNEL);
700 if (!qt_port) {
701 for (--i; i >= 0; i--) {
702 port = serial->port[i];
703 kfree(usb_get_serial_port_data(port));
704 usb_set_serial_port_data(port, NULL);
705 }
706 return -ENOMEM;
707 }
708 mutex_init(&qt_port->lock);
709
710 usb_set_serial_port_data(port, qt_port);
711
712 }
713
714 status = qt_get_device(serial, &DeviceData);
715 if (status < 0)
716 goto startup_error;
717
718 dev_dbg(dev, "DeviceData.portb = 0x%x\n", DeviceData.portb);
719
720 DeviceData.portb &= ~FULLPWRBIT;
721 dev_dbg(dev, "Changing DeviceData.portb to 0x%x\n", DeviceData.portb);
722
723 status = qt_set_device(serial, &DeviceData);
724 if (status < 0) {
725 dev_dbg(dev, "qt_set_device failed\n");
726 goto startup_error;
727 }
728
729 status = qt_get_device(serial, &DeviceData);
730 if (status < 0) {
731 dev_dbg(dev, "qt_get_device failed\n");
732 goto startup_error;
733 }
734
735 switch (serial->dev->descriptor.idProduct) {
736 case QUATECH_DSU100:
737 case QUATECH_QSU100:
738 case QUATECH_ESU100A:
739 case QUATECH_ESU100B:
740 case QUATECH_HSU100A:
741 case QUATECH_HSU100B:
742 case QUATECH_HSU100C:
743 case QUATECH_HSU100D:
744 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
745 DeviceData.porta |= CLKS_X4;
746 DeviceData.portb &= ~(LOOPMODE_BITS);
747 DeviceData.portb |= RS232_MODE;
748 break;
749
750 case QUATECH_SSU200:
751 case QUATECH_DSU200:
752 case QUATECH_QSU200:
753 case QUATECH_ESU200A:
754 case QUATECH_ESU200B:
755 case QUATECH_HSU200A:
756 case QUATECH_HSU200B:
757 case QUATECH_HSU200C:
758 case QUATECH_HSU200D:
759 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
760 DeviceData.porta |= CLKS_X4;
761 DeviceData.portb &= ~(LOOPMODE_BITS);
762 DeviceData.portb |= ALL_LOOPBACK;
763 break;
764 default:
765 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
766 DeviceData.porta |= CLKS_X4;
767 DeviceData.portb &= ~(LOOPMODE_BITS);
768 DeviceData.portb |= RS232_MODE;
769 break;
770
771 }
772
773 status = BoxSetPrebufferLevel(serial); /* sets to default value */
774 if (status < 0) {
775 dev_dbg(dev, "BoxSetPrebufferLevel failed\n");
776 goto startup_error;
777 }
778
779 status = BoxSetATC(serial, ATC_DISABLED);
780 if (status < 0) {
781 dev_dbg(dev, "BoxSetATC failed\n");
782 goto startup_error;
783 }
784
785 dev_dbg(dev, "DeviceData.portb = 0x%x\n", DeviceData.portb);
786
787 DeviceData.portb |= NEXT_BOARD_POWER_BIT;
788 dev_dbg(dev, "Changing DeviceData.portb to 0x%x\n", DeviceData.portb);
789
790 status = qt_set_device(serial, &DeviceData);
791 if (status < 0) {
792 dev_dbg(dev, "qt_set_device failed\n");
793 goto startup_error;
794 }
795
796 return 0;
797
798 startup_error:
799 for (i = 0; i < serial->num_ports; i++) {
800 port = serial->port[i];
801 qt_port = qt_get_port_private(port);
802 kfree(qt_port);
803 usb_set_serial_port_data(port, NULL);
804 }
805
806 return -EIO;
807 }
808
809 static void qt_release(struct usb_serial *serial)
810 {
811 struct usb_serial_port *port;
812 struct quatech_port *qt_port;
813 int i;
814
815 for (i = 0; i < serial->num_ports; i++) {
816 port = serial->port[i];
817 if (!port)
818 continue;
819
820 qt_port = usb_get_serial_port_data(port);
821 kfree(qt_port);
822 usb_set_serial_port_data(port, NULL);
823 }
824
825 }
826
827 static int qt_open(struct tty_struct *tty,
828 struct usb_serial_port *port)
829 {
830 struct usb_serial *serial;
831 struct quatech_port *quatech_port;
832 struct quatech_port *port0;
833 struct qt_open_channel_data ChannelData;
834
835 int result;
836
837 if (port_paranoia_check(port, __func__))
838 return -ENODEV;
839
840 serial = port->serial;
841
842 if (serial_paranoia_check(serial, __func__))
843 return -ENODEV;
844
845 quatech_port = qt_get_port_private(port);
846 port0 = qt_get_port_private(serial->port[0]);
847
848 if (quatech_port == NULL || port0 == NULL)
849 return -ENODEV;
850
851 usb_clear_halt(serial->dev, port->write_urb->pipe);
852 usb_clear_halt(serial->dev, port->read_urb->pipe);
853 port0->open_ports++;
854
855 result = qt_get_device(serial, &port0->DeviceData);
856
857 /* Port specific setups */
858 result = qt_open_channel(serial, port->number, &ChannelData);
859 if (result < 0) {
860 dev_dbg(&port->dev, "qt_open_channel failed\n");
861 return result;
862 }
863 dev_dbg(&port->dev, "qt_open_channel completed.\n");
864
865 /* FIXME: are these needed? Does it even do anything useful? */
866 quatech_port->shadowLSR = ChannelData.line_status &
867 (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
868
869 quatech_port->shadowMSR = ChannelData.modem_status &
870 (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
871
872 /* Set Baud rate to default and turn off (default)flow control here */
873 result = qt_setuart(serial, port->number, DEFAULT_DIVISOR, DEFAULT_LCR);
874 if (result < 0) {
875 dev_dbg(&port->dev, "qt_setuart failed\n");
876 return result;
877 }
878 dev_dbg(&port->dev, "qt_setuart completed.\n");
879
880 /*
881 * Put this here to make it responsive to stty and defaults set by
882 * the tty layer
883 */
884
885 /* Check to see if we've set up our endpoint info yet */
886 if (port0->open_ports == 1) {
887 if (serial->port[0]->interrupt_in_buffer == NULL) {
888 /* set up interrupt urb */
889 usb_fill_int_urb(serial->port[0]->interrupt_in_urb,
890 serial->dev,
891 usb_rcvintpipe(serial->dev,
892 serial->port[0]->interrupt_in_endpointAddress),
893 serial->port[0]->interrupt_in_buffer,
894 serial->port[0]->
895 interrupt_in_urb->transfer_buffer_length,
896 qt_interrupt_callback, serial,
897 serial->port[0]->
898 interrupt_in_urb->interval);
899
900 result =
901 usb_submit_urb(serial->port[0]->interrupt_in_urb,
902 GFP_KERNEL);
903 if (result) {
904 dev_err(&port->dev,
905 "%s - Error %d submitting "
906 "interrupt urb\n", __func__, result);
907 }
908
909 }
910
911 }
912
913 dev_dbg(&port->dev, "port number is %d\n", port->number);
914 dev_dbg(&port->dev, "serial number is %d\n", port->serial->minor);
915 dev_dbg(&port->dev, "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
916 dev_dbg(&port->dev, "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
917 dev_dbg(&port->dev, "Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress);
918 dev_dbg(&port->dev, "port's number in the device is %d\n", quatech_port->port_num);
919 quatech_port->read_urb = port->read_urb;
920
921 /* set up our bulk in urb */
922
923 usb_fill_bulk_urb(quatech_port->read_urb,
924 serial->dev,
925 usb_rcvbulkpipe(serial->dev,
926 port->bulk_in_endpointAddress),
927 port->bulk_in_buffer,
928 quatech_port->read_urb->transfer_buffer_length,
929 qt_read_bulk_callback, quatech_port);
930
931 dev_dbg(&port->dev, "qt_open: bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
932 quatech_port->read_urb_busy = true;
933 result = usb_submit_urb(quatech_port->read_urb, GFP_KERNEL);
934 if (result) {
935 dev_err(&port->dev,
936 "%s - Error %d submitting control urb\n",
937 __func__, result);
938 quatech_port->read_urb_busy = false;
939 }
940
941 /* initialize our wait queues */
942 init_waitqueue_head(&quatech_port->wait);
943 init_waitqueue_head(&quatech_port->msr_wait);
944
945 /* initialize our icount structure */
946 memset(&(quatech_port->icount), 0x00, sizeof(quatech_port->icount));
947
948 return 0;
949
950 }
951
952 static int qt_chars_in_buffer(struct tty_struct *tty)
953 {
954 struct usb_serial_port *port = tty->driver_data;
955 struct usb_serial *serial;
956 int chars = 0;
957
958 serial = get_usb_serial(port, __func__);
959
960 if (serial->num_bulk_out) {
961 if (port->write_urb->status == -EINPROGRESS)
962 chars = port->write_urb->transfer_buffer_length;
963 }
964
965 return chars;
966 }
967
968 static void qt_block_until_empty(struct tty_struct *tty,
969 struct quatech_port *qt_port)
970 {
971 int timeout = HZ / 10;
972 int wait = 30;
973 int count;
974
975 while (1) {
976
977 count = qt_chars_in_buffer(tty);
978
979 if (count <= 0)
980 return;
981
982 interruptible_sleep_on_timeout(&qt_port->wait, timeout);
983
984 wait--;
985 if (wait == 0) {
986 dev_dbg(&qt_port->port->dev, "%s - TIMEOUT", __func__);
987 return;
988 } else {
989 wait = 30;
990 }
991 }
992 }
993
994 static void qt_close(struct usb_serial_port *port)
995 {
996 struct usb_serial *serial = port->serial;
997 struct quatech_port *qt_port;
998 struct quatech_port *port0;
999 struct tty_struct *tty;
1000 int status;
1001 unsigned int index;
1002 status = 0;
1003
1004 tty = tty_port_tty_get(&port->port);
1005 index = tty->index - serial->minor;
1006
1007 qt_port = qt_get_port_private(port);
1008 port0 = qt_get_port_private(serial->port[0]);
1009
1010 /* shutdown any bulk reads that might be going on */
1011 if (serial->num_bulk_out)
1012 usb_unlink_urb(port->write_urb);
1013 if (serial->num_bulk_in)
1014 usb_unlink_urb(port->read_urb);
1015
1016 /* wait up to for transmitter to empty */
1017 if (serial->dev)
1018 qt_block_until_empty(tty, qt_port);
1019 tty_kref_put(tty);
1020
1021 /* Close uart channel */
1022 status = qt_close_channel(serial, index);
1023 if (status < 0)
1024 dev_dbg(&port->dev, "%s - port %d qt_close_channel failed.\n", __func__, port->number);
1025
1026 port0->open_ports--;
1027
1028 dev_dbg(&port->dev, "qt_num_open_ports in close%d:in port%d\n", port0->open_ports, port->number);
1029
1030 if (port0->open_ports == 0) {
1031 if (serial->port[0]->interrupt_in_urb) {
1032 dev_dbg(&port->dev, "%s", "Shutdown interrupt_in_urb\n");
1033 usb_kill_urb(serial->port[0]->interrupt_in_urb);
1034 }
1035
1036 }
1037
1038 if (qt_port->write_urb) {
1039 /* if this urb had a transfer buffer already (old tx) free it */
1040 kfree(qt_port->write_urb->transfer_buffer);
1041 usb_free_urb(qt_port->write_urb);
1042 }
1043
1044 }
1045
1046 static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
1047 const unsigned char *buf, int count)
1048 {
1049 int result;
1050 struct usb_serial *serial = get_usb_serial(port, __func__);
1051
1052 if (serial == NULL)
1053 return -ENODEV;
1054
1055 if (count == 0) {
1056 dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
1057 return 0;
1058 }
1059
1060 /* only do something if we have a bulk out endpoint */
1061 if (serial->num_bulk_out) {
1062 if (port->write_urb->status == -EINPROGRESS) {
1063 dev_dbg(&port->dev, "%s - already writing\n", __func__);
1064 return 0;
1065 }
1066
1067 count =
1068 (count > port->bulk_out_size) ? port->bulk_out_size : count;
1069 memcpy(port->write_urb->transfer_buffer, buf, count);
1070
1071 /* set up our urb */
1072
1073 usb_fill_bulk_urb(port->write_urb, serial->dev,
1074 usb_sndbulkpipe(serial->dev,
1075 port->
1076 bulk_out_endpointAddress),
1077 port->write_urb->transfer_buffer, count,
1078 qt_write_bulk_callback, port);
1079
1080 /* send the data out the bulk port */
1081 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1082 if (result)
1083 dev_dbg(&port->dev, "%s - failed submitting write urb, error %d\n",
1084 __func__, result);
1085 else
1086 result = count;
1087
1088 return result;
1089 }
1090
1091 /* no bulk out, so return 0 bytes written */
1092 return 0;
1093 }
1094
1095 static int qt_write_room(struct tty_struct *tty)
1096 {
1097 struct usb_serial_port *port = tty->driver_data;
1098 struct usb_serial *serial;
1099 struct quatech_port *qt_port;
1100
1101 int retval = -EINVAL;
1102
1103 if (port_paranoia_check(port, __func__))
1104 return -1;
1105
1106 serial = get_usb_serial(port, __func__);
1107
1108 if (!serial)
1109 return -ENODEV;
1110
1111 qt_port = qt_get_port_private(port);
1112
1113 mutex_lock(&qt_port->lock);
1114
1115 if (serial->num_bulk_out) {
1116 if (port->write_urb->status != -EINPROGRESS)
1117 retval = port->bulk_out_size;
1118 }
1119
1120 mutex_unlock(&qt_port->lock);
1121 return retval;
1122
1123 }
1124
1125 static int qt_ioctl(struct tty_struct *tty,
1126 unsigned int cmd, unsigned long arg)
1127 {
1128 struct usb_serial_port *port = tty->driver_data;
1129 struct quatech_port *qt_port = qt_get_port_private(port);
1130 struct usb_serial *serial = get_usb_serial(port, __func__);
1131 unsigned int index;
1132
1133 dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
1134
1135 index = tty->index - serial->minor;
1136
1137 if (cmd == TIOCMIWAIT) {
1138 while (qt_port != NULL) {
1139 interruptible_sleep_on(&qt_port->msr_wait);
1140 if (signal_pending(current))
1141 return -ERESTARTSYS;
1142 else {
1143 char diff = qt_port->diff_status;
1144
1145 if (diff == 0)
1146 return -EIO; /* no change => error */
1147
1148 /* Consume all events */
1149 qt_port->diff_status = 0;
1150
1151 if (((arg & TIOCM_RNG)
1152 && (diff & SERIAL_MSR_RI))
1153 || ((arg & TIOCM_DSR)
1154 && (diff & SERIAL_MSR_DSR))
1155 || ((arg & TIOCM_CD)
1156 && (diff & SERIAL_MSR_CD))
1157 || ((arg & TIOCM_CTS)
1158 && (diff & SERIAL_MSR_CTS))) {
1159 return 0;
1160 }
1161 }
1162 }
1163 return 0;
1164 }
1165
1166 dev_dbg(&port->dev, "%s -No ioctl for that one. port = %d\n", __func__, port->number);
1167 return -ENOIOCTLCMD;
1168 }
1169
1170 static void qt_set_termios(struct tty_struct *tty,
1171 struct usb_serial_port *port,
1172 struct ktermios *old_termios)
1173 {
1174 struct ktermios *termios = &tty->termios;
1175 unsigned char new_LCR = 0;
1176 unsigned int cflag = termios->c_cflag;
1177 unsigned int index;
1178 int baud, divisor, remainder;
1179 int status;
1180
1181 index = tty->index - port->serial->minor;
1182
1183 switch (cflag & CSIZE) {
1184 case CS5:
1185 new_LCR |= SERIAL_5_DATA;
1186 break;
1187 case CS6:
1188 new_LCR |= SERIAL_6_DATA;
1189 break;
1190 case CS7:
1191 new_LCR |= SERIAL_7_DATA;
1192 break;
1193 default:
1194 termios->c_cflag &= ~CSIZE;
1195 termios->c_cflag |= CS8;
1196 case CS8:
1197 new_LCR |= SERIAL_8_DATA;
1198 break;
1199 }
1200
1201 /* Parity stuff */
1202 if (cflag & PARENB) {
1203 if (cflag & PARODD)
1204 new_LCR |= SERIAL_ODD_PARITY;
1205 else
1206 new_LCR |= SERIAL_EVEN_PARITY;
1207 }
1208 if (cflag & CSTOPB)
1209 new_LCR |= SERIAL_TWO_STOPB;
1210 else
1211 new_LCR |= SERIAL_ONE_STOPB;
1212
1213 dev_dbg(&port->dev, "%s - 4\n", __func__);
1214
1215 /* Thats the LCR stuff, go ahead and set it */
1216 baud = tty_get_baud_rate(tty);
1217 if (!baud)
1218 /* pick a default, any default... */
1219 baud = 9600;
1220
1221 dev_dbg(&port->dev, "%s - got baud = %d\n", __func__, baud);
1222
1223 divisor = MAX_BAUD_RATE / baud;
1224 remainder = MAX_BAUD_RATE % baud;
1225 /* Round to nearest divisor */
1226 if (((remainder * 2) >= baud) && (baud != 110))
1227 divisor++;
1228
1229 /*
1230 * Set Baud rate to default and turn off (default)flow control here
1231 */
1232 status =
1233 qt_setuart(port->serial, index, (unsigned short)divisor, new_LCR);
1234 if (status < 0) {
1235 dev_dbg(&port->dev, "qt_setuart failed\n");
1236 return;
1237 }
1238
1239 /* Now determine flow control */
1240 if (cflag & CRTSCTS) {
1241 dev_dbg(&port->dev, "%s - Enabling HW flow control port %d\n", __func__, port->number);
1242
1243 /* Enable RTS/CTS flow control */
1244 status = BoxSetHW_FlowCtrl(port->serial, index, 1);
1245
1246 if (status < 0) {
1247 dev_dbg(&port->dev, "BoxSetHW_FlowCtrl failed\n");
1248 return;
1249 }
1250 } else {
1251 /* Disable RTS/CTS flow control */
1252 dev_dbg(&port->dev, "%s - disabling HW flow control port %d\n", __func__, port->number);
1253
1254 status = BoxSetHW_FlowCtrl(port->serial, index, 0);
1255 if (status < 0) {
1256 dev_dbg(&port->dev, "BoxSetHW_FlowCtrl failed\n");
1257 return;
1258 }
1259
1260 }
1261
1262 /* if we are implementing XON/XOFF, set the start and stop character in
1263 * the device */
1264 if (I_IXOFF(tty) || I_IXON(tty)) {
1265 unsigned char stop_char = STOP_CHAR(tty);
1266 unsigned char start_char = START_CHAR(tty);
1267 status =
1268 BoxSetSW_FlowCtrl(port->serial, index, stop_char,
1269 start_char);
1270 if (status < 0)
1271 dev_dbg(&port->dev, "BoxSetSW_FlowCtrl (enabled) failed\n");
1272
1273 } else {
1274 /* disable SW flow control */
1275 status = BoxDisable_SW_FlowCtrl(port->serial, index);
1276 if (status < 0)
1277 dev_dbg(&port->dev, "BoxSetSW_FlowCtrl (diabling) failed\n");
1278
1279 }
1280 termios->c_cflag &= ~CMSPAR;
1281 /* FIXME: Error cases should be returning the actual bits changed only */
1282 }
1283
1284 static void qt_break(struct tty_struct *tty, int break_state)
1285 {
1286 struct usb_serial_port *port = tty->driver_data;
1287 struct usb_serial *serial = get_usb_serial(port, __func__);
1288 struct quatech_port *qt_port;
1289 u16 index, onoff;
1290 unsigned int result;
1291
1292 index = tty->index - serial->minor;
1293
1294 qt_port = qt_get_port_private(port);
1295
1296 if (break_state == -1)
1297 onoff = 1;
1298 else
1299 onoff = 0;
1300
1301 mutex_lock(&qt_port->lock);
1302
1303 result =
1304 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1305 QT_BREAK_CONTROL, 0x40, onoff, index, NULL, 0, 300);
1306
1307 mutex_unlock(&qt_port->lock);
1308 }
1309
1310 static inline int qt_real_tiocmget(struct tty_struct *tty,
1311 struct usb_serial_port *port,
1312 struct usb_serial *serial)
1313 {
1314
1315 u8 mcr;
1316 u8 msr;
1317 unsigned int result = 0;
1318 int status;
1319 unsigned int index;
1320
1321 index = tty->index - serial->minor;
1322 status =
1323 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1324 if (status >= 0) {
1325 status =
1326 BoxGetRegister(port->serial, index,
1327 MODEM_STATUS_REGISTER, &msr);
1328
1329 }
1330
1331 if (status >= 0) {
1332 result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1333 /* DTR IS SET */
1334 | ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1335 /* RTS IS SET */
1336 | ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1337 /* CTS is set */
1338 | ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1339 /* Carrier detect is set */
1340 | ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1341 /* Ring indicator set */
1342 | ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1343 /* DSR is set */
1344 return result;
1345
1346 } else
1347 return -ESPIPE;
1348 }
1349
1350 static inline int qt_real_tiocmset(struct tty_struct *tty,
1351 struct usb_serial_port *port,
1352 struct usb_serial *serial,
1353 unsigned int value)
1354 {
1355
1356 u8 mcr;
1357 int status;
1358 unsigned int index;
1359
1360 index = tty->index - serial->minor;
1361 status =
1362 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1363 if (status < 0)
1364 return -ESPIPE;
1365
1366 /*
1367 * Turn off the RTS and DTR and loopback and then only turn on what was
1368 * asked for
1369 */
1370 mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
1371 if (value & TIOCM_RTS)
1372 mcr |= SERIAL_MCR_RTS;
1373 if (value & TIOCM_DTR)
1374 mcr |= SERIAL_MCR_DTR;
1375 if (value & TIOCM_LOOP)
1376 mcr |= SERIAL_MCR_LOOP;
1377
1378 status =
1379 BoxSetRegister(port->serial, index, MODEM_CONTROL_REGISTER, mcr);
1380 if (status < 0)
1381 return -ESPIPE;
1382 else
1383 return 0;
1384 }
1385
1386 static int qt_tiocmget(struct tty_struct *tty)
1387 {
1388 struct usb_serial_port *port = tty->driver_data;
1389 struct usb_serial *serial = get_usb_serial(port, __func__);
1390 struct quatech_port *qt_port = qt_get_port_private(port);
1391 int retval;
1392
1393 if (!serial)
1394 return -ENODEV;
1395
1396 mutex_lock(&qt_port->lock);
1397 retval = qt_real_tiocmget(tty, port, serial);
1398 mutex_unlock(&qt_port->lock);
1399 return retval;
1400 }
1401
1402 static int qt_tiocmset(struct tty_struct *tty,
1403 unsigned int set, unsigned int clear)
1404 {
1405
1406 struct usb_serial_port *port = tty->driver_data;
1407 struct usb_serial *serial = get_usb_serial(port, __func__);
1408 struct quatech_port *qt_port = qt_get_port_private(port);
1409 int retval;
1410
1411 if (!serial)
1412 return -ENODEV;
1413
1414 mutex_lock(&qt_port->lock);
1415 retval = qt_real_tiocmset(tty, port, serial, set);
1416 mutex_unlock(&qt_port->lock);
1417 return retval;
1418 }
1419
1420 static void qt_throttle(struct tty_struct *tty)
1421 {
1422 struct usb_serial_port *port = tty->driver_data;
1423 struct usb_serial *serial = get_usb_serial(port, __func__);
1424 struct quatech_port *qt_port;
1425
1426 if (!serial)
1427 return;
1428
1429 qt_port = qt_get_port_private(port);
1430
1431 mutex_lock(&qt_port->lock);
1432
1433 /* pass on to the driver specific version of this function */
1434 qt_port->RxHolding = 1;
1435
1436 mutex_unlock(&qt_port->lock);
1437 }
1438
1439 static void qt_unthrottle(struct tty_struct *tty)
1440 {
1441 struct usb_serial_port *port = tty->driver_data;
1442 struct usb_serial *serial = get_usb_serial(port, __func__);
1443 struct quatech_port *qt_port;
1444 unsigned int result;
1445
1446 if (!serial)
1447 return;
1448
1449 qt_port = qt_get_port_private(port);
1450
1451 mutex_lock(&qt_port->lock);
1452
1453 if (qt_port->RxHolding == 1) {
1454 dev_dbg(&port->dev, "%s -qt_port->RxHolding == 1\n", __func__);
1455
1456 qt_port->RxHolding = 0;
1457 dev_dbg(&port->dev, "%s - qt_port->RxHolding = 0\n", __func__);
1458
1459 /* if we have a bulk endpoint, start it up */
1460 if ((serial->num_bulk_in) && (qt_port->ReadBulkStopped == 1)) {
1461 /* Start reading from the device */
1462 usb_fill_bulk_urb(port->read_urb, serial->dev,
1463 usb_rcvbulkpipe(serial->dev,
1464 port->bulk_in_endpointAddress),
1465 port->read_urb->transfer_buffer,
1466 port->read_urb->
1467 transfer_buffer_length,
1468 qt_read_bulk_callback, port);
1469 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1470 if (result)
1471 dev_err(&port->dev,
1472 "%s - failed restarting read urb, error %d\n",
1473 __func__, result);
1474 }
1475 }
1476 mutex_unlock(&qt_port->lock);
1477 }
1478
1479 static int qt_calc_num_ports(struct usb_serial *serial)
1480 {
1481 int num_ports;
1482
1483 num_ports =
1484 (serial->interface->cur_altsetting->desc.bNumEndpoints - 1) / 2;
1485
1486 return num_ports;
1487 }
1488
1489 static struct usb_serial_driver quatech_device = {
1490 .driver = {
1491 .owner = THIS_MODULE,
1492 .name = "serqt",
1493 },
1494 .description = DRIVER_DESC,
1495 .id_table = id_table,
1496 .num_ports = 8,
1497 .open = qt_open,
1498 .close = qt_close,
1499 .write = qt_write,
1500 .write_room = qt_write_room,
1501 .chars_in_buffer = qt_chars_in_buffer,
1502 .throttle = qt_throttle,
1503 .unthrottle = qt_unthrottle,
1504 .calc_num_ports = qt_calc_num_ports,
1505 .ioctl = qt_ioctl,
1506 .set_termios = qt_set_termios,
1507 .break_ctl = qt_break,
1508 .tiocmget = qt_tiocmget,
1509 .tiocmset = qt_tiocmset,
1510 .attach = qt_startup,
1511 .release = qt_release,
1512 };
1513
1514 static struct usb_serial_driver * const serial_drivers[] = {
1515 &quatech_device, NULL
1516 };
1517
1518 module_usb_serial_driver(serial_drivers, id_table);
1519
1520 MODULE_AUTHOR(DRIVER_AUTHOR);
1521 MODULE_DESCRIPTION(DRIVER_DESC);
1522 MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)