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