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