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