1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/kernel.h>
21#include <linux/errno.h>
22#include <linux/slab.h>
23#include <linux/tty.h>
24#include <linux/tty_driver.h>
25#include <linux/tty_flip.h>
26#include <linux/module.h>
27#include <linux/spinlock.h>
28#include <linux/serial.h>
29#include <linux/serial_reg.h>
30#include <linux/usb.h>
31#include <linux/usb/serial.h>
32#include <linux/uaccess.h>
33#include <linux/parport.h>
34
35#define DRIVER_AUTHOR "Aspire Communications pvt Ltd."
36#define DRIVER_DESC "Moschip USB Serial Driver"
37
38
39#define MOS_WDR_TIMEOUT 5000
40
41#define MOS_MAX_PORT 0x02
42#define MOS_WRITE 0x0E
43#define MOS_READ 0x0D
44
45
46#define SERIAL_IIR_RLS 0x06
47#define SERIAL_IIR_RDA 0x04
48#define SERIAL_IIR_CTI 0x0c
49#define SERIAL_IIR_THR 0x02
50#define SERIAL_IIR_MS 0x00
51
52#define NUM_URBS 16
53#define URB_TRANSFER_BUFFER_SIZE 32
54
55
56struct moschip_port {
57 __u8 shadowLCR;
58 __u8 shadowMCR;
59 __u8 shadowMSR;
60 char open;
61 struct usb_serial_port *port;
62 struct urb *write_urb_pool[NUM_URBS];
63};
64
65#define USB_VENDOR_ID_MOSCHIP 0x9710
66#define MOSCHIP_DEVICE_ID_7720 0x7720
67#define MOSCHIP_DEVICE_ID_7715 0x7715
68
69static const struct usb_device_id id_table[] = {
70 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
71 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7715) },
72 { }
73};
74MODULE_DEVICE_TABLE(usb, id_table);
75
76#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
77
78
79#define DCR_INIT_VAL 0x0c
80#define ECR_INIT_VAL 0x00
81
82enum mos7715_pp_modes {
83 SPP = 0<<5,
84 PS2 = 1<<5,
85 PPF = 2<<5,
86};
87
88struct mos7715_parport {
89 struct parport *pp;
90 struct kref ref_count;
91 bool msg_pending;
92 struct completion syncmsg_compl;
93 struct work_struct work;
94 struct usb_serial *serial;
95 __u8 shadowECR;
96 __u8 shadowDCR;
97 atomic_t shadowDSR;
98};
99
100
101static DEFINE_SPINLOCK(release_lock);
102
103#endif
104
105static const unsigned int dummy;
106
107enum mos_regs {
108 MOS7720_THR,
109 MOS7720_RHR,
110 MOS7720_IER,
111 MOS7720_FCR,
112 MOS7720_ISR,
113 MOS7720_LCR,
114 MOS7720_MCR,
115 MOS7720_LSR,
116 MOS7720_MSR,
117 MOS7720_SPR,
118 MOS7720_DLL,
119 MOS7720_DLM,
120 MOS7720_DPR,
121 MOS7720_DSR,
122 MOS7720_DCR,
123 MOS7720_ECR,
124 MOS7720_SP1_REG,
125 MOS7720_SP2_REG,
126 MOS7720_PP_REG,
127 MOS7720_SP_CONTROL_REG,
128};
129
130
131
132
133
134static inline __u16 get_reg_index(enum mos_regs reg)
135{
136 static const __u16 mos7715_index_lookup_table[] = {
137 0x00,
138 0x00,
139 0x01,
140 0x02,
141 0x02,
142 0x03,
143 0x04,
144 0x05,
145 0x06,
146 0x07,
147 0x00,
148 0x01,
149 0x00,
150 0x01,
151 0x02,
152 0x0a,
153 0x01,
154 0x02,
155 0x04,
156 0x08,
157 };
158 return mos7715_index_lookup_table[reg];
159}
160
161
162
163
164
165static inline __u16 get_reg_value(enum mos_regs reg,
166 unsigned int serial_portnum)
167{
168 if (reg >= MOS7720_SP1_REG)
169 return 0x0000;
170
171 else if (reg >= MOS7720_DPR)
172 return 0x0100;
173
174 else
175 return (serial_portnum + 2) << 8;
176}
177
178
179
180
181
182
183static int write_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
184 enum mos_regs reg, __u8 data)
185{
186 struct usb_device *usbdev = serial->dev;
187 unsigned int pipe = usb_sndctrlpipe(usbdev, 0);
188 __u8 request = (__u8)0x0e;
189 __u8 requesttype = (__u8)0x40;
190 __u16 index = get_reg_index(reg);
191 __u16 value = get_reg_value(reg, serial_portnum) + data;
192 int status = usb_control_msg(usbdev, pipe, request, requesttype, value,
193 index, NULL, 0, MOS_WDR_TIMEOUT);
194 if (status < 0)
195 dev_err(&usbdev->dev,
196 "mos7720: usb_control_msg() failed: %d\n", status);
197 return status;
198}
199
200
201
202
203
204
205static int read_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
206 enum mos_regs reg, __u8 *data)
207{
208 struct usb_device *usbdev = serial->dev;
209 unsigned int pipe = usb_rcvctrlpipe(usbdev, 0);
210 __u8 request = (__u8)0x0d;
211 __u8 requesttype = (__u8)0xc0;
212 __u16 index = get_reg_index(reg);
213 __u16 value = get_reg_value(reg, serial_portnum);
214 u8 *buf;
215 int status;
216
217 buf = kmalloc(1, GFP_KERNEL);
218 if (!buf) {
219 *data = 0;
220 return -ENOMEM;
221 }
222
223 status = usb_control_msg(usbdev, pipe, request, requesttype, value,
224 index, buf, 1, MOS_WDR_TIMEOUT);
225 if (status == 1) {
226 *data = *buf;
227 } else {
228 dev_err(&usbdev->dev,
229 "mos7720: usb_control_msg() failed: %d\n", status);
230 if (status >= 0)
231 status = -EIO;
232 *data = 0;
233 }
234
235 kfree(buf);
236
237 return status;
238}
239
240#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
241
242static inline int mos7715_change_mode(struct mos7715_parport *mos_parport,
243 enum mos7715_pp_modes mode)
244{
245 mos_parport->shadowECR = mode;
246 write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
247 mos_parport->shadowECR);
248 return 0;
249}
250
251static void destroy_mos_parport(struct kref *kref)
252{
253 struct mos7715_parport *mos_parport =
254 container_of(kref, struct mos7715_parport, ref_count);
255
256 kfree(mos_parport);
257}
258
259
260
261
262
263
264
265
266
267
268
269
270
271static int parport_prologue(struct parport *pp)
272{
273 struct mos7715_parport *mos_parport;
274
275 spin_lock(&release_lock);
276 mos_parport = pp->private_data;
277 if (unlikely(mos_parport == NULL)) {
278
279 spin_unlock(&release_lock);
280 return -1;
281 }
282 mos_parport->msg_pending = true;
283 reinit_completion(&mos_parport->syncmsg_compl);
284 spin_unlock(&release_lock);
285
286
287 if (work_pending(&mos_parport->work))
288 flush_work(&mos_parport->work);
289
290 mutex_lock(&mos_parport->serial->disc_mutex);
291 if (mos_parport->serial->disconnected) {
292
293 mutex_unlock(&mos_parport->serial->disc_mutex);
294 mos_parport->msg_pending = false;
295 complete(&mos_parport->syncmsg_compl);
296 return -1;
297 }
298
299 return 0;
300}
301
302
303
304
305
306static inline void parport_epilogue(struct parport *pp)
307{
308 struct mos7715_parport *mos_parport = pp->private_data;
309 mutex_unlock(&mos_parport->serial->disc_mutex);
310 mos_parport->msg_pending = false;
311 complete(&mos_parport->syncmsg_compl);
312}
313
314static void deferred_restore_writes(struct work_struct *work)
315{
316 struct mos7715_parport *mos_parport;
317
318 mos_parport = container_of(work, struct mos7715_parport, work);
319
320 mutex_lock(&mos_parport->serial->disc_mutex);
321
322
323 if (mos_parport->serial->disconnected)
324 goto done;
325
326 write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
327 mos_parport->shadowDCR);
328 write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
329 mos_parport->shadowECR);
330done:
331 mutex_unlock(&mos_parport->serial->disc_mutex);
332}
333
334static void parport_mos7715_write_data(struct parport *pp, unsigned char d)
335{
336 struct mos7715_parport *mos_parport = pp->private_data;
337
338 if (parport_prologue(pp) < 0)
339 return;
340 mos7715_change_mode(mos_parport, SPP);
341 write_mos_reg(mos_parport->serial, dummy, MOS7720_DPR, (__u8)d);
342 parport_epilogue(pp);
343}
344
345static unsigned char parport_mos7715_read_data(struct parport *pp)
346{
347 struct mos7715_parport *mos_parport = pp->private_data;
348 unsigned char d;
349
350 if (parport_prologue(pp) < 0)
351 return 0;
352 read_mos_reg(mos_parport->serial, dummy, MOS7720_DPR, &d);
353 parport_epilogue(pp);
354 return d;
355}
356
357static void parport_mos7715_write_control(struct parport *pp, unsigned char d)
358{
359 struct mos7715_parport *mos_parport = pp->private_data;
360 __u8 data;
361
362 if (parport_prologue(pp) < 0)
363 return;
364 data = ((__u8)d & 0x0f) | (mos_parport->shadowDCR & 0xf0);
365 write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR, data);
366 mos_parport->shadowDCR = data;
367 parport_epilogue(pp);
368}
369
370static unsigned char parport_mos7715_read_control(struct parport *pp)
371{
372 struct mos7715_parport *mos_parport;
373 __u8 dcr;
374
375 spin_lock(&release_lock);
376 mos_parport = pp->private_data;
377 if (unlikely(mos_parport == NULL)) {
378 spin_unlock(&release_lock);
379 return 0;
380 }
381 dcr = mos_parport->shadowDCR & 0x0f;
382 spin_unlock(&release_lock);
383 return dcr;
384}
385
386static unsigned char parport_mos7715_frob_control(struct parport *pp,
387 unsigned char mask,
388 unsigned char val)
389{
390 struct mos7715_parport *mos_parport = pp->private_data;
391 __u8 dcr;
392
393 mask &= 0x0f;
394 val &= 0x0f;
395 if (parport_prologue(pp) < 0)
396 return 0;
397 mos_parport->shadowDCR = (mos_parport->shadowDCR & (~mask)) ^ val;
398 write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
399 mos_parport->shadowDCR);
400 dcr = mos_parport->shadowDCR & 0x0f;
401 parport_epilogue(pp);
402 return dcr;
403}
404
405static unsigned char parport_mos7715_read_status(struct parport *pp)
406{
407 unsigned char status;
408 struct mos7715_parport *mos_parport;
409
410 spin_lock(&release_lock);
411 mos_parport = pp->private_data;
412 if (unlikely(mos_parport == NULL)) {
413 spin_unlock(&release_lock);
414 return 0;
415 }
416 status = atomic_read(&mos_parport->shadowDSR) & 0xf8;
417 spin_unlock(&release_lock);
418 return status;
419}
420
421static void parport_mos7715_enable_irq(struct parport *pp)
422{
423}
424
425static void parport_mos7715_disable_irq(struct parport *pp)
426{
427}
428
429static void parport_mos7715_data_forward(struct parport *pp)
430{
431 struct mos7715_parport *mos_parport = pp->private_data;
432
433 if (parport_prologue(pp) < 0)
434 return;
435 mos7715_change_mode(mos_parport, PS2);
436 mos_parport->shadowDCR &= ~0x20;
437 write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
438 mos_parport->shadowDCR);
439 parport_epilogue(pp);
440}
441
442static void parport_mos7715_data_reverse(struct parport *pp)
443{
444 struct mos7715_parport *mos_parport = pp->private_data;
445
446 if (parport_prologue(pp) < 0)
447 return;
448 mos7715_change_mode(mos_parport, PS2);
449 mos_parport->shadowDCR |= 0x20;
450 write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
451 mos_parport->shadowDCR);
452 parport_epilogue(pp);
453}
454
455static void parport_mos7715_init_state(struct pardevice *dev,
456 struct parport_state *s)
457{
458 s->u.pc.ctr = DCR_INIT_VAL;
459 s->u.pc.ecr = ECR_INIT_VAL;
460}
461
462
463static void parport_mos7715_save_state(struct parport *pp,
464 struct parport_state *s)
465{
466 struct mos7715_parport *mos_parport;
467
468 spin_lock(&release_lock);
469 mos_parport = pp->private_data;
470 if (unlikely(mos_parport == NULL)) {
471 spin_unlock(&release_lock);
472 return;
473 }
474 s->u.pc.ctr = mos_parport->shadowDCR;
475 s->u.pc.ecr = mos_parport->shadowECR;
476 spin_unlock(&release_lock);
477}
478
479
480static void parport_mos7715_restore_state(struct parport *pp,
481 struct parport_state *s)
482{
483 struct mos7715_parport *mos_parport;
484
485 spin_lock(&release_lock);
486 mos_parport = pp->private_data;
487 if (unlikely(mos_parport == NULL)) {
488 spin_unlock(&release_lock);
489 return;
490 }
491 mos_parport->shadowDCR = s->u.pc.ctr;
492 mos_parport->shadowECR = s->u.pc.ecr;
493
494 schedule_work(&mos_parport->work);
495 spin_unlock(&release_lock);
496}
497
498static size_t parport_mos7715_write_compat(struct parport *pp,
499 const void *buffer,
500 size_t len, int flags)
501{
502 int retval;
503 struct mos7715_parport *mos_parport = pp->private_data;
504 int actual_len;
505
506 if (parport_prologue(pp) < 0)
507 return 0;
508 mos7715_change_mode(mos_parport, PPF);
509 retval = usb_bulk_msg(mos_parport->serial->dev,
510 usb_sndbulkpipe(mos_parport->serial->dev, 2),
511 (void *)buffer, len, &actual_len,
512 MOS_WDR_TIMEOUT);
513 parport_epilogue(pp);
514 if (retval) {
515 dev_err(&mos_parport->serial->dev->dev,
516 "mos7720: usb_bulk_msg() failed: %d\n", retval);
517 return 0;
518 }
519 return actual_len;
520}
521
522static struct parport_operations parport_mos7715_ops = {
523 .owner = THIS_MODULE,
524 .write_data = parport_mos7715_write_data,
525 .read_data = parport_mos7715_read_data,
526
527 .write_control = parport_mos7715_write_control,
528 .read_control = parport_mos7715_read_control,
529 .frob_control = parport_mos7715_frob_control,
530
531 .read_status = parport_mos7715_read_status,
532
533 .enable_irq = parport_mos7715_enable_irq,
534 .disable_irq = parport_mos7715_disable_irq,
535
536 .data_forward = parport_mos7715_data_forward,
537 .data_reverse = parport_mos7715_data_reverse,
538
539 .init_state = parport_mos7715_init_state,
540 .save_state = parport_mos7715_save_state,
541 .restore_state = parport_mos7715_restore_state,
542
543 .compat_write_data = parport_mos7715_write_compat,
544
545 .nibble_read_data = parport_ieee1284_read_nibble,
546 .byte_read_data = parport_ieee1284_read_byte,
547};
548
549
550
551
552
553static int mos7715_parport_init(struct usb_serial *serial)
554{
555 struct mos7715_parport *mos_parport;
556
557
558 mos_parport = kzalloc(sizeof(struct mos7715_parport), GFP_KERNEL);
559 if (!mos_parport)
560 return -ENOMEM;
561
562 mos_parport->msg_pending = false;
563 kref_init(&mos_parport->ref_count);
564 usb_set_serial_data(serial, mos_parport);
565 mos_parport->serial = serial;
566 INIT_WORK(&mos_parport->work, deferred_restore_writes);
567 init_completion(&mos_parport->syncmsg_compl);
568
569
570 write_mos_reg(mos_parport->serial, dummy, MOS7720_PP_REG, (__u8)0x80);
571 write_mos_reg(mos_parport->serial, dummy, MOS7720_PP_REG, (__u8)0x00);
572
573
574 mos_parport->shadowDCR = DCR_INIT_VAL;
575 write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
576 mos_parport->shadowDCR);
577 mos_parport->shadowECR = ECR_INIT_VAL;
578 write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
579 mos_parport->shadowECR);
580
581
582 mos_parport->pp = parport_register_port(0, PARPORT_IRQ_NONE,
583 PARPORT_DMA_NONE,
584 &parport_mos7715_ops);
585 if (mos_parport->pp == NULL) {
586 dev_err(&serial->interface->dev,
587 "Could not register parport\n");
588 kref_put(&mos_parport->ref_count, destroy_mos_parport);
589 return -EIO;
590 }
591 mos_parport->pp->private_data = mos_parport;
592 mos_parport->pp->modes = PARPORT_MODE_COMPAT | PARPORT_MODE_PCSPP;
593 mos_parport->pp->dev = &serial->interface->dev;
594 parport_announce_port(mos_parport->pp);
595
596 return 0;
597}
598#endif
599
600
601
602
603
604
605static void mos7720_interrupt_callback(struct urb *urb)
606{
607 int result;
608 int length;
609 int status = urb->status;
610 struct device *dev = &urb->dev->dev;
611 __u8 *data;
612 __u8 sp1;
613 __u8 sp2;
614
615 switch (status) {
616 case 0:
617
618 break;
619 case -ECONNRESET:
620 case -ENOENT:
621 case -ESHUTDOWN:
622
623 dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
624 return;
625 default:
626 dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
627 goto exit;
628 }
629
630 length = urb->actual_length;
631 data = urb->transfer_buffer;
632
633
634
635
636
637
638
639
640
641
642 if (unlikely(length != 4)) {
643 dev_dbg(dev, "Wrong data !!!\n");
644 return;
645 }
646
647 sp1 = data[3];
648 sp2 = data[2];
649
650 if ((sp1 | sp2) & 0x01) {
651
652 dev_dbg(dev, "No Interrupt !!!\n");
653 } else {
654 switch (sp1 & 0x0f) {
655 case SERIAL_IIR_RLS:
656 dev_dbg(dev, "Serial Port 1: Receiver status error or address bit detected in 9-bit mode\n");
657 break;
658 case SERIAL_IIR_CTI:
659 dev_dbg(dev, "Serial Port 1: Receiver time out\n");
660 break;
661 case SERIAL_IIR_MS:
662
663 break;
664 }
665
666 switch (sp2 & 0x0f) {
667 case SERIAL_IIR_RLS:
668 dev_dbg(dev, "Serial Port 2: Receiver status error or address bit detected in 9-bit mode\n");
669 break;
670 case SERIAL_IIR_CTI:
671 dev_dbg(dev, "Serial Port 2: Receiver time out\n");
672 break;
673 case SERIAL_IIR_MS:
674
675 break;
676 }
677 }
678
679exit:
680 result = usb_submit_urb(urb, GFP_ATOMIC);
681 if (result)
682 dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
683}
684
685
686
687
688
689
690static void mos7715_interrupt_callback(struct urb *urb)
691{
692 int result;
693 int length;
694 int status = urb->status;
695 struct device *dev = &urb->dev->dev;
696 __u8 *data;
697 __u8 iir;
698
699 switch (status) {
700 case 0:
701
702 break;
703 case -ECONNRESET:
704 case -ENOENT:
705 case -ESHUTDOWN:
706 case -ENODEV:
707
708 dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
709 return;
710 default:
711 dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
712 goto exit;
713 }
714
715 length = urb->actual_length;
716 data = urb->transfer_buffer;
717
718
719
720
721
722
723
724 if (unlikely(length != 4)) {
725 dev_dbg(dev, "Wrong data !!!\n");
726 return;
727 }
728
729 iir = data[0];
730 if (!(iir & 0x01)) {
731 switch (iir & 0x0f) {
732 case SERIAL_IIR_RLS:
733 dev_dbg(dev, "Serial Port: Receiver status error or address bit detected in 9-bit mode\n");
734 break;
735 case SERIAL_IIR_CTI:
736 dev_dbg(dev, "Serial Port: Receiver time out\n");
737 break;
738 case SERIAL_IIR_MS:
739
740 break;
741 }
742 }
743
744#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
745 {
746 struct usb_serial_port *port = urb->context;
747 struct mos7715_parport *mos_parport = port->serial->private;
748 if (unlikely(mos_parport == NULL))
749 return;
750 atomic_set(&mos_parport->shadowDSR, data[2]);
751 }
752#endif
753
754exit:
755 result = usb_submit_urb(urb, GFP_ATOMIC);
756 if (result)
757 dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
758}
759
760
761
762
763
764
765static void mos7720_bulk_in_callback(struct urb *urb)
766{
767 int retval;
768 unsigned char *data ;
769 struct usb_serial_port *port;
770 int status = urb->status;
771
772 if (status) {
773 dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
774 return;
775 }
776
777 port = urb->context;
778
779 dev_dbg(&port->dev, "Entering...%s\n", __func__);
780
781 data = urb->transfer_buffer;
782
783 if (urb->actual_length) {
784 tty_insert_flip_string(&port->port, data, urb->actual_length);
785 tty_flip_buffer_push(&port->port);
786 }
787
788 if (port->read_urb->status != -EINPROGRESS) {
789 retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
790 if (retval)
791 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
792 }
793}
794
795
796
797
798
799
800static void mos7720_bulk_out_data_callback(struct urb *urb)
801{
802 struct moschip_port *mos7720_port;
803 int status = urb->status;
804
805 if (status) {
806 dev_dbg(&urb->dev->dev, "nonzero write bulk status received:%d\n", status);
807 return;
808 }
809
810 mos7720_port = urb->context;
811 if (!mos7720_port) {
812 dev_dbg(&urb->dev->dev, "NULL mos7720_port pointer\n");
813 return ;
814 }
815
816 if (mos7720_port->open)
817 tty_port_tty_wakeup(&mos7720_port->port->port);
818}
819
820static int mos77xx_calc_num_ports(struct usb_serial *serial,
821 struct usb_serial_endpoints *epds)
822{
823 u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
824
825 if (product == MOSCHIP_DEVICE_ID_7715) {
826
827
828
829
830
831
832
833 swap(epds->bulk_in[0], epds->bulk_in[1]);
834 swap(epds->bulk_out[0], epds->bulk_out[1]);
835
836 return 1;
837 }
838
839 return 2;
840}
841
842static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
843{
844 struct usb_serial *serial;
845 struct urb *urb;
846 struct moschip_port *mos7720_port;
847 int response;
848 int port_number;
849 __u8 data;
850 int allocated_urbs = 0;
851 int j;
852
853 serial = port->serial;
854
855 mos7720_port = usb_get_serial_port_data(port);
856 if (mos7720_port == NULL)
857 return -ENODEV;
858
859 usb_clear_halt(serial->dev, port->write_urb->pipe);
860 usb_clear_halt(serial->dev, port->read_urb->pipe);
861
862
863 for (j = 0; j < NUM_URBS; ++j) {
864 urb = usb_alloc_urb(0, GFP_KERNEL);
865 mos7720_port->write_urb_pool[j] = urb;
866 if (!urb)
867 continue;
868
869 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
870 GFP_KERNEL);
871 if (!urb->transfer_buffer) {
872 usb_free_urb(mos7720_port->write_urb_pool[j]);
873 mos7720_port->write_urb_pool[j] = NULL;
874 continue;
875 }
876 allocated_urbs++;
877 }
878
879 if (!allocated_urbs)
880 return -ENOMEM;
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896 port_number = port->port_number;
897 read_mos_reg(serial, port_number, MOS7720_LSR, &data);
898
899 dev_dbg(&port->dev, "SS::%p LSR:%x\n", mos7720_port, data);
900
901 write_mos_reg(serial, dummy, MOS7720_SP1_REG, 0x02);
902 write_mos_reg(serial, dummy, MOS7720_SP2_REG, 0x02);
903
904 write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
905 write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
906
907 write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
908 mos7720_port->shadowLCR = 0x03;
909 write_mos_reg(serial, port_number, MOS7720_LCR,
910 mos7720_port->shadowLCR);
911 mos7720_port->shadowMCR = 0x0b;
912 write_mos_reg(serial, port_number, MOS7720_MCR,
913 mos7720_port->shadowMCR);
914
915 write_mos_reg(serial, port_number, MOS7720_SP_CONTROL_REG, 0x00);
916 read_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, &data);
917 data = data | (port->port_number + 1);
918 write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, data);
919 mos7720_port->shadowLCR = 0x83;
920 write_mos_reg(serial, port_number, MOS7720_LCR,
921 mos7720_port->shadowLCR);
922 write_mos_reg(serial, port_number, MOS7720_THR, 0x0c);
923 write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
924 mos7720_port->shadowLCR = 0x03;
925 write_mos_reg(serial, port_number, MOS7720_LCR,
926 mos7720_port->shadowLCR);
927 write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
928
929 response = usb_submit_urb(port->read_urb, GFP_KERNEL);
930 if (response)
931 dev_err(&port->dev, "%s - Error %d submitting read urb\n",
932 __func__, response);
933
934
935 mos7720_port->shadowMCR = UART_MCR_OUT2;
936
937
938 mos7720_port->open = 1;
939
940 return 0;
941}
942
943
944
945
946
947
948
949static unsigned int mos7720_chars_in_buffer(struct tty_struct *tty)
950{
951 struct usb_serial_port *port = tty->driver_data;
952 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
953 int i;
954 unsigned int chars = 0;
955
956 for (i = 0; i < NUM_URBS; ++i) {
957 if (mos7720_port->write_urb_pool[i] &&
958 mos7720_port->write_urb_pool[i]->status == -EINPROGRESS)
959 chars += URB_TRANSFER_BUFFER_SIZE;
960 }
961 dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
962 return chars;
963}
964
965static void mos7720_close(struct usb_serial_port *port)
966{
967 struct usb_serial *serial;
968 struct moschip_port *mos7720_port;
969 int j;
970
971 serial = port->serial;
972
973 mos7720_port = usb_get_serial_port_data(port);
974 if (mos7720_port == NULL)
975 return;
976
977 for (j = 0; j < NUM_URBS; ++j)
978 usb_kill_urb(mos7720_port->write_urb_pool[j]);
979
980
981 for (j = 0; j < NUM_URBS; ++j) {
982 if (mos7720_port->write_urb_pool[j]) {
983 kfree(mos7720_port->write_urb_pool[j]->transfer_buffer);
984 usb_free_urb(mos7720_port->write_urb_pool[j]);
985 }
986 }
987
988
989
990 usb_kill_urb(port->write_urb);
991 usb_kill_urb(port->read_urb);
992
993 write_mos_reg(serial, port->port_number, MOS7720_MCR, 0x00);
994 write_mos_reg(serial, port->port_number, MOS7720_IER, 0x00);
995
996 mos7720_port->open = 0;
997}
998
999static void mos7720_break(struct tty_struct *tty, int break_state)
1000{
1001 struct usb_serial_port *port = tty->driver_data;
1002 unsigned char data;
1003 struct usb_serial *serial;
1004 struct moschip_port *mos7720_port;
1005
1006 serial = port->serial;
1007
1008 mos7720_port = usb_get_serial_port_data(port);
1009 if (mos7720_port == NULL)
1010 return;
1011
1012 if (break_state == -1)
1013 data = mos7720_port->shadowLCR | UART_LCR_SBC;
1014 else
1015 data = mos7720_port->shadowLCR & ~UART_LCR_SBC;
1016
1017 mos7720_port->shadowLCR = data;
1018 write_mos_reg(serial, port->port_number, MOS7720_LCR,
1019 mos7720_port->shadowLCR);
1020}
1021
1022
1023
1024
1025
1026
1027static unsigned int mos7720_write_room(struct tty_struct *tty)
1028{
1029 struct usb_serial_port *port = tty->driver_data;
1030 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1031 unsigned int room = 0;
1032 int i;
1033
1034
1035 for (i = 0; i < NUM_URBS; ++i) {
1036 if (mos7720_port->write_urb_pool[i] &&
1037 mos7720_port->write_urb_pool[i]->status != -EINPROGRESS)
1038 room += URB_TRANSFER_BUFFER_SIZE;
1039 }
1040
1041 dev_dbg(&port->dev, "%s - returns %u\n", __func__, room);
1042 return room;
1043}
1044
1045static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
1046 const unsigned char *data, int count)
1047{
1048 int status;
1049 int i;
1050 int bytes_sent = 0;
1051 int transfer_size;
1052
1053 struct moschip_port *mos7720_port;
1054 struct usb_serial *serial;
1055 struct urb *urb;
1056 const unsigned char *current_position = data;
1057
1058 serial = port->serial;
1059
1060 mos7720_port = usb_get_serial_port_data(port);
1061 if (mos7720_port == NULL)
1062 return -ENODEV;
1063
1064
1065 urb = NULL;
1066
1067 for (i = 0; i < NUM_URBS; ++i) {
1068 if (mos7720_port->write_urb_pool[i] &&
1069 mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) {
1070 urb = mos7720_port->write_urb_pool[i];
1071 dev_dbg(&port->dev, "URB:%d\n", i);
1072 break;
1073 }
1074 }
1075
1076 if (urb == NULL) {
1077 dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
1078 goto exit;
1079 }
1080
1081 if (urb->transfer_buffer == NULL) {
1082 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
1083 GFP_ATOMIC);
1084 if (!urb->transfer_buffer) {
1085 bytes_sent = -ENOMEM;
1086 goto exit;
1087 }
1088 }
1089 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
1090
1091 memcpy(urb->transfer_buffer, current_position, transfer_size);
1092 usb_serial_debug_data(&port->dev, __func__, transfer_size,
1093 urb->transfer_buffer);
1094
1095
1096 usb_fill_bulk_urb(urb, serial->dev,
1097 usb_sndbulkpipe(serial->dev,
1098 port->bulk_out_endpointAddress),
1099 urb->transfer_buffer, transfer_size,
1100 mos7720_bulk_out_data_callback, mos7720_port);
1101
1102
1103 status = usb_submit_urb(urb, GFP_ATOMIC);
1104 if (status) {
1105 dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
1106 "with status = %d\n", __func__, status);
1107 bytes_sent = status;
1108 goto exit;
1109 }
1110 bytes_sent = transfer_size;
1111
1112exit:
1113 return bytes_sent;
1114}
1115
1116static void mos7720_throttle(struct tty_struct *tty)
1117{
1118 struct usb_serial_port *port = tty->driver_data;
1119 struct moschip_port *mos7720_port;
1120 int status;
1121
1122 mos7720_port = usb_get_serial_port_data(port);
1123
1124 if (mos7720_port == NULL)
1125 return;
1126
1127 if (!mos7720_port->open) {
1128 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1129 return;
1130 }
1131
1132
1133 if (I_IXOFF(tty)) {
1134 unsigned char stop_char = STOP_CHAR(tty);
1135 status = mos7720_write(tty, port, &stop_char, 1);
1136 if (status <= 0)
1137 return;
1138 }
1139
1140
1141 if (C_CRTSCTS(tty)) {
1142 mos7720_port->shadowMCR &= ~UART_MCR_RTS;
1143 write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
1144 mos7720_port->shadowMCR);
1145 }
1146}
1147
1148static void mos7720_unthrottle(struct tty_struct *tty)
1149{
1150 struct usb_serial_port *port = tty->driver_data;
1151 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1152 int status;
1153
1154 if (mos7720_port == NULL)
1155 return;
1156
1157 if (!mos7720_port->open) {
1158 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1159 return;
1160 }
1161
1162
1163 if (I_IXOFF(tty)) {
1164 unsigned char start_char = START_CHAR(tty);
1165 status = mos7720_write(tty, port, &start_char, 1);
1166 if (status <= 0)
1167 return;
1168 }
1169
1170
1171 if (C_CRTSCTS(tty)) {
1172 mos7720_port->shadowMCR |= UART_MCR_RTS;
1173 write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
1174 mos7720_port->shadowMCR);
1175 }
1176}
1177
1178
1179static int set_higher_rates(struct moschip_port *mos7720_port,
1180 unsigned int baud)
1181{
1182 struct usb_serial_port *port;
1183 struct usb_serial *serial;
1184 int port_number;
1185 enum mos_regs sp_reg;
1186 if (mos7720_port == NULL)
1187 return -EINVAL;
1188
1189 port = mos7720_port->port;
1190 serial = port->serial;
1191
1192
1193
1194
1195 dev_dbg(&port->dev, "Sending Setting Commands ..........\n");
1196 port_number = port->port_number;
1197
1198 write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
1199 write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
1200 write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
1201 mos7720_port->shadowMCR = 0x0b;
1202 write_mos_reg(serial, port_number, MOS7720_MCR,
1203 mos7720_port->shadowMCR);
1204 write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, 0x00);
1205
1206
1207
1208
1209
1210 if (port_number == 0)
1211 sp_reg = MOS7720_SP1_REG;
1212 else
1213 sp_reg = MOS7720_SP2_REG;
1214 write_mos_reg(serial, dummy, sp_reg, baud * 0x10);
1215 write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, 0x03);
1216 mos7720_port->shadowMCR = 0x2b;
1217 write_mos_reg(serial, port_number, MOS7720_MCR,
1218 mos7720_port->shadowMCR);
1219
1220
1221
1222
1223 mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
1224 write_mos_reg(serial, port_number, MOS7720_LCR,
1225 mos7720_port->shadowLCR);
1226 write_mos_reg(serial, port_number, MOS7720_DLL, 0x01);
1227 write_mos_reg(serial, port_number, MOS7720_DLM, 0x00);
1228 mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
1229 write_mos_reg(serial, port_number, MOS7720_LCR,
1230 mos7720_port->shadowLCR);
1231
1232 return 0;
1233}
1234
1235
1236struct divisor_table_entry {
1237 __u32 baudrate;
1238 __u16 divisor;
1239};
1240
1241
1242
1243
1244static const struct divisor_table_entry divisor_table[] = {
1245 { 50, 2304},
1246 { 110, 1047},
1247 { 134, 857},
1248 { 150, 768},
1249 { 300, 384},
1250 { 600, 192},
1251 { 1200, 96},
1252 { 1800, 64},
1253 { 2400, 48},
1254 { 4800, 24},
1255 { 7200, 16},
1256 { 9600, 12},
1257 { 19200, 6},
1258 { 38400, 3},
1259 { 57600, 2},
1260 { 115200, 1},
1261};
1262
1263
1264
1265
1266
1267
1268static int calc_baud_rate_divisor(struct usb_serial_port *port, int baudrate, int *divisor)
1269{
1270 int i;
1271 __u16 custom;
1272 __u16 round1;
1273 __u16 round;
1274
1275
1276 dev_dbg(&port->dev, "%s - %d\n", __func__, baudrate);
1277
1278 for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
1279 if (divisor_table[i].baudrate == baudrate) {
1280 *divisor = divisor_table[i].divisor;
1281 return 0;
1282 }
1283 }
1284
1285
1286
1287 if (baudrate > 75 && baudrate < 230400) {
1288
1289 custom = (__u16)(230400L / baudrate);
1290
1291
1292 round1 = (__u16)(2304000L / baudrate);
1293 round = (__u16)(round1 - (custom * 10));
1294 if (round > 4)
1295 custom++;
1296 *divisor = custom;
1297
1298 dev_dbg(&port->dev, "Baud %d = %d\n", baudrate, custom);
1299 return 0;
1300 }
1301
1302 dev_dbg(&port->dev, "Baud calculation Failed...\n");
1303 return -EINVAL;
1304}
1305
1306
1307
1308
1309
1310
1311static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
1312 int baudrate)
1313{
1314 struct usb_serial_port *port;
1315 struct usb_serial *serial;
1316 int divisor;
1317 int status;
1318 unsigned char number;
1319
1320 if (mos7720_port == NULL)
1321 return -1;
1322
1323 port = mos7720_port->port;
1324 serial = port->serial;
1325
1326 number = port->port_number;
1327 dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudrate);
1328
1329
1330 status = calc_baud_rate_divisor(port, baudrate, &divisor);
1331 if (status) {
1332 dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1333 return status;
1334 }
1335
1336
1337 mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
1338 write_mos_reg(serial, number, MOS7720_LCR, mos7720_port->shadowLCR);
1339
1340
1341 write_mos_reg(serial, number, MOS7720_DLL, (__u8)(divisor & 0xff));
1342 write_mos_reg(serial, number, MOS7720_DLM,
1343 (__u8)((divisor & 0xff00) >> 8));
1344
1345
1346 mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
1347 write_mos_reg(serial, number, MOS7720_LCR, mos7720_port->shadowLCR);
1348
1349 return status;
1350}
1351
1352
1353
1354
1355
1356
1357static void change_port_settings(struct tty_struct *tty,
1358 struct moschip_port *mos7720_port,
1359 struct ktermios *old_termios)
1360{
1361 struct usb_serial_port *port;
1362 struct usb_serial *serial;
1363 int baud;
1364 unsigned cflag;
1365 __u8 lData;
1366 __u8 lParity;
1367 __u8 lStop;
1368 int status;
1369 int port_number;
1370
1371 if (mos7720_port == NULL)
1372 return ;
1373
1374 port = mos7720_port->port;
1375 serial = port->serial;
1376 port_number = port->port_number;
1377
1378 if (!mos7720_port->open) {
1379 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1380 return;
1381 }
1382
1383 lData = UART_LCR_WLEN8;
1384 lStop = 0x00;
1385 lParity = 0x00;
1386
1387 cflag = tty->termios.c_cflag;
1388
1389
1390 switch (cflag & CSIZE) {
1391 case CS5:
1392 lData = UART_LCR_WLEN5;
1393 break;
1394
1395 case CS6:
1396 lData = UART_LCR_WLEN6;
1397 break;
1398
1399 case CS7:
1400 lData = UART_LCR_WLEN7;
1401 break;
1402 default:
1403 case CS8:
1404 lData = UART_LCR_WLEN8;
1405 break;
1406 }
1407
1408
1409 if (cflag & PARENB) {
1410 if (cflag & PARODD) {
1411 lParity = UART_LCR_PARITY;
1412 dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
1413 } else {
1414 lParity = (UART_LCR_EPAR | UART_LCR_PARITY);
1415 dev_dbg(&port->dev, "%s - parity = even\n", __func__);
1416 }
1417
1418 } else {
1419 dev_dbg(&port->dev, "%s - parity = none\n", __func__);
1420 }
1421
1422 if (cflag & CMSPAR)
1423 lParity = lParity | 0x20;
1424
1425
1426 if (cflag & CSTOPB) {
1427 lStop = UART_LCR_STOP;
1428 dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
1429 } else {
1430 lStop = 0x00;
1431 dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
1432 }
1433
1434#define LCR_BITS_MASK 0x03
1435#define LCR_STOP_MASK 0x04
1436#define LCR_PAR_MASK 0x38
1437
1438
1439 mos7720_port->shadowLCR &=
1440 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1441 mos7720_port->shadowLCR |= (lData | lParity | lStop);
1442
1443
1444
1445 write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
1446 write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
1447 write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
1448
1449
1450 write_mos_reg(serial, port_number, MOS7720_LCR,
1451 mos7720_port->shadowLCR);
1452 mos7720_port->shadowMCR = 0x0b;
1453 write_mos_reg(serial, port_number, MOS7720_MCR,
1454 mos7720_port->shadowMCR);
1455
1456
1457 mos7720_port->shadowMCR = UART_MCR_OUT2;
1458 if (cflag & CBAUD)
1459 mos7720_port->shadowMCR |= (UART_MCR_DTR | UART_MCR_RTS);
1460
1461 if (cflag & CRTSCTS) {
1462 mos7720_port->shadowMCR |= (UART_MCR_XONANY);
1463
1464
1465 if (port_number)
1466 write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG,
1467 0x01);
1468 else
1469 write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG,
1470 0x02);
1471
1472 } else
1473 mos7720_port->shadowMCR &= ~(UART_MCR_XONANY);
1474
1475 write_mos_reg(serial, port_number, MOS7720_MCR,
1476 mos7720_port->shadowMCR);
1477
1478
1479 baud = tty_get_baud_rate(tty);
1480 if (!baud) {
1481
1482 dev_dbg(&port->dev, "Picked default baud...\n");
1483 baud = 9600;
1484 }
1485
1486 if (baud >= 230400) {
1487 set_higher_rates(mos7720_port, baud);
1488
1489 write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
1490 return;
1491 }
1492
1493 dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
1494 status = send_cmd_write_baud_rate(mos7720_port, baud);
1495
1496
1497 if (cflag & CBAUD)
1498 tty_encode_baud_rate(tty, baud, baud);
1499
1500 write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
1501
1502 if (port->read_urb->status != -EINPROGRESS) {
1503 status = usb_submit_urb(port->read_urb, GFP_KERNEL);
1504 if (status)
1505 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
1506 }
1507}
1508
1509
1510
1511
1512
1513
1514static void mos7720_set_termios(struct tty_struct *tty,
1515 struct usb_serial_port *port, struct ktermios *old_termios)
1516{
1517 int status;
1518 struct moschip_port *mos7720_port;
1519
1520 mos7720_port = usb_get_serial_port_data(port);
1521
1522 if (mos7720_port == NULL)
1523 return;
1524
1525 if (!mos7720_port->open) {
1526 dev_dbg(&port->dev, "%s - port not opened\n", __func__);
1527 return;
1528 }
1529
1530
1531 change_port_settings(tty, mos7720_port, old_termios);
1532
1533 if (port->read_urb->status != -EINPROGRESS) {
1534 status = usb_submit_urb(port->read_urb, GFP_KERNEL);
1535 if (status)
1536 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
1537 }
1538}
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550static int get_lsr_info(struct tty_struct *tty,
1551 struct moschip_port *mos7720_port, unsigned int __user *value)
1552{
1553 struct usb_serial_port *port = tty->driver_data;
1554 unsigned int result = 0;
1555 unsigned char data = 0;
1556 int port_number = port->port_number;
1557 int count;
1558
1559 count = mos7720_chars_in_buffer(tty);
1560 if (count == 0) {
1561 read_mos_reg(port->serial, port_number, MOS7720_LSR, &data);
1562 if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
1563 == (UART_LSR_TEMT | UART_LSR_THRE)) {
1564 dev_dbg(&port->dev, "%s -- Empty\n", __func__);
1565 result = TIOCSER_TEMT;
1566 }
1567 }
1568 if (copy_to_user(value, &result, sizeof(int)))
1569 return -EFAULT;
1570 return 0;
1571}
1572
1573static int mos7720_tiocmget(struct tty_struct *tty)
1574{
1575 struct usb_serial_port *port = tty->driver_data;
1576 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1577 unsigned int result = 0;
1578 unsigned int mcr ;
1579 unsigned int msr ;
1580
1581 mcr = mos7720_port->shadowMCR;
1582 msr = mos7720_port->shadowMSR;
1583
1584 result = ((mcr & UART_MCR_DTR) ? TIOCM_DTR : 0)
1585 | ((mcr & UART_MCR_RTS) ? TIOCM_RTS : 0)
1586 | ((msr & UART_MSR_CTS) ? TIOCM_CTS : 0)
1587 | ((msr & UART_MSR_DCD) ? TIOCM_CAR : 0)
1588 | ((msr & UART_MSR_RI) ? TIOCM_RI : 0)
1589 | ((msr & UART_MSR_DSR) ? TIOCM_DSR : 0);
1590
1591 return result;
1592}
1593
1594static int mos7720_tiocmset(struct tty_struct *tty,
1595 unsigned int set, unsigned int clear)
1596{
1597 struct usb_serial_port *port = tty->driver_data;
1598 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1599 unsigned int mcr ;
1600
1601 mcr = mos7720_port->shadowMCR;
1602
1603 if (set & TIOCM_RTS)
1604 mcr |= UART_MCR_RTS;
1605 if (set & TIOCM_DTR)
1606 mcr |= UART_MCR_DTR;
1607 if (set & TIOCM_LOOP)
1608 mcr |= UART_MCR_LOOP;
1609
1610 if (clear & TIOCM_RTS)
1611 mcr &= ~UART_MCR_RTS;
1612 if (clear & TIOCM_DTR)
1613 mcr &= ~UART_MCR_DTR;
1614 if (clear & TIOCM_LOOP)
1615 mcr &= ~UART_MCR_LOOP;
1616
1617 mos7720_port->shadowMCR = mcr;
1618 write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
1619 mos7720_port->shadowMCR);
1620
1621 return 0;
1622}
1623
1624static int mos7720_ioctl(struct tty_struct *tty,
1625 unsigned int cmd, unsigned long arg)
1626{
1627 struct usb_serial_port *port = tty->driver_data;
1628 struct moschip_port *mos7720_port;
1629
1630 mos7720_port = usb_get_serial_port_data(port);
1631 if (mos7720_port == NULL)
1632 return -ENODEV;
1633
1634 switch (cmd) {
1635 case TIOCSERGETLSR:
1636 dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
1637 return get_lsr_info(tty, mos7720_port,
1638 (unsigned int __user *)arg);
1639 }
1640
1641 return -ENOIOCTLCMD;
1642}
1643
1644static int mos7720_startup(struct usb_serial *serial)
1645{
1646 struct usb_device *dev;
1647 char data;
1648 u16 product;
1649 int ret_val;
1650
1651 product = le16_to_cpu(serial->dev->descriptor.idProduct);
1652 dev = serial->dev;
1653
1654 if (product == MOSCHIP_DEVICE_ID_7715) {
1655 struct urb *urb = serial->port[0]->interrupt_in_urb;
1656
1657 urb->complete = mos7715_interrupt_callback;
1658
1659#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
1660 ret_val = mos7715_parport_init(serial);
1661 if (ret_val < 0)
1662 return ret_val;
1663#endif
1664 }
1665
1666 ret_val = usb_submit_urb(serial->port[0]->interrupt_in_urb, GFP_KERNEL);
1667 if (ret_val) {
1668 dev_err(&dev->dev, "failed to submit interrupt urb: %d\n",
1669 ret_val);
1670 }
1671
1672
1673 read_mos_reg(serial, 0, MOS7720_LSR, &data);
1674 dev_dbg(&dev->dev, "LSR:%x\n", data);
1675
1676 return 0;
1677}
1678
1679static void mos7720_release(struct usb_serial *serial)
1680{
1681 usb_kill_urb(serial->port[0]->interrupt_in_urb);
1682
1683#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
1684
1685
1686 if (le16_to_cpu(serial->dev->descriptor.idProduct)
1687 == MOSCHIP_DEVICE_ID_7715) {
1688 struct mos7715_parport *mos_parport =
1689 usb_get_serial_data(serial);
1690
1691
1692 spin_lock(&release_lock);
1693 mos_parport->pp->private_data = NULL;
1694 spin_unlock(&release_lock);
1695
1696
1697 if (mos_parport->msg_pending)
1698 wait_for_completion_timeout(&mos_parport->syncmsg_compl,
1699 msecs_to_jiffies(MOS_WDR_TIMEOUT));
1700
1701
1702
1703
1704
1705 cancel_work_sync(&mos_parport->work);
1706
1707 parport_remove_port(mos_parport->pp);
1708 usb_set_serial_data(serial, NULL);
1709 mos_parport->serial = NULL;
1710
1711 parport_del_port(mos_parport->pp);
1712
1713 kref_put(&mos_parport->ref_count, destroy_mos_parport);
1714 }
1715#endif
1716}
1717
1718static int mos7720_port_probe(struct usb_serial_port *port)
1719{
1720 struct moschip_port *mos7720_port;
1721
1722 mos7720_port = kzalloc(sizeof(*mos7720_port), GFP_KERNEL);
1723 if (!mos7720_port)
1724 return -ENOMEM;
1725
1726 mos7720_port->port = port;
1727
1728 usb_set_serial_port_data(port, mos7720_port);
1729
1730 return 0;
1731}
1732
1733static void mos7720_port_remove(struct usb_serial_port *port)
1734{
1735 struct moschip_port *mos7720_port;
1736
1737 mos7720_port = usb_get_serial_port_data(port);
1738 kfree(mos7720_port);
1739}
1740
1741static struct usb_serial_driver moschip7720_2port_driver = {
1742 .driver = {
1743 .owner = THIS_MODULE,
1744 .name = "moschip7720",
1745 },
1746 .description = "Moschip 2 port adapter",
1747 .id_table = id_table,
1748 .num_bulk_in = 2,
1749 .num_bulk_out = 2,
1750 .num_interrupt_in = 1,
1751 .calc_num_ports = mos77xx_calc_num_ports,
1752 .open = mos7720_open,
1753 .close = mos7720_close,
1754 .throttle = mos7720_throttle,
1755 .unthrottle = mos7720_unthrottle,
1756 .attach = mos7720_startup,
1757 .release = mos7720_release,
1758 .port_probe = mos7720_port_probe,
1759 .port_remove = mos7720_port_remove,
1760 .ioctl = mos7720_ioctl,
1761 .tiocmget = mos7720_tiocmget,
1762 .tiocmset = mos7720_tiocmset,
1763 .set_termios = mos7720_set_termios,
1764 .write = mos7720_write,
1765 .write_room = mos7720_write_room,
1766 .chars_in_buffer = mos7720_chars_in_buffer,
1767 .break_ctl = mos7720_break,
1768 .read_bulk_callback = mos7720_bulk_in_callback,
1769 .read_int_callback = mos7720_interrupt_callback,
1770};
1771
1772static struct usb_serial_driver * const serial_drivers[] = {
1773 &moschip7720_2port_driver, NULL
1774};
1775
1776module_usb_serial_driver(serial_drivers, id_table);
1777
1778MODULE_AUTHOR(DRIVER_AUTHOR);
1779MODULE_DESCRIPTION(DRIVER_DESC);
1780MODULE_LICENSE("GPL v2");
1781