1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/kernel.h>
24#include <linux/errno.h>
25#include <linux/init.h>
26#include <linux/slab.h>
27#include <linux/tty.h>
28#include <linux/tty_driver.h>
29#include <linux/tty_flip.h>
30#include <linux/module.h>
31#include <linux/spinlock.h>
32#include <linux/serial.h>
33#include <linux/serial_reg.h>
34#include <linux/usb.h>
35#include <linux/usb/serial.h>
36#include <linux/uaccess.h>
37#include <linux/parport.h>
38
39
40
41
42#define DRIVER_VERSION "2.1"
43#define DRIVER_AUTHOR "Aspire Communications pvt Ltd."
44#define DRIVER_DESC "Moschip USB Serial Driver"
45
46
47#define MOS_WDR_TIMEOUT (HZ * 5)
48
49#define MOS_MAX_PORT 0x02
50#define MOS_WRITE 0x0E
51#define MOS_READ 0x0D
52
53
54#define SERIAL_IIR_RLS 0x06
55#define SERIAL_IIR_RDA 0x04
56#define SERIAL_IIR_CTI 0x0c
57#define SERIAL_IIR_THR 0x02
58#define SERIAL_IIR_MS 0x00
59
60#define NUM_URBS 16
61#define URB_TRANSFER_BUFFER_SIZE 32
62
63
64struct moschip_port {
65 __u8 shadowLCR;
66 __u8 shadowMCR;
67 __u8 shadowMSR;
68 char open;
69 struct async_icount icount;
70 struct usb_serial_port *port;
71 struct urb *write_urb_pool[NUM_URBS];
72};
73
74static bool debug;
75
76static struct usb_serial_driver moschip7720_2port_driver;
77
78#define USB_VENDOR_ID_MOSCHIP 0x9710
79#define MOSCHIP_DEVICE_ID_7720 0x7720
80#define MOSCHIP_DEVICE_ID_7715 0x7715
81
82static const struct usb_device_id id_table[] = {
83 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
84 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7715) },
85 { }
86};
87MODULE_DEVICE_TABLE(usb, id_table);
88
89#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
90
91
92#define DCR_INIT_VAL 0x0c
93#define ECR_INIT_VAL 0x00
94
95struct urbtracker {
96 struct mos7715_parport *mos_parport;
97 struct list_head urblist_entry;
98 struct kref ref_count;
99 struct urb *urb;
100};
101
102enum mos7715_pp_modes {
103 SPP = 0<<5,
104 PS2 = 1<<5,
105 PPF = 2<<5,
106};
107
108struct mos7715_parport {
109 struct parport *pp;
110 struct kref ref_count;
111 struct list_head deferred_urbs;
112 struct list_head active_urbs;
113 spinlock_t listlock;
114 bool msg_pending;
115 struct completion syncmsg_compl;
116 struct tasklet_struct urb_tasklet;
117 struct usb_serial *serial;
118 __u8 shadowECR;
119 __u8 shadowDCR;
120 atomic_t shadowDSR;
121};
122
123
124static DEFINE_SPINLOCK(release_lock);
125
126#endif
127
128static const unsigned int dummy;
129
130enum mos_regs {
131 THR,
132 RHR,
133 IER,
134 FCR,
135 ISR,
136 LCR,
137 MCR,
138 LSR,
139 MSR,
140 SPR,
141 DLL,
142 DLM,
143 DPR,
144 DSR,
145 DCR,
146 ECR,
147 SP1_REG,
148 SP2_REG,
149 PP_REG,
150 SP_CONTROL_REG,
151};
152
153
154
155
156
157static inline __u16 get_reg_index(enum mos_regs reg)
158{
159 static const __u16 mos7715_index_lookup_table[] = {
160 0x00,
161 0x00,
162 0x01,
163 0x02,
164 0x02,
165 0x03,
166 0x04,
167 0x05,
168 0x06,
169 0x07,
170 0x00,
171 0x01,
172 0x00,
173 0x01,
174 0x02,
175 0x0a,
176 0x01,
177 0x02,
178 0x04,
179 0x08,
180 };
181 return mos7715_index_lookup_table[reg];
182}
183
184
185
186
187
188static inline __u16 get_reg_value(enum mos_regs reg,
189 unsigned int serial_portnum)
190{
191 if (reg >= SP1_REG)
192 return 0x0000;
193
194 else if (reg >= DPR)
195 return 0x0100;
196
197 else
198 return (serial_portnum + 2) << 8;
199}
200
201
202
203
204
205
206static int write_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
207 enum mos_regs reg, __u8 data)
208{
209 struct usb_device *usbdev = serial->dev;
210 unsigned int pipe = usb_sndctrlpipe(usbdev, 0);
211 __u8 request = (__u8)0x0e;
212 __u8 requesttype = (__u8)0x40;
213 __u16 index = get_reg_index(reg);
214 __u16 value = get_reg_value(reg, serial_portnum) + data;
215 int status = usb_control_msg(usbdev, pipe, request, requesttype, value,
216 index, NULL, 0, MOS_WDR_TIMEOUT);
217 if (status < 0)
218 dev_err(&usbdev->dev,
219 "mos7720: usb_control_msg() failed: %d", status);
220 return status;
221}
222
223
224
225
226
227
228static int read_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
229 enum mos_regs reg, __u8 *data)
230{
231 struct usb_device *usbdev = serial->dev;
232 unsigned int pipe = usb_rcvctrlpipe(usbdev, 0);
233 __u8 request = (__u8)0x0d;
234 __u8 requesttype = (__u8)0xc0;
235 __u16 index = get_reg_index(reg);
236 __u16 value = get_reg_value(reg, serial_portnum);
237 int status = usb_control_msg(usbdev, pipe, request, requesttype, value,
238 index, data, 1, MOS_WDR_TIMEOUT);
239 if (status < 0)
240 dev_err(&usbdev->dev,
241 "mos7720: usb_control_msg() failed: %d", status);
242 return status;
243}
244
245#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
246
247static inline int mos7715_change_mode(struct mos7715_parport *mos_parport,
248 enum mos7715_pp_modes mode)
249{
250 mos_parport->shadowECR = mode;
251 write_mos_reg(mos_parport->serial, dummy, ECR, mos_parport->shadowECR);
252 return 0;
253}
254
255static void destroy_mos_parport(struct kref *kref)
256{
257 struct mos7715_parport *mos_parport =
258 container_of(kref, struct mos7715_parport, ref_count);
259
260 kfree(mos_parport);
261}
262
263static void destroy_urbtracker(struct kref *kref)
264{
265 struct urbtracker *urbtrack =
266 container_of(kref, struct urbtracker, ref_count);
267 struct mos7715_parport *mos_parport = urbtrack->mos_parport;
268
269 usb_free_urb(urbtrack->urb);
270 kfree(urbtrack);
271 kref_put(&mos_parport->ref_count, destroy_mos_parport);
272}
273
274
275
276
277
278
279static void send_deferred_urbs(unsigned long _mos_parport)
280{
281 int ret_val;
282 unsigned long flags;
283 struct mos7715_parport *mos_parport = (void *)_mos_parport;
284 struct urbtracker *urbtrack;
285 struct list_head *cursor, *next;
286
287
288 if (unlikely(mos_parport->serial == NULL))
289 return;
290
291
292 if (!mutex_trylock(&mos_parport->serial->disc_mutex)) {
293 dbg("%s: rescheduling tasklet", __func__);
294 tasklet_schedule(&mos_parport->urb_tasklet);
295 return;
296 }
297
298
299 if (unlikely(mos_parport->serial->disconnected)) {
300 mutex_unlock(&mos_parport->serial->disc_mutex);
301 return;
302 }
303
304 spin_lock_irqsave(&mos_parport->listlock, flags);
305 if (list_empty(&mos_parport->deferred_urbs)) {
306 spin_unlock_irqrestore(&mos_parport->listlock, flags);
307 mutex_unlock(&mos_parport->serial->disc_mutex);
308 dbg("%s: deferred_urbs list empty", __func__);
309 return;
310 }
311
312
313 list_for_each_safe(cursor, next, &mos_parport->deferred_urbs)
314 list_move_tail(cursor, &mos_parport->active_urbs);
315 list_for_each_entry(urbtrack, &mos_parport->active_urbs,
316 urblist_entry) {
317 ret_val = usb_submit_urb(urbtrack->urb, GFP_ATOMIC);
318 dbg("%s: urb submitted", __func__);
319 if (ret_val) {
320 dev_err(&mos_parport->serial->dev->dev,
321 "usb_submit_urb() failed: %d", ret_val);
322 list_del(&urbtrack->urblist_entry);
323 kref_put(&urbtrack->ref_count, destroy_urbtracker);
324 }
325 }
326 spin_unlock_irqrestore(&mos_parport->listlock, flags);
327 mutex_unlock(&mos_parport->serial->disc_mutex);
328}
329
330
331static void async_complete(struct urb *urb)
332{
333 struct urbtracker *urbtrack = urb->context;
334 int status = urb->status;
335
336 if (unlikely(status))
337 dbg("%s - nonzero urb status received: %d", __func__, status);
338
339
340 spin_lock(&urbtrack->mos_parport->listlock);
341 list_del(&urbtrack->urblist_entry);
342 spin_unlock(&urbtrack->mos_parport->listlock);
343 kref_put(&urbtrack->ref_count, destroy_urbtracker);
344}
345
346static int write_parport_reg_nonblock(struct mos7715_parport *mos_parport,
347 enum mos_regs reg, __u8 data)
348{
349 struct urbtracker *urbtrack;
350 int ret_val;
351 unsigned long flags;
352 struct usb_ctrlrequest setup;
353 struct usb_serial *serial = mos_parport->serial;
354 struct usb_device *usbdev = serial->dev;
355
356
357 urbtrack = kmalloc(sizeof(struct urbtracker), GFP_ATOMIC);
358 if (urbtrack == NULL) {
359 dev_err(&usbdev->dev, "out of memory");
360 return -ENOMEM;
361 }
362 kref_get(&mos_parport->ref_count);
363 urbtrack->mos_parport = mos_parport;
364 urbtrack->urb = usb_alloc_urb(0, GFP_ATOMIC);
365 if (urbtrack->urb == NULL) {
366 dev_err(&usbdev->dev, "out of urbs");
367 kfree(urbtrack);
368 return -ENOMEM;
369 }
370 setup.bRequestType = (__u8)0x40;
371 setup.bRequest = (__u8)0x0e;
372 setup.wValue = get_reg_value(reg, dummy);
373 setup.wIndex = get_reg_index(reg);
374 setup.wLength = 0;
375 usb_fill_control_urb(urbtrack->urb, usbdev,
376 usb_sndctrlpipe(usbdev, 0),
377 (unsigned char *)&setup,
378 NULL, 0, async_complete, urbtrack);
379 kref_init(&urbtrack->ref_count);
380 INIT_LIST_HEAD(&urbtrack->urblist_entry);
381
382
383
384
385
386 if (!mutex_trylock(&serial->disc_mutex)) {
387 spin_lock_irqsave(&mos_parport->listlock, flags);
388 list_add_tail(&urbtrack->urblist_entry,
389 &mos_parport->deferred_urbs);
390 spin_unlock_irqrestore(&mos_parport->listlock, flags);
391 tasklet_schedule(&mos_parport->urb_tasklet);
392 dbg("tasklet scheduled");
393 return 0;
394 }
395
396
397 if (serial->disconnected) {
398 kref_put(&urbtrack->ref_count, destroy_urbtracker);
399 mutex_unlock(&serial->disc_mutex);
400 return -ENODEV;
401 }
402
403
404 spin_lock_irqsave(&mos_parport->listlock, flags);
405 list_add_tail(&urbtrack->urblist_entry, &mos_parport->active_urbs);
406 spin_unlock_irqrestore(&mos_parport->listlock, flags);
407 ret_val = usb_submit_urb(urbtrack->urb, GFP_ATOMIC);
408 mutex_unlock(&serial->disc_mutex);
409 if (ret_val) {
410 dev_err(&usbdev->dev,
411 "%s: submit_urb() failed: %d", __func__, ret_val);
412 spin_lock_irqsave(&mos_parport->listlock, flags);
413 list_del(&urbtrack->urblist_entry);
414 spin_unlock_irqrestore(&mos_parport->listlock, flags);
415 kref_put(&urbtrack->ref_count, destroy_urbtracker);
416 return ret_val;
417 }
418 return 0;
419}
420
421
422
423
424
425
426
427
428
429
430
431
432
433static int parport_prologue(struct parport *pp)
434{
435 struct mos7715_parport *mos_parport;
436
437 spin_lock(&release_lock);
438 mos_parport = pp->private_data;
439 if (unlikely(mos_parport == NULL)) {
440
441 spin_unlock(&release_lock);
442 return -1;
443 }
444 mos_parport->msg_pending = true;
445 INIT_COMPLETION(mos_parport->syncmsg_compl);
446 spin_unlock(&release_lock);
447
448 mutex_lock(&mos_parport->serial->disc_mutex);
449 if (mos_parport->serial->disconnected) {
450
451 mutex_unlock(&mos_parport->serial->disc_mutex);
452 mos_parport->msg_pending = false;
453 complete(&mos_parport->syncmsg_compl);
454 return -1;
455 }
456
457 return 0;
458}
459
460
461
462
463
464static inline void parport_epilogue(struct parport *pp)
465{
466 struct mos7715_parport *mos_parport = pp->private_data;
467 mutex_unlock(&mos_parport->serial->disc_mutex);
468 mos_parport->msg_pending = false;
469 complete(&mos_parport->syncmsg_compl);
470}
471
472static void parport_mos7715_write_data(struct parport *pp, unsigned char d)
473{
474 struct mos7715_parport *mos_parport = pp->private_data;
475
476 if (parport_prologue(pp) < 0)
477 return;
478 mos7715_change_mode(mos_parport, SPP);
479 write_mos_reg(mos_parport->serial, dummy, DPR, (__u8)d);
480 parport_epilogue(pp);
481}
482
483static unsigned char parport_mos7715_read_data(struct parport *pp)
484{
485 struct mos7715_parport *mos_parport = pp->private_data;
486 unsigned char d;
487
488 if (parport_prologue(pp) < 0)
489 return 0;
490 read_mos_reg(mos_parport->serial, dummy, DPR, &d);
491 parport_epilogue(pp);
492 return d;
493}
494
495static void parport_mos7715_write_control(struct parport *pp, unsigned char d)
496{
497 struct mos7715_parport *mos_parport = pp->private_data;
498 __u8 data;
499
500 if (parport_prologue(pp) < 0)
501 return;
502 data = ((__u8)d & 0x0f) | (mos_parport->shadowDCR & 0xf0);
503 write_mos_reg(mos_parport->serial, dummy, DCR, data);
504 mos_parport->shadowDCR = data;
505 parport_epilogue(pp);
506}
507
508static unsigned char parport_mos7715_read_control(struct parport *pp)
509{
510 struct mos7715_parport *mos_parport = pp->private_data;
511 __u8 dcr;
512
513 spin_lock(&release_lock);
514 mos_parport = pp->private_data;
515 if (unlikely(mos_parport == NULL)) {
516 spin_unlock(&release_lock);
517 return 0;
518 }
519 dcr = mos_parport->shadowDCR & 0x0f;
520 spin_unlock(&release_lock);
521 return dcr;
522}
523
524static unsigned char parport_mos7715_frob_control(struct parport *pp,
525 unsigned char mask,
526 unsigned char val)
527{
528 struct mos7715_parport *mos_parport = pp->private_data;
529 __u8 dcr;
530
531 mask &= 0x0f;
532 val &= 0x0f;
533 if (parport_prologue(pp) < 0)
534 return 0;
535 mos_parport->shadowDCR = (mos_parport->shadowDCR & (~mask)) ^ val;
536 write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
537 dcr = mos_parport->shadowDCR & 0x0f;
538 parport_epilogue(pp);
539 return dcr;
540}
541
542static unsigned char parport_mos7715_read_status(struct parport *pp)
543{
544 unsigned char status;
545 struct mos7715_parport *mos_parport = pp->private_data;
546
547 spin_lock(&release_lock);
548 mos_parport = pp->private_data;
549 if (unlikely(mos_parport == NULL)) {
550 spin_unlock(&release_lock);
551 return 0;
552 }
553 status = atomic_read(&mos_parport->shadowDSR) & 0xf8;
554 spin_unlock(&release_lock);
555 return status;
556}
557
558static void parport_mos7715_enable_irq(struct parport *pp)
559{
560}
561
562static void parport_mos7715_disable_irq(struct parport *pp)
563{
564}
565
566static void parport_mos7715_data_forward(struct parport *pp)
567{
568 struct mos7715_parport *mos_parport = pp->private_data;
569
570 if (parport_prologue(pp) < 0)
571 return;
572 mos7715_change_mode(mos_parport, PS2);
573 mos_parport->shadowDCR &= ~0x20;
574 write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
575 parport_epilogue(pp);
576}
577
578static void parport_mos7715_data_reverse(struct parport *pp)
579{
580 struct mos7715_parport *mos_parport = pp->private_data;
581
582 if (parport_prologue(pp) < 0)
583 return;
584 mos7715_change_mode(mos_parport, PS2);
585 mos_parport->shadowDCR |= 0x20;
586 write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
587 parport_epilogue(pp);
588}
589
590static void parport_mos7715_init_state(struct pardevice *dev,
591 struct parport_state *s)
592{
593 s->u.pc.ctr = DCR_INIT_VAL;
594 s->u.pc.ecr = ECR_INIT_VAL;
595}
596
597
598static void parport_mos7715_save_state(struct parport *pp,
599 struct parport_state *s)
600{
601 struct mos7715_parport *mos_parport;
602
603 spin_lock(&release_lock);
604 mos_parport = pp->private_data;
605 if (unlikely(mos_parport == NULL)) {
606 spin_unlock(&release_lock);
607 return;
608 }
609 s->u.pc.ctr = mos_parport->shadowDCR;
610 s->u.pc.ecr = mos_parport->shadowECR;
611 spin_unlock(&release_lock);
612}
613
614
615static void parport_mos7715_restore_state(struct parport *pp,
616 struct parport_state *s)
617{
618 struct mos7715_parport *mos_parport;
619
620 spin_lock(&release_lock);
621 mos_parport = pp->private_data;
622 if (unlikely(mos_parport == NULL)) {
623 spin_unlock(&release_lock);
624 return;
625 }
626 write_parport_reg_nonblock(mos_parport, DCR, mos_parport->shadowDCR);
627 write_parport_reg_nonblock(mos_parport, ECR, mos_parport->shadowECR);
628 spin_unlock(&release_lock);
629}
630
631static size_t parport_mos7715_write_compat(struct parport *pp,
632 const void *buffer,
633 size_t len, int flags)
634{
635 int retval;
636 struct mos7715_parport *mos_parport = pp->private_data;
637 int actual_len;
638
639 if (parport_prologue(pp) < 0)
640 return 0;
641 mos7715_change_mode(mos_parport, PPF);
642 retval = usb_bulk_msg(mos_parport->serial->dev,
643 usb_sndbulkpipe(mos_parport->serial->dev, 2),
644 (void *)buffer, len, &actual_len,
645 MOS_WDR_TIMEOUT);
646 parport_epilogue(pp);
647 if (retval) {
648 dev_err(&mos_parport->serial->dev->dev,
649 "mos7720: usb_bulk_msg() failed: %d", retval);
650 return 0;
651 }
652 return actual_len;
653}
654
655static struct parport_operations parport_mos7715_ops = {
656 .owner = THIS_MODULE,
657 .write_data = parport_mos7715_write_data,
658 .read_data = parport_mos7715_read_data,
659
660 .write_control = parport_mos7715_write_control,
661 .read_control = parport_mos7715_read_control,
662 .frob_control = parport_mos7715_frob_control,
663
664 .read_status = parport_mos7715_read_status,
665
666 .enable_irq = parport_mos7715_enable_irq,
667 .disable_irq = parport_mos7715_disable_irq,
668
669 .data_forward = parport_mos7715_data_forward,
670 .data_reverse = parport_mos7715_data_reverse,
671
672 .init_state = parport_mos7715_init_state,
673 .save_state = parport_mos7715_save_state,
674 .restore_state = parport_mos7715_restore_state,
675
676 .compat_write_data = parport_mos7715_write_compat,
677
678 .nibble_read_data = parport_ieee1284_read_nibble,
679 .byte_read_data = parport_ieee1284_read_byte,
680};
681
682
683
684
685
686static int mos7715_parport_init(struct usb_serial *serial)
687{
688 struct mos7715_parport *mos_parport;
689
690
691 mos_parport = kzalloc(sizeof(struct mos7715_parport), GFP_KERNEL);
692 if (mos_parport == NULL) {
693 dbg("mos7715_parport_init: kzalloc failed");
694 return -ENOMEM;
695 }
696 mos_parport->msg_pending = false;
697 kref_init(&mos_parport->ref_count);
698 spin_lock_init(&mos_parport->listlock);
699 INIT_LIST_HEAD(&mos_parport->active_urbs);
700 INIT_LIST_HEAD(&mos_parport->deferred_urbs);
701 usb_set_serial_data(serial, mos_parport);
702 mos_parport->serial = serial;
703 tasklet_init(&mos_parport->urb_tasklet, send_deferred_urbs,
704 (unsigned long) mos_parport);
705 init_completion(&mos_parport->syncmsg_compl);
706
707
708 write_mos_reg(mos_parport->serial, dummy, PP_REG, (__u8)0x80);
709 write_mos_reg(mos_parport->serial, dummy, PP_REG, (__u8)0x00);
710
711
712 mos_parport->shadowDCR = DCR_INIT_VAL;
713 write_mos_reg(mos_parport->serial, dummy, DCR, mos_parport->shadowDCR);
714 mos_parport->shadowECR = ECR_INIT_VAL;
715 write_mos_reg(mos_parport->serial, dummy, ECR, mos_parport->shadowECR);
716
717
718 mos_parport->pp = parport_register_port(0, PARPORT_IRQ_NONE,
719 PARPORT_DMA_NONE,
720 &parport_mos7715_ops);
721 if (mos_parport->pp == NULL) {
722 dev_err(&serial->interface->dev,
723 "Could not register parport\n");
724 kref_put(&mos_parport->ref_count, destroy_mos_parport);
725 return -EIO;
726 }
727 mos_parport->pp->private_data = mos_parport;
728 mos_parport->pp->modes = PARPORT_MODE_COMPAT | PARPORT_MODE_PCSPP;
729 mos_parport->pp->dev = &serial->interface->dev;
730 parport_announce_port(mos_parport->pp);
731
732 return 0;
733}
734#endif
735
736
737
738
739
740
741static void mos7720_interrupt_callback(struct urb *urb)
742{
743 int result;
744 int length;
745 int status = urb->status;
746 __u8 *data;
747 __u8 sp1;
748 __u8 sp2;
749
750 switch (status) {
751 case 0:
752
753 break;
754 case -ECONNRESET:
755 case -ENOENT:
756 case -ESHUTDOWN:
757
758 dbg("%s - urb shutting down with status: %d", __func__,
759 status);
760 return;
761 default:
762 dbg("%s - nonzero urb status received: %d", __func__,
763 status);
764 goto exit;
765 }
766
767 length = urb->actual_length;
768 data = urb->transfer_buffer;
769
770
771
772
773
774
775
776
777
778
779 if (unlikely(length != 4)) {
780 dbg("Wrong data !!!");
781 return;
782 }
783
784 sp1 = data[3];
785 sp2 = data[2];
786
787 if ((sp1 | sp2) & 0x01) {
788
789 dbg("No Interrupt !!!");
790 } else {
791 switch (sp1 & 0x0f) {
792 case SERIAL_IIR_RLS:
793 dbg("Serial Port 1: Receiver status error or address "
794 "bit detected in 9-bit mode\n");
795 break;
796 case SERIAL_IIR_CTI:
797 dbg("Serial Port 1: Receiver time out");
798 break;
799 case SERIAL_IIR_MS:
800
801 break;
802 }
803
804 switch (sp2 & 0x0f) {
805 case SERIAL_IIR_RLS:
806 dbg("Serial Port 2: Receiver status error or address "
807 "bit detected in 9-bit mode");
808 break;
809 case SERIAL_IIR_CTI:
810 dbg("Serial Port 2: Receiver time out");
811 break;
812 case SERIAL_IIR_MS:
813
814 break;
815 }
816 }
817
818exit:
819 result = usb_submit_urb(urb, GFP_ATOMIC);
820 if (result)
821 dev_err(&urb->dev->dev,
822 "%s - Error %d submitting control urb\n",
823 __func__, result);
824}
825
826
827
828
829
830
831static void mos7715_interrupt_callback(struct urb *urb)
832{
833 int result;
834 int length;
835 int status = urb->status;
836 __u8 *data;
837 __u8 iir;
838
839 switch (status) {
840 case 0:
841
842 break;
843 case -ECONNRESET:
844 case -ENOENT:
845 case -ESHUTDOWN:
846 case -ENODEV:
847
848 dbg("%s - urb shutting down with status: %d", __func__,
849 status);
850 return;
851 default:
852 dbg("%s - nonzero urb status received: %d", __func__,
853 status);
854 goto exit;
855 }
856
857 length = urb->actual_length;
858 data = urb->transfer_buffer;
859
860
861
862
863
864
865
866 if (unlikely(length != 4)) {
867 dbg("Wrong data !!!");
868 return;
869 }
870
871 iir = data[0];
872 if (!(iir & 0x01)) {
873 switch (iir & 0x0f) {
874 case SERIAL_IIR_RLS:
875 dbg("Serial Port: Receiver status error or address "
876 "bit detected in 9-bit mode\n");
877 break;
878 case SERIAL_IIR_CTI:
879 dbg("Serial Port: Receiver time out");
880 break;
881 case SERIAL_IIR_MS:
882
883 break;
884 }
885 }
886
887#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
888 {
889 struct usb_serial_port *port = urb->context;
890 struct mos7715_parport *mos_parport = port->serial->private;
891 if (unlikely(mos_parport == NULL))
892 return;
893 atomic_set(&mos_parport->shadowDSR, data[2]);
894 }
895#endif
896
897exit:
898 result = usb_submit_urb(urb, GFP_ATOMIC);
899 if (result)
900 dev_err(&urb->dev->dev,
901 "%s - Error %d submitting control urb\n",
902 __func__, result);
903}
904
905
906
907
908
909
910static void mos7720_bulk_in_callback(struct urb *urb)
911{
912 int retval;
913 unsigned char *data ;
914 struct usb_serial_port *port;
915 struct tty_struct *tty;
916 int status = urb->status;
917
918 if (status) {
919 dbg("nonzero read bulk status received: %d", status);
920 return;
921 }
922
923 port = urb->context;
924
925 dbg("Entering...%s", __func__);
926
927 data = urb->transfer_buffer;
928
929 tty = tty_port_tty_get(&port->port);
930 if (tty && urb->actual_length) {
931 tty_insert_flip_string(tty, data, urb->actual_length);
932 tty_flip_buffer_push(tty);
933 }
934 tty_kref_put(tty);
935
936 if (port->read_urb->status != -EINPROGRESS) {
937 retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
938 if (retval)
939 dbg("usb_submit_urb(read bulk) failed, retval = %d",
940 retval);
941 }
942}
943
944
945
946
947
948
949static void mos7720_bulk_out_data_callback(struct urb *urb)
950{
951 struct moschip_port *mos7720_port;
952 struct tty_struct *tty;
953 int status = urb->status;
954
955 if (status) {
956 dbg("nonzero write bulk status received:%d", status);
957 return;
958 }
959
960 mos7720_port = urb->context;
961 if (!mos7720_port) {
962 dbg("NULL mos7720_port pointer");
963 return ;
964 }
965
966 tty = tty_port_tty_get(&mos7720_port->port->port);
967
968 if (tty && mos7720_port->open)
969 tty_wakeup(tty);
970 tty_kref_put(tty);
971}
972
973
974
975
976
977
978
979static int mos77xx_probe(struct usb_serial *serial,
980 const struct usb_device_id *id)
981{
982 if (id->idProduct == MOSCHIP_DEVICE_ID_7715)
983 moschip7720_2port_driver.read_int_callback =
984 mos7715_interrupt_callback;
985 else
986 moschip7720_2port_driver.read_int_callback =
987 mos7720_interrupt_callback;
988
989 return 0;
990}
991
992static int mos77xx_calc_num_ports(struct usb_serial *serial)
993{
994 u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
995 if (product == MOSCHIP_DEVICE_ID_7715)
996 return 1;
997
998 return 2;
999}
1000
1001static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
1002{
1003 struct usb_serial *serial;
1004 struct urb *urb;
1005 struct moschip_port *mos7720_port;
1006 int response;
1007 int port_number;
1008 __u8 data;
1009 int allocated_urbs = 0;
1010 int j;
1011
1012 serial = port->serial;
1013
1014 mos7720_port = usb_get_serial_port_data(port);
1015 if (mos7720_port == NULL)
1016 return -ENODEV;
1017
1018 usb_clear_halt(serial->dev, port->write_urb->pipe);
1019 usb_clear_halt(serial->dev, port->read_urb->pipe);
1020
1021
1022 for (j = 0; j < NUM_URBS; ++j) {
1023 urb = usb_alloc_urb(0, GFP_KERNEL);
1024 mos7720_port->write_urb_pool[j] = urb;
1025
1026 if (urb == NULL) {
1027 dev_err(&port->dev, "No more urbs???\n");
1028 continue;
1029 }
1030
1031 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
1032 GFP_KERNEL);
1033 if (!urb->transfer_buffer) {
1034 dev_err(&port->dev,
1035 "%s-out of memory for urb buffers.\n",
1036 __func__);
1037 usb_free_urb(mos7720_port->write_urb_pool[j]);
1038 mos7720_port->write_urb_pool[j] = NULL;
1039 continue;
1040 }
1041 allocated_urbs++;
1042 }
1043
1044 if (!allocated_urbs)
1045 return -ENOMEM;
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061 port_number = port->number - port->serial->minor;
1062 read_mos_reg(serial, port_number, LSR, &data);
1063
1064 dbg("SS::%p LSR:%x", mos7720_port, data);
1065
1066 dbg("Check:Sending Command ..........");
1067
1068 write_mos_reg(serial, dummy, SP1_REG, 0x02);
1069 write_mos_reg(serial, dummy, SP2_REG, 0x02);
1070
1071 write_mos_reg(serial, port_number, IER, 0x00);
1072 write_mos_reg(serial, port_number, FCR, 0x00);
1073
1074 write_mos_reg(serial, port_number, FCR, 0xcf);
1075 mos7720_port->shadowLCR = 0x03;
1076 write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
1077 mos7720_port->shadowMCR = 0x0b;
1078 write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1079
1080 write_mos_reg(serial, port_number, SP_CONTROL_REG, 0x00);
1081 read_mos_reg(serial, dummy, SP_CONTROL_REG, &data);
1082 data = data | (port->number - port->serial->minor + 1);
1083 write_mos_reg(serial, dummy, SP_CONTROL_REG, data);
1084 mos7720_port->shadowLCR = 0x83;
1085 write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
1086 write_mos_reg(serial, port_number, THR, 0x0c);
1087 write_mos_reg(serial, port_number, IER, 0x00);
1088 mos7720_port->shadowLCR = 0x03;
1089 write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
1090 write_mos_reg(serial, port_number, IER, 0x0c);
1091
1092 response = usb_submit_urb(port->read_urb, GFP_KERNEL);
1093 if (response)
1094 dev_err(&port->dev, "%s - Error %d submitting read urb\n",
1095 __func__, response);
1096
1097
1098 memset(&(mos7720_port->icount), 0x00, sizeof(mos7720_port->icount));
1099
1100
1101 mos7720_port->shadowMCR = UART_MCR_OUT2;
1102
1103
1104 mos7720_port->open = 1;
1105
1106 return 0;
1107}
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118static int mos7720_chars_in_buffer(struct tty_struct *tty)
1119{
1120 struct usb_serial_port *port = tty->driver_data;
1121 int i;
1122 int chars = 0;
1123 struct moschip_port *mos7720_port;
1124
1125 dbg("%s:entering ...........", __func__);
1126
1127 mos7720_port = usb_get_serial_port_data(port);
1128 if (mos7720_port == NULL) {
1129 dbg("%s:leaving ...........", __func__);
1130 return 0;
1131 }
1132
1133 for (i = 0; i < NUM_URBS; ++i) {
1134 if (mos7720_port->write_urb_pool[i] &&
1135 mos7720_port->write_urb_pool[i]->status == -EINPROGRESS)
1136 chars += URB_TRANSFER_BUFFER_SIZE;
1137 }
1138 dbg("%s - returns %d", __func__, chars);
1139 return chars;
1140}
1141
1142static void mos7720_close(struct usb_serial_port *port)
1143{
1144 struct usb_serial *serial;
1145 struct moschip_port *mos7720_port;
1146 int j;
1147
1148 dbg("mos7720_close:entering...");
1149
1150 serial = port->serial;
1151
1152 mos7720_port = usb_get_serial_port_data(port);
1153 if (mos7720_port == NULL)
1154 return;
1155
1156 for (j = 0; j < NUM_URBS; ++j)
1157 usb_kill_urb(mos7720_port->write_urb_pool[j]);
1158
1159
1160 for (j = 0; j < NUM_URBS; ++j) {
1161 if (mos7720_port->write_urb_pool[j]) {
1162 kfree(mos7720_port->write_urb_pool[j]->transfer_buffer);
1163 usb_free_urb(mos7720_port->write_urb_pool[j]);
1164 }
1165 }
1166
1167
1168
1169 dbg("Shutdown bulk write");
1170 usb_kill_urb(port->write_urb);
1171 dbg("Shutdown bulk read");
1172 usb_kill_urb(port->read_urb);
1173
1174 mutex_lock(&serial->disc_mutex);
1175
1176
1177 if (!serial->disconnected) {
1178 write_mos_reg(serial, port->number - port->serial->minor,
1179 MCR, 0x00);
1180 write_mos_reg(serial, port->number - port->serial->minor,
1181 IER, 0x00);
1182 }
1183 mutex_unlock(&serial->disc_mutex);
1184 mos7720_port->open = 0;
1185
1186 dbg("Leaving %s", __func__);
1187}
1188
1189static void mos7720_break(struct tty_struct *tty, int break_state)
1190{
1191 struct usb_serial_port *port = tty->driver_data;
1192 unsigned char data;
1193 struct usb_serial *serial;
1194 struct moschip_port *mos7720_port;
1195
1196 dbg("Entering %s", __func__);
1197
1198 serial = port->serial;
1199
1200 mos7720_port = usb_get_serial_port_data(port);
1201 if (mos7720_port == NULL)
1202 return;
1203
1204 if (break_state == -1)
1205 data = mos7720_port->shadowLCR | UART_LCR_SBC;
1206 else
1207 data = mos7720_port->shadowLCR & ~UART_LCR_SBC;
1208
1209 mos7720_port->shadowLCR = data;
1210 write_mos_reg(serial, port->number - port->serial->minor,
1211 LCR, mos7720_port->shadowLCR);
1212}
1213
1214
1215
1216
1217
1218
1219
1220
1221static int mos7720_write_room(struct tty_struct *tty)
1222{
1223 struct usb_serial_port *port = tty->driver_data;
1224 struct moschip_port *mos7720_port;
1225 int room = 0;
1226 int i;
1227
1228 dbg("%s:entering ...........", __func__);
1229
1230 mos7720_port = usb_get_serial_port_data(port);
1231 if (mos7720_port == NULL) {
1232 dbg("%s:leaving ...........", __func__);
1233 return -ENODEV;
1234 }
1235
1236
1237 for (i = 0; i < NUM_URBS; ++i) {
1238 if (mos7720_port->write_urb_pool[i] &&
1239 mos7720_port->write_urb_pool[i]->status != -EINPROGRESS)
1240 room += URB_TRANSFER_BUFFER_SIZE;
1241 }
1242
1243 dbg("%s - returns %d", __func__, room);
1244 return room;
1245}
1246
1247static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
1248 const unsigned char *data, int count)
1249{
1250 int status;
1251 int i;
1252 int bytes_sent = 0;
1253 int transfer_size;
1254
1255 struct moschip_port *mos7720_port;
1256 struct usb_serial *serial;
1257 struct urb *urb;
1258 const unsigned char *current_position = data;
1259
1260 dbg("%s:entering ...........", __func__);
1261
1262 serial = port->serial;
1263
1264 mos7720_port = usb_get_serial_port_data(port);
1265 if (mos7720_port == NULL) {
1266 dbg("mos7720_port is NULL");
1267 return -ENODEV;
1268 }
1269
1270
1271 urb = NULL;
1272
1273 for (i = 0; i < NUM_URBS; ++i) {
1274 if (mos7720_port->write_urb_pool[i] &&
1275 mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) {
1276 urb = mos7720_port->write_urb_pool[i];
1277 dbg("URB:%d", i);
1278 break;
1279 }
1280 }
1281
1282 if (urb == NULL) {
1283 dbg("%s - no more free urbs", __func__);
1284 goto exit;
1285 }
1286
1287 if (urb->transfer_buffer == NULL) {
1288 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
1289 GFP_KERNEL);
1290 if (urb->transfer_buffer == NULL) {
1291 dev_err_console(port, "%s no more kernel memory...\n",
1292 __func__);
1293 goto exit;
1294 }
1295 }
1296 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
1297
1298 memcpy(urb->transfer_buffer, current_position, transfer_size);
1299 usb_serial_debug_data(debug, &port->dev, __func__, transfer_size,
1300 urb->transfer_buffer);
1301
1302
1303 usb_fill_bulk_urb(urb, serial->dev,
1304 usb_sndbulkpipe(serial->dev,
1305 port->bulk_out_endpointAddress),
1306 urb->transfer_buffer, transfer_size,
1307 mos7720_bulk_out_data_callback, mos7720_port);
1308
1309
1310 status = usb_submit_urb(urb, GFP_ATOMIC);
1311 if (status) {
1312 dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
1313 "with status = %d\n", __func__, status);
1314 bytes_sent = status;
1315 goto exit;
1316 }
1317 bytes_sent = transfer_size;
1318
1319exit:
1320 return bytes_sent;
1321}
1322
1323static void mos7720_throttle(struct tty_struct *tty)
1324{
1325 struct usb_serial_port *port = tty->driver_data;
1326 struct moschip_port *mos7720_port;
1327 int status;
1328
1329 dbg("%s- port %d", __func__, port->number);
1330
1331 mos7720_port = usb_get_serial_port_data(port);
1332
1333 if (mos7720_port == NULL)
1334 return;
1335
1336 if (!mos7720_port->open) {
1337 dbg("port not opened");
1338 return;
1339 }
1340
1341 dbg("%s: Entering ..........", __func__);
1342
1343
1344 if (I_IXOFF(tty)) {
1345 unsigned char stop_char = STOP_CHAR(tty);
1346 status = mos7720_write(tty, port, &stop_char, 1);
1347 if (status <= 0)
1348 return;
1349 }
1350
1351
1352 if (tty->termios->c_cflag & CRTSCTS) {
1353 mos7720_port->shadowMCR &= ~UART_MCR_RTS;
1354 write_mos_reg(port->serial, port->number - port->serial->minor,
1355 MCR, mos7720_port->shadowMCR);
1356 if (status != 0)
1357 return;
1358 }
1359}
1360
1361static void mos7720_unthrottle(struct tty_struct *tty)
1362{
1363 struct usb_serial_port *port = tty->driver_data;
1364 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1365 int status;
1366
1367 if (mos7720_port == NULL)
1368 return;
1369
1370 if (!mos7720_port->open) {
1371 dbg("%s - port not opened", __func__);
1372 return;
1373 }
1374
1375 dbg("%s: Entering ..........", __func__);
1376
1377
1378 if (I_IXOFF(tty)) {
1379 unsigned char start_char = START_CHAR(tty);
1380 status = mos7720_write(tty, port, &start_char, 1);
1381 if (status <= 0)
1382 return;
1383 }
1384
1385
1386 if (tty->termios->c_cflag & CRTSCTS) {
1387 mos7720_port->shadowMCR |= UART_MCR_RTS;
1388 write_mos_reg(port->serial, port->number - port->serial->minor,
1389 MCR, mos7720_port->shadowMCR);
1390 if (status != 0)
1391 return;
1392 }
1393}
1394
1395
1396static int set_higher_rates(struct moschip_port *mos7720_port,
1397 unsigned int baud)
1398{
1399 struct usb_serial_port *port;
1400 struct usb_serial *serial;
1401 int port_number;
1402 enum mos_regs sp_reg;
1403 if (mos7720_port == NULL)
1404 return -EINVAL;
1405
1406 port = mos7720_port->port;
1407 serial = port->serial;
1408
1409
1410
1411
1412 dbg("Sending Setting Commands ..........");
1413 port_number = port->number - port->serial->minor;
1414
1415 write_mos_reg(serial, port_number, IER, 0x00);
1416 write_mos_reg(serial, port_number, FCR, 0x00);
1417 write_mos_reg(serial, port_number, FCR, 0xcf);
1418 mos7720_port->shadowMCR = 0x0b;
1419 write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1420 write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x00);
1421
1422
1423
1424
1425
1426 if (port_number == 0)
1427 sp_reg = SP1_REG;
1428 else
1429 sp_reg = SP2_REG;
1430 write_mos_reg(serial, dummy, sp_reg, baud * 0x10);
1431 write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x03);
1432 mos7720_port->shadowMCR = 0x2b;
1433 write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1434
1435
1436
1437
1438 mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
1439 write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
1440 write_mos_reg(serial, port_number, DLL, 0x01);
1441 write_mos_reg(serial, port_number, DLM, 0x00);
1442 mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
1443 write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
1444
1445 return 0;
1446}
1447
1448
1449struct divisor_table_entry {
1450 __u32 baudrate;
1451 __u16 divisor;
1452};
1453
1454
1455
1456
1457static struct divisor_table_entry divisor_table[] = {
1458 { 50, 2304},
1459 { 110, 1047},
1460 { 134, 857},
1461 { 150, 768},
1462 { 300, 384},
1463 { 600, 192},
1464 { 1200, 96},
1465 { 1800, 64},
1466 { 2400, 48},
1467 { 4800, 24},
1468 { 7200, 16},
1469 { 9600, 12},
1470 { 19200, 6},
1471 { 38400, 3},
1472 { 57600, 2},
1473 { 115200, 1},
1474};
1475
1476
1477
1478
1479
1480
1481static int calc_baud_rate_divisor(int baudrate, int *divisor)
1482{
1483 int i;
1484 __u16 custom;
1485 __u16 round1;
1486 __u16 round;
1487
1488
1489 dbg("%s - %d", __func__, baudrate);
1490
1491 for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
1492 if (divisor_table[i].baudrate == baudrate) {
1493 *divisor = divisor_table[i].divisor;
1494 return 0;
1495 }
1496 }
1497
1498
1499
1500 if (baudrate > 75 && baudrate < 230400) {
1501
1502 custom = (__u16)(230400L / baudrate);
1503
1504
1505 round1 = (__u16)(2304000L / baudrate);
1506 round = (__u16)(round1 - (custom * 10));
1507 if (round > 4)
1508 custom++;
1509 *divisor = custom;
1510
1511 dbg("Baud %d = %d", baudrate, custom);
1512 return 0;
1513 }
1514
1515 dbg("Baud calculation Failed...");
1516 return -EINVAL;
1517}
1518
1519
1520
1521
1522
1523
1524static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
1525 int baudrate)
1526{
1527 struct usb_serial_port *port;
1528 struct usb_serial *serial;
1529 int divisor;
1530 int status;
1531 unsigned char number;
1532
1533 if (mos7720_port == NULL)
1534 return -1;
1535
1536 port = mos7720_port->port;
1537 serial = port->serial;
1538
1539 dbg("%s: Entering ..........", __func__);
1540
1541 number = port->number - port->serial->minor;
1542 dbg("%s - port = %d, baud = %d", __func__, port->number, baudrate);
1543
1544
1545 status = calc_baud_rate_divisor(baudrate, &divisor);
1546 if (status) {
1547 dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1548 return status;
1549 }
1550
1551
1552 mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
1553 write_mos_reg(serial, number, LCR, mos7720_port->shadowLCR);
1554
1555
1556 write_mos_reg(serial, number, DLL, (__u8)(divisor & 0xff));
1557 write_mos_reg(serial, number, DLM, (__u8)((divisor & 0xff00) >> 8));
1558
1559
1560 mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
1561 write_mos_reg(serial, number, LCR, mos7720_port->shadowLCR);
1562
1563 return status;
1564}
1565
1566
1567
1568
1569
1570
1571static void change_port_settings(struct tty_struct *tty,
1572 struct moschip_port *mos7720_port,
1573 struct ktermios *old_termios)
1574{
1575 struct usb_serial_port *port;
1576 struct usb_serial *serial;
1577 int baud;
1578 unsigned cflag;
1579 unsigned iflag;
1580 __u8 mask = 0xff;
1581 __u8 lData;
1582 __u8 lParity;
1583 __u8 lStop;
1584 int status;
1585 int port_number;
1586
1587 if (mos7720_port == NULL)
1588 return ;
1589
1590 port = mos7720_port->port;
1591 serial = port->serial;
1592 port_number = port->number - port->serial->minor;
1593
1594 dbg("%s - port %d", __func__, port->number);
1595
1596 if (!mos7720_port->open) {
1597 dbg("%s - port not opened", __func__);
1598 return;
1599 }
1600
1601 dbg("%s: Entering ..........", __func__);
1602
1603 lData = UART_LCR_WLEN8;
1604 lStop = 0x00;
1605 lParity = 0x00;
1606
1607 cflag = tty->termios->c_cflag;
1608 iflag = tty->termios->c_iflag;
1609
1610
1611 switch (cflag & CSIZE) {
1612 case CS5:
1613 lData = UART_LCR_WLEN5;
1614 mask = 0x1f;
1615 break;
1616
1617 case CS6:
1618 lData = UART_LCR_WLEN6;
1619 mask = 0x3f;
1620 break;
1621
1622 case CS7:
1623 lData = UART_LCR_WLEN7;
1624 mask = 0x7f;
1625 break;
1626 default:
1627 case CS8:
1628 lData = UART_LCR_WLEN8;
1629 break;
1630 }
1631
1632
1633 if (cflag & PARENB) {
1634 if (cflag & PARODD) {
1635 lParity = UART_LCR_PARITY;
1636 dbg("%s - parity = odd", __func__);
1637 } else {
1638 lParity = (UART_LCR_EPAR | UART_LCR_PARITY);
1639 dbg("%s - parity = even", __func__);
1640 }
1641
1642 } else {
1643 dbg("%s - parity = none", __func__);
1644 }
1645
1646 if (cflag & CMSPAR)
1647 lParity = lParity | 0x20;
1648
1649
1650 if (cflag & CSTOPB) {
1651 lStop = UART_LCR_STOP;
1652 dbg("%s - stop bits = 2", __func__);
1653 } else {
1654 lStop = 0x00;
1655 dbg("%s - stop bits = 1", __func__);
1656 }
1657
1658#define LCR_BITS_MASK 0x03
1659#define LCR_STOP_MASK 0x04
1660#define LCR_PAR_MASK 0x38
1661
1662
1663 mos7720_port->shadowLCR &=
1664 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1665 mos7720_port->shadowLCR |= (lData | lParity | lStop);
1666
1667
1668
1669 write_mos_reg(serial, port_number, IER, 0x00);
1670 write_mos_reg(serial, port_number, FCR, 0x00);
1671 write_mos_reg(serial, port_number, FCR, 0xcf);
1672
1673
1674 write_mos_reg(serial, port_number, LCR, mos7720_port->shadowLCR);
1675 mos7720_port->shadowMCR = 0x0b;
1676 write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1677
1678
1679 mos7720_port->shadowMCR = UART_MCR_OUT2;
1680 if (cflag & CBAUD)
1681 mos7720_port->shadowMCR |= (UART_MCR_DTR | UART_MCR_RTS);
1682
1683 if (cflag & CRTSCTS) {
1684 mos7720_port->shadowMCR |= (UART_MCR_XONANY);
1685
1686
1687 if (port->number)
1688 write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x01);
1689 else
1690 write_mos_reg(serial, dummy, SP_CONTROL_REG, 0x02);
1691
1692 } else
1693 mos7720_port->shadowMCR &= ~(UART_MCR_XONANY);
1694
1695 write_mos_reg(serial, port_number, MCR, mos7720_port->shadowMCR);
1696
1697
1698 baud = tty_get_baud_rate(tty);
1699 if (!baud) {
1700
1701 dbg("Picked default baud...");
1702 baud = 9600;
1703 }
1704
1705 if (baud >= 230400) {
1706 set_higher_rates(mos7720_port, baud);
1707
1708 write_mos_reg(serial, port_number, IER, 0x0c);
1709 return;
1710 }
1711
1712 dbg("%s - baud rate = %d", __func__, baud);
1713 status = send_cmd_write_baud_rate(mos7720_port, baud);
1714
1715
1716 if (cflag & CBAUD)
1717 tty_encode_baud_rate(tty, baud, baud);
1718
1719 write_mos_reg(serial, port_number, IER, 0x0c);
1720
1721 if (port->read_urb->status != -EINPROGRESS) {
1722 status = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1723 if (status)
1724 dbg("usb_submit_urb(read bulk) failed, status = %d",
1725 status);
1726 }
1727}
1728
1729
1730
1731
1732
1733
1734static void mos7720_set_termios(struct tty_struct *tty,
1735 struct usb_serial_port *port, struct ktermios *old_termios)
1736{
1737 int status;
1738 unsigned int cflag;
1739 struct usb_serial *serial;
1740 struct moschip_port *mos7720_port;
1741
1742 serial = port->serial;
1743
1744 mos7720_port = usb_get_serial_port_data(port);
1745
1746 if (mos7720_port == NULL)
1747 return;
1748
1749 if (!mos7720_port->open) {
1750 dbg("%s - port not opened", __func__);
1751 return;
1752 }
1753
1754 dbg("%s\n", "setting termios - ASPIRE");
1755
1756 cflag = tty->termios->c_cflag;
1757
1758 dbg("%s - cflag %08x iflag %08x", __func__,
1759 tty->termios->c_cflag,
1760 RELEVANT_IFLAG(tty->termios->c_iflag));
1761
1762 dbg("%s - old cflag %08x old iflag %08x", __func__,
1763 old_termios->c_cflag,
1764 RELEVANT_IFLAG(old_termios->c_iflag));
1765
1766 dbg("%s - port %d", __func__, port->number);
1767
1768
1769 change_port_settings(tty, mos7720_port, old_termios);
1770
1771 if (port->read_urb->status != -EINPROGRESS) {
1772 status = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1773 if (status)
1774 dbg("usb_submit_urb(read bulk) failed, status = %d",
1775 status);
1776 }
1777}
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789static int get_lsr_info(struct tty_struct *tty,
1790 struct moschip_port *mos7720_port, unsigned int __user *value)
1791{
1792 struct usb_serial_port *port = tty->driver_data;
1793 unsigned int result = 0;
1794 unsigned char data = 0;
1795 int port_number = port->number - port->serial->minor;
1796 int count;
1797
1798 count = mos7720_chars_in_buffer(tty);
1799 if (count == 0) {
1800 read_mos_reg(port->serial, port_number, LSR, &data);
1801 if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
1802 == (UART_LSR_TEMT | UART_LSR_THRE)) {
1803 dbg("%s -- Empty", __func__);
1804 result = TIOCSER_TEMT;
1805 }
1806 }
1807 if (copy_to_user(value, &result, sizeof(int)))
1808 return -EFAULT;
1809 return 0;
1810}
1811
1812static int mos7720_tiocmget(struct tty_struct *tty)
1813{
1814 struct usb_serial_port *port = tty->driver_data;
1815 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1816 unsigned int result = 0;
1817 unsigned int mcr ;
1818 unsigned int msr ;
1819
1820 dbg("%s - port %d", __func__, port->number);
1821
1822 mcr = mos7720_port->shadowMCR;
1823 msr = mos7720_port->shadowMSR;
1824
1825 result = ((mcr & UART_MCR_DTR) ? TIOCM_DTR : 0)
1826 | ((mcr & UART_MCR_RTS) ? TIOCM_RTS : 0)
1827 | ((msr & UART_MSR_CTS) ? TIOCM_CTS : 0)
1828 | ((msr & UART_MSR_DCD) ? TIOCM_CAR : 0)
1829 | ((msr & UART_MSR_RI) ? TIOCM_RI : 0)
1830 | ((msr & UART_MSR_DSR) ? TIOCM_DSR : 0);
1831
1832 dbg("%s -- %x", __func__, result);
1833
1834 return result;
1835}
1836
1837static int mos7720_tiocmset(struct tty_struct *tty,
1838 unsigned int set, unsigned int clear)
1839{
1840 struct usb_serial_port *port = tty->driver_data;
1841 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1842 unsigned int mcr ;
1843 dbg("%s - port %d", __func__, port->number);
1844 dbg("he was at tiocmset");
1845
1846 mcr = mos7720_port->shadowMCR;
1847
1848 if (set & TIOCM_RTS)
1849 mcr |= UART_MCR_RTS;
1850 if (set & TIOCM_DTR)
1851 mcr |= UART_MCR_DTR;
1852 if (set & TIOCM_LOOP)
1853 mcr |= UART_MCR_LOOP;
1854
1855 if (clear & TIOCM_RTS)
1856 mcr &= ~UART_MCR_RTS;
1857 if (clear & TIOCM_DTR)
1858 mcr &= ~UART_MCR_DTR;
1859 if (clear & TIOCM_LOOP)
1860 mcr &= ~UART_MCR_LOOP;
1861
1862 mos7720_port->shadowMCR = mcr;
1863 write_mos_reg(port->serial, port->number - port->serial->minor,
1864 MCR, mos7720_port->shadowMCR);
1865
1866 return 0;
1867}
1868
1869static int mos7720_get_icount(struct tty_struct *tty,
1870 struct serial_icounter_struct *icount)
1871{
1872 struct usb_serial_port *port = tty->driver_data;
1873 struct moschip_port *mos7720_port;
1874 struct async_icount cnow;
1875
1876 mos7720_port = usb_get_serial_port_data(port);
1877 cnow = mos7720_port->icount;
1878
1879 icount->cts = cnow.cts;
1880 icount->dsr = cnow.dsr;
1881 icount->rng = cnow.rng;
1882 icount->dcd = cnow.dcd;
1883 icount->rx = cnow.rx;
1884 icount->tx = cnow.tx;
1885 icount->frame = cnow.frame;
1886 icount->overrun = cnow.overrun;
1887 icount->parity = cnow.parity;
1888 icount->brk = cnow.brk;
1889 icount->buf_overrun = cnow.buf_overrun;
1890
1891 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
1892 port->number, icount->rx, icount->tx);
1893 return 0;
1894}
1895
1896static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
1897 unsigned int __user *value)
1898{
1899 unsigned int mcr;
1900 unsigned int arg;
1901
1902 struct usb_serial_port *port;
1903
1904 if (mos7720_port == NULL)
1905 return -1;
1906
1907 port = (struct usb_serial_port *)mos7720_port->port;
1908 mcr = mos7720_port->shadowMCR;
1909
1910 if (copy_from_user(&arg, value, sizeof(int)))
1911 return -EFAULT;
1912
1913 switch (cmd) {
1914 case TIOCMBIS:
1915 if (arg & TIOCM_RTS)
1916 mcr |= UART_MCR_RTS;
1917 if (arg & TIOCM_DTR)
1918 mcr |= UART_MCR_RTS;
1919 if (arg & TIOCM_LOOP)
1920 mcr |= UART_MCR_LOOP;
1921 break;
1922
1923 case TIOCMBIC:
1924 if (arg & TIOCM_RTS)
1925 mcr &= ~UART_MCR_RTS;
1926 if (arg & TIOCM_DTR)
1927 mcr &= ~UART_MCR_RTS;
1928 if (arg & TIOCM_LOOP)
1929 mcr &= ~UART_MCR_LOOP;
1930 break;
1931
1932 }
1933
1934 mos7720_port->shadowMCR = mcr;
1935 write_mos_reg(port->serial, port->number - port->serial->minor,
1936 MCR, mos7720_port->shadowMCR);
1937
1938 return 0;
1939}
1940
1941static int get_serial_info(struct moschip_port *mos7720_port,
1942 struct serial_struct __user *retinfo)
1943{
1944 struct serial_struct tmp;
1945
1946 if (!retinfo)
1947 return -EFAULT;
1948
1949 memset(&tmp, 0, sizeof(tmp));
1950
1951 tmp.type = PORT_16550A;
1952 tmp.line = mos7720_port->port->serial->minor;
1953 tmp.port = mos7720_port->port->number;
1954 tmp.irq = 0;
1955 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
1956 tmp.xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE;
1957 tmp.baud_base = 9600;
1958 tmp.close_delay = 5*HZ;
1959 tmp.closing_wait = 30*HZ;
1960
1961 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1962 return -EFAULT;
1963 return 0;
1964}
1965
1966static int mos7720_ioctl(struct tty_struct *tty,
1967 unsigned int cmd, unsigned long arg)
1968{
1969 struct usb_serial_port *port = tty->driver_data;
1970 struct moschip_port *mos7720_port;
1971 struct async_icount cnow;
1972 struct async_icount cprev;
1973
1974 mos7720_port = usb_get_serial_port_data(port);
1975 if (mos7720_port == NULL)
1976 return -ENODEV;
1977
1978 dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
1979
1980 switch (cmd) {
1981 case TIOCSERGETLSR:
1982 dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
1983 return get_lsr_info(tty, mos7720_port,
1984 (unsigned int __user *)arg);
1985
1986
1987 case TIOCMBIS:
1988 case TIOCMBIC:
1989 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET",
1990 __func__, port->number);
1991 return set_modem_info(mos7720_port, cmd,
1992 (unsigned int __user *)arg);
1993
1994 case TIOCGSERIAL:
1995 dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
1996 return get_serial_info(mos7720_port,
1997 (struct serial_struct __user *)arg);
1998
1999 case TIOCMIWAIT:
2000 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
2001 cprev = mos7720_port->icount;
2002 while (1) {
2003 if (signal_pending(current))
2004 return -ERESTARTSYS;
2005 cnow = mos7720_port->icount;
2006 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2007 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
2008 return -EIO;
2009 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2010 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2011 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2012 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
2013 return 0;
2014 }
2015 cprev = cnow;
2016 }
2017
2018 break;
2019 }
2020
2021 return -ENOIOCTLCMD;
2022}
2023
2024static int mos7720_startup(struct usb_serial *serial)
2025{
2026 struct moschip_port *mos7720_port;
2027 struct usb_device *dev;
2028 int i;
2029 char data;
2030 u16 product;
2031 int ret_val;
2032
2033 dbg("%s: Entering ..........", __func__);
2034
2035 if (!serial) {
2036 dbg("Invalid Handler");
2037 return -ENODEV;
2038 }
2039
2040 product = le16_to_cpu(serial->dev->descriptor.idProduct);
2041 dev = serial->dev;
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054 if (product == MOSCHIP_DEVICE_ID_7715) {
2055 struct usb_serial_port *tmp = serial->port[0];
2056 serial->port[0] = serial->port[1];
2057 serial->port[1] = tmp;
2058 serial->port[0]->interrupt_in_urb = tmp->interrupt_in_urb;
2059 serial->port[0]->interrupt_in_buffer = tmp->interrupt_in_buffer;
2060 serial->port[0]->interrupt_in_endpointAddress =
2061 tmp->interrupt_in_endpointAddress;
2062 serial->port[1]->interrupt_in_urb = NULL;
2063 serial->port[1]->interrupt_in_buffer = NULL;
2064 }
2065
2066
2067
2068 for (i = 0; i < serial->num_ports; ++i) {
2069 mos7720_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
2070 if (mos7720_port == NULL) {
2071 dev_err(&dev->dev, "%s - Out of memory\n", __func__);
2072 return -ENOMEM;
2073 }
2074
2075
2076
2077
2078 serial->port[i]->interrupt_in_endpointAddress =
2079 serial->port[0]->interrupt_in_endpointAddress;
2080
2081 mos7720_port->port = serial->port[i];
2082 usb_set_serial_port_data(serial->port[i], mos7720_port);
2083
2084 dbg("port number is %d", serial->port[i]->number);
2085 dbg("serial number is %d", serial->minor);
2086 }
2087
2088
2089
2090 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2091 (__u8)0x03, 0x00, 0x01, 0x00, NULL, 0x00, 5*HZ);
2092
2093
2094 ret_val = usb_submit_urb(serial->port[0]->interrupt_in_urb, GFP_KERNEL);
2095 if (ret_val)
2096 dev_err(&dev->dev,
2097 "%s - Error %d submitting control urb\n",
2098 __func__, ret_val);
2099
2100#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
2101 if (product == MOSCHIP_DEVICE_ID_7715) {
2102 ret_val = mos7715_parport_init(serial);
2103 if (ret_val < 0)
2104 return ret_val;
2105 }
2106#endif
2107
2108 read_mos_reg(serial, 0, LSR, &data);
2109 dbg("LSR:%x", data);
2110
2111 return 0;
2112}
2113
2114static void mos7720_release(struct usb_serial *serial)
2115{
2116 int i;
2117
2118#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
2119
2120
2121 if (le16_to_cpu(serial->dev->descriptor.idProduct)
2122 == MOSCHIP_DEVICE_ID_7715) {
2123 struct urbtracker *urbtrack;
2124 unsigned long flags;
2125 struct mos7715_parport *mos_parport =
2126 usb_get_serial_data(serial);
2127
2128
2129 spin_lock(&release_lock);
2130 mos_parport->pp->private_data = NULL;
2131 spin_unlock(&release_lock);
2132
2133
2134 if (mos_parport->msg_pending)
2135 wait_for_completion_timeout(&mos_parport->syncmsg_compl,
2136 MOS_WDR_TIMEOUT);
2137
2138 parport_remove_port(mos_parport->pp);
2139 usb_set_serial_data(serial, NULL);
2140 mos_parport->serial = NULL;
2141
2142
2143 tasklet_kill(&mos_parport->urb_tasklet);
2144
2145
2146 spin_lock_irqsave(&mos_parport->listlock, flags);
2147 list_for_each_entry(urbtrack,
2148 &mos_parport->active_urbs,
2149 urblist_entry)
2150 usb_unlink_urb(urbtrack->urb);
2151 spin_unlock_irqrestore(&mos_parport->listlock, flags);
2152
2153 kref_put(&mos_parport->ref_count, destroy_mos_parport);
2154 }
2155#endif
2156
2157 for (i = 0; i < serial->num_ports; ++i)
2158 kfree(usb_get_serial_port_data(serial->port[i]));
2159}
2160
2161static struct usb_serial_driver moschip7720_2port_driver = {
2162 .driver = {
2163 .owner = THIS_MODULE,
2164 .name = "moschip7720",
2165 },
2166 .description = "Moschip 2 port adapter",
2167 .id_table = id_table,
2168 .calc_num_ports = mos77xx_calc_num_ports,
2169 .open = mos7720_open,
2170 .close = mos7720_close,
2171 .throttle = mos7720_throttle,
2172 .unthrottle = mos7720_unthrottle,
2173 .probe = mos77xx_probe,
2174 .attach = mos7720_startup,
2175 .release = mos7720_release,
2176 .ioctl = mos7720_ioctl,
2177 .tiocmget = mos7720_tiocmget,
2178 .tiocmset = mos7720_tiocmset,
2179 .get_icount = mos7720_get_icount,
2180 .set_termios = mos7720_set_termios,
2181 .write = mos7720_write,
2182 .write_room = mos7720_write_room,
2183 .chars_in_buffer = mos7720_chars_in_buffer,
2184 .break_ctl = mos7720_break,
2185 .read_bulk_callback = mos7720_bulk_in_callback,
2186 .read_int_callback = NULL
2187};
2188
2189static struct usb_serial_driver * const serial_drivers[] = {
2190 &moschip7720_2port_driver, NULL
2191};
2192
2193module_usb_serial_driver(serial_drivers, id_table);
2194
2195MODULE_AUTHOR(DRIVER_AUTHOR);
2196MODULE_DESCRIPTION(DRIVER_DESC);
2197MODULE_LICENSE("GPL");
2198
2199module_param(debug, bool, S_IRUGO | S_IWUSR);
2200MODULE_PARM_DESC(debug, "Debug enabled or not");
2201