Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/usb/serial/ark3116.c

  1 /*
  2  * Copyright (C) 2009 by Bart Hartgers (bart.hartgers+ark3116@gmail.com)
  3  * Original version:
  4  * Copyright (C) 2006
  5  *   Simon Schulz (ark3116_driver <at> auctionant.de)
  6  *
  7  * ark3116
  8  * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547,
  9  *   productid=0x0232) (used in a datacable called KQ-U8A)
 10  *
 11  * Supports full modem status lines, break, hardware flow control. Does not
 12  * support software flow control, since I do not know how to enable it in hw.
 13  *
 14  * This driver is a essentially new implementation. I initially dug
 15  * into the old ark3116.c driver and suddenly realized the ark3116 is
 16  * a 16450 with a USB interface glued to it. See comments at the
 17  * bottom of this file.
 18  *
 19  * This program is free software; you can redistribute it and/or modify it
 20  * under the terms of the GNU General Public License as published by the
 21  * Free Software Foundation; either version 2 of the License, or (at your
 22  * option) any later version.
 23  */
 24 
 25 #include <linux/kernel.h>
 26 #include <linux/ioctl.h>
 27 #include <linux/tty.h>
 28 #include <linux/slab.h>
 29 #include <linux/tty_flip.h>
 30 #include <linux/module.h>
 31 #include <linux/usb.h>
 32 #include <linux/usb/serial.h>
 33 #include <linux/serial.h>
 34 #include <linux/serial_reg.h>
 35 #include <linux/uaccess.h>
 36 #include <linux/mutex.h>
 37 #include <linux/spinlock.h>
 38 
 39 #define DRIVER_AUTHOR "Bart Hartgers <bart.hartgers+ark3116@gmail.com>"
 40 #define DRIVER_DESC "USB ARK3116 serial/IrDA driver"
 41 #define DRIVER_DEV_DESC "ARK3116 RS232/IrDA"
 42 #define DRIVER_NAME "ark3116"
 43 
 44 /* usb timeout of 1 second */
 45 #define ARK_TIMEOUT 1000
 46 
 47 static const struct usb_device_id id_table[] = {
 48         { USB_DEVICE(0x6547, 0x0232) },
 49         { USB_DEVICE(0x18ec, 0x3118) },         /* USB to IrDA adapter */
 50         { },
 51 };
 52 MODULE_DEVICE_TABLE(usb, id_table);
 53 
 54 static int is_irda(struct usb_serial *serial)
 55 {
 56         struct usb_device *dev = serial->dev;
 57         if (le16_to_cpu(dev->descriptor.idVendor) == 0x18ec &&
 58                         le16_to_cpu(dev->descriptor.idProduct) == 0x3118)
 59                 return 1;
 60         return 0;
 61 }
 62 
 63 struct ark3116_private {
 64         int                     irda;   /* 1 for irda device */
 65 
 66         /* protects hw register updates */
 67         struct mutex            hw_lock;
 68 
 69         int                     quot;   /* baudrate divisor */
 70         __u32                   lcr;    /* line control register value */
 71         __u32                   hcr;    /* handshake control register (0x8)
 72                                          * value */
 73         __u32                   mcr;    /* modem control register value */
 74 
 75         /* protects the status values below */
 76         spinlock_t              status_lock;
 77         __u32                   msr;    /* modem status register value */
 78         __u32                   lsr;    /* line status register value */
 79 };
 80 
 81 static int ark3116_write_reg(struct usb_serial *serial,
 82                              unsigned reg, __u8 val)
 83 {
 84         int result;
 85          /* 0xfe 0x40 are magic values taken from original driver */
 86         result = usb_control_msg(serial->dev,
 87                                  usb_sndctrlpipe(serial->dev, 0),
 88                                  0xfe, 0x40, val, reg,
 89                                  NULL, 0, ARK_TIMEOUT);
 90         return result;
 91 }
 92 
 93 static int ark3116_read_reg(struct usb_serial *serial,
 94                             unsigned reg, unsigned char *buf)
 95 {
 96         int result;
 97         /* 0xfe 0xc0 are magic values taken from original driver */
 98         result = usb_control_msg(serial->dev,
 99                                  usb_rcvctrlpipe(serial->dev, 0),
100                                  0xfe, 0xc0, 0, reg,
101                                  buf, 1, ARK_TIMEOUT);
102         if (result < 0)
103                 return result;
104         else
105                 return buf[0];
106 }
107 
108 static inline int calc_divisor(int bps)
109 {
110         /* Original ark3116 made some exceptions in rounding here
111          * because windows did the same. Assume that is not really
112          * necessary.
113          * Crystal is 12MHz, probably because of USB, but we divide by 4?
114          */
115         return (12000000 + 2*bps) / (4*bps);
116 }
117 
118 static int ark3116_attach(struct usb_serial *serial)
119 {
120         /* make sure we have our end-points */
121         if ((serial->num_bulk_in == 0) ||
122             (serial->num_bulk_out == 0) ||
123             (serial->num_interrupt_in == 0)) {
124                 dev_err(&serial->dev->dev,
125                         "%s - missing endpoint - "
126                         "bulk in: %d, bulk out: %d, int in %d\n",
127                         KBUILD_MODNAME,
128                         serial->num_bulk_in,
129                         serial->num_bulk_out,
130                         serial->num_interrupt_in);
131                 return -EINVAL;
132         }
133 
134         return 0;
135 }
136 
137 static int ark3116_port_probe(struct usb_serial_port *port)
138 {
139         struct usb_serial *serial = port->serial;
140         struct ark3116_private *priv;
141 
142         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
143         if (!priv)
144                 return -ENOMEM;
145 
146         mutex_init(&priv->hw_lock);
147         spin_lock_init(&priv->status_lock);
148 
149         priv->irda = is_irda(serial);
150 
151         usb_set_serial_port_data(port, priv);
152 
153         /* setup the hardware */
154         ark3116_write_reg(serial, UART_IER, 0);
155         /* disable DMA */
156         ark3116_write_reg(serial, UART_FCR, 0);
157         /* handshake control */
158         priv->hcr = 0;
159         ark3116_write_reg(serial, 0x8     , 0);
160         /* modem control */
161         priv->mcr = 0;
162         ark3116_write_reg(serial, UART_MCR, 0);
163 
164         if (!(priv->irda)) {
165                 ark3116_write_reg(serial, 0xb , 0);
166         } else {
167                 ark3116_write_reg(serial, 0xb , 1);
168                 ark3116_write_reg(serial, 0xc , 0);
169                 ark3116_write_reg(serial, 0xd , 0x41);
170                 ark3116_write_reg(serial, 0xa , 1);
171         }
172 
173         /* setup baudrate */
174         ark3116_write_reg(serial, UART_LCR, UART_LCR_DLAB);
175 
176         /* setup for 9600 8N1 */
177         priv->quot = calc_divisor(9600);
178         ark3116_write_reg(serial, UART_DLL, priv->quot & 0xff);
179         ark3116_write_reg(serial, UART_DLM, (priv->quot>>8) & 0xff);
180 
181         priv->lcr = UART_LCR_WLEN8;
182         ark3116_write_reg(serial, UART_LCR, UART_LCR_WLEN8);
183 
184         ark3116_write_reg(serial, 0xe, 0);
185 
186         if (priv->irda)
187                 ark3116_write_reg(serial, 0x9, 0);
188 
189         dev_info(&serial->dev->dev,
190                 "%s using %s mode\n",
191                 KBUILD_MODNAME,
192                 priv->irda ? "IrDA" : "RS232");
193         return 0;
194 }
195 
196 static int ark3116_port_remove(struct usb_serial_port *port)
197 {
198         struct ark3116_private *priv = usb_get_serial_port_data(port);
199 
200         /* device is closed, so URBs and DMA should be down */
201         mutex_destroy(&priv->hw_lock);
202         kfree(priv);
203 
204         return 0;
205 }
206 
207 static void ark3116_init_termios(struct tty_struct *tty)
208 {
209         struct ktermios *termios = &tty->termios;
210         *termios = tty_std_termios;
211         termios->c_cflag = B9600 | CS8
212                                       | CREAD | HUPCL | CLOCAL;
213         termios->c_ispeed = 9600;
214         termios->c_ospeed = 9600;
215 }
216 
217 static void ark3116_set_termios(struct tty_struct *tty,
218                                 struct usb_serial_port *port,
219                                 struct ktermios *old_termios)
220 {
221         struct usb_serial *serial = port->serial;
222         struct ark3116_private *priv = usb_get_serial_port_data(port);
223         struct ktermios *termios = &tty->termios;
224         unsigned int cflag = termios->c_cflag;
225         int bps = tty_get_baud_rate(tty);
226         int quot;
227         __u8 lcr, hcr, eval;
228 
229         /* set data bit count */
230         switch (cflag & CSIZE) {
231         case CS5:
232                 lcr = UART_LCR_WLEN5;
233                 break;
234         case CS6:
235                 lcr = UART_LCR_WLEN6;
236                 break;
237         case CS7:
238                 lcr = UART_LCR_WLEN7;
239                 break;
240         default:
241         case CS8:
242                 lcr = UART_LCR_WLEN8;
243                 break;
244         }
245         if (cflag & CSTOPB)
246                 lcr |= UART_LCR_STOP;
247         if (cflag & PARENB)
248                 lcr |= UART_LCR_PARITY;
249         if (!(cflag & PARODD))
250                 lcr |= UART_LCR_EPAR;
251 #ifdef CMSPAR
252         if (cflag & CMSPAR)
253                 lcr |= UART_LCR_SPAR;
254 #endif
255         /* handshake control */
256         hcr = (cflag & CRTSCTS) ? 0x03 : 0x00;
257 
258         /* calc baudrate */
259         dev_dbg(&port->dev, "%s - setting bps to %d\n", __func__, bps);
260         eval = 0;
261         switch (bps) {
262         case 0:
263                 quot = calc_divisor(9600);
264                 break;
265         default:
266                 if ((bps < 75) || (bps > 3000000))
267                         bps = 9600;
268                 quot = calc_divisor(bps);
269                 break;
270         case 460800:
271                 eval = 1;
272                 quot = calc_divisor(bps);
273                 break;
274         case 921600:
275                 eval = 2;
276                 quot = calc_divisor(bps);
277                 break;
278         }
279 
280         /* Update state: synchronize */
281         mutex_lock(&priv->hw_lock);
282 
283         /* keep old LCR_SBC bit */
284         lcr |= (priv->lcr & UART_LCR_SBC);
285 
286         dev_dbg(&port->dev, "%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d\n",
287                 __func__, hcr, lcr, quot);
288 
289         /* handshake control */
290         if (priv->hcr != hcr) {
291                 priv->hcr = hcr;
292                 ark3116_write_reg(serial, 0x8, hcr);
293         }
294 
295         /* baudrate */
296         if (priv->quot != quot) {
297                 priv->quot = quot;
298                 priv->lcr = lcr; /* need to write lcr anyway */
299 
300                 /* disable DMA since transmit/receive is
301                  * shadowed by UART_DLL
302                  */
303                 ark3116_write_reg(serial, UART_FCR, 0);
304 
305                 ark3116_write_reg(serial, UART_LCR,
306                                   lcr|UART_LCR_DLAB);
307                 ark3116_write_reg(serial, UART_DLL, quot & 0xff);
308                 ark3116_write_reg(serial, UART_DLM, (quot>>8) & 0xff);
309 
310                 /* restore lcr */
311                 ark3116_write_reg(serial, UART_LCR, lcr);
312                 /* magic baudrate thingy: not sure what it does,
313                  * but windows does this as well.
314                  */
315                 ark3116_write_reg(serial, 0xe, eval);
316 
317                 /* enable DMA */
318                 ark3116_write_reg(serial, UART_FCR, UART_FCR_DMA_SELECT);
319         } else if (priv->lcr != lcr) {
320                 priv->lcr = lcr;
321                 ark3116_write_reg(serial, UART_LCR, lcr);
322         }
323 
324         mutex_unlock(&priv->hw_lock);
325 
326         /* check for software flow control */
327         if (I_IXOFF(tty) || I_IXON(tty)) {
328                 dev_warn(&serial->dev->dev,
329                          "%s: don't know how to do software flow control\n",
330                          KBUILD_MODNAME);
331         }
332 
333         /* Don't rewrite B0 */
334         if (tty_termios_baud_rate(termios))
335                 tty_termios_encode_baud_rate(termios, bps, bps);
336 }
337 
338 static void ark3116_close(struct usb_serial_port *port)
339 {
340         struct usb_serial *serial = port->serial;
341 
342         /* disable DMA */
343         ark3116_write_reg(serial, UART_FCR, 0);
344 
345         /* deactivate interrupts */
346         ark3116_write_reg(serial, UART_IER, 0);
347 
348         usb_serial_generic_close(port);
349         if (serial->num_interrupt_in)
350                 usb_kill_urb(port->interrupt_in_urb);
351 }
352 
353 static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
354 {
355         struct ark3116_private *priv = usb_get_serial_port_data(port);
356         struct usb_serial *serial = port->serial;
357         unsigned char *buf;
358         int result;
359 
360         buf = kmalloc(1, GFP_KERNEL);
361         if (buf == NULL)
362                 return -ENOMEM;
363 
364         result = usb_serial_generic_open(tty, port);
365         if (result) {
366                 dev_dbg(&port->dev,
367                         "%s - usb_serial_generic_open failed: %d\n",
368                         __func__, result);
369                 goto err_out;
370         }
371 
372         /* remove any data still left: also clears error state */
373         ark3116_read_reg(serial, UART_RX, buf);
374 
375         /* read modem status */
376         priv->msr = ark3116_read_reg(serial, UART_MSR, buf);
377         /* read line status */
378         priv->lsr = ark3116_read_reg(serial, UART_LSR, buf);
379 
380         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
381         if (result) {
382                 dev_err(&port->dev, "submit irq_in urb failed %d\n",
383                         result);
384                 ark3116_close(port);
385                 goto err_out;
386         }
387 
388         /* activate interrupts */
389         ark3116_write_reg(port->serial, UART_IER, UART_IER_MSI|UART_IER_RLSI);
390 
391         /* enable DMA */
392         ark3116_write_reg(port->serial, UART_FCR, UART_FCR_DMA_SELECT);
393 
394         /* setup termios */
395         if (tty)
396                 ark3116_set_termios(tty, port, NULL);
397 
398 err_out:
399         kfree(buf);
400         return result;
401 }
402 
403 static int ark3116_ioctl(struct tty_struct *tty,
404                          unsigned int cmd, unsigned long arg)
405 {
406         struct usb_serial_port *port = tty->driver_data;
407         struct serial_struct serstruct;
408         void __user *user_arg = (void __user *)arg;
409 
410         switch (cmd) {
411         case TIOCGSERIAL:
412                 /* XXX: Some of these values are probably wrong. */
413                 memset(&serstruct, 0, sizeof(serstruct));
414                 serstruct.type = PORT_16654;
415                 serstruct.line = port->minor;
416                 serstruct.port = port->port_number;
417                 serstruct.custom_divisor = 0;
418                 serstruct.baud_base = 460800;
419 
420                 if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
421                         return -EFAULT;
422 
423                 return 0;
424         case TIOCSSERIAL:
425                 if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
426                         return -EFAULT;
427                 return 0;
428         }
429 
430         return -ENOIOCTLCMD;
431 }
432 
433 static int ark3116_tiocmget(struct tty_struct *tty)
434 {
435         struct usb_serial_port *port = tty->driver_data;
436         struct ark3116_private *priv = usb_get_serial_port_data(port);
437         __u32 status;
438         __u32 ctrl;
439         unsigned long flags;
440 
441         mutex_lock(&priv->hw_lock);
442         ctrl = priv->mcr;
443         mutex_unlock(&priv->hw_lock);
444 
445         spin_lock_irqsave(&priv->status_lock, flags);
446         status = priv->msr;
447         spin_unlock_irqrestore(&priv->status_lock, flags);
448 
449         return  (status & UART_MSR_DSR  ? TIOCM_DSR  : 0) |
450                 (status & UART_MSR_CTS  ? TIOCM_CTS  : 0) |
451                 (status & UART_MSR_RI   ? TIOCM_RI   : 0) |
452                 (status & UART_MSR_DCD  ? TIOCM_CD   : 0) |
453                 (ctrl   & UART_MCR_DTR  ? TIOCM_DTR  : 0) |
454                 (ctrl   & UART_MCR_RTS  ? TIOCM_RTS  : 0) |
455                 (ctrl   & UART_MCR_OUT1 ? TIOCM_OUT1 : 0) |
456                 (ctrl   & UART_MCR_OUT2 ? TIOCM_OUT2 : 0);
457 }
458 
459 static int ark3116_tiocmset(struct tty_struct *tty,
460                         unsigned set, unsigned clr)
461 {
462         struct usb_serial_port *port = tty->driver_data;
463         struct ark3116_private *priv = usb_get_serial_port_data(port);
464 
465         /* we need to take the mutex here, to make sure that the value
466          * in priv->mcr is actually the one that is in the hardware
467          */
468 
469         mutex_lock(&priv->hw_lock);
470 
471         if (set & TIOCM_RTS)
472                 priv->mcr |= UART_MCR_RTS;
473         if (set & TIOCM_DTR)
474                 priv->mcr |= UART_MCR_DTR;
475         if (set & TIOCM_OUT1)
476                 priv->mcr |= UART_MCR_OUT1;
477         if (set & TIOCM_OUT2)
478                 priv->mcr |= UART_MCR_OUT2;
479         if (clr & TIOCM_RTS)
480                 priv->mcr &= ~UART_MCR_RTS;
481         if (clr & TIOCM_DTR)
482                 priv->mcr &= ~UART_MCR_DTR;
483         if (clr & TIOCM_OUT1)
484                 priv->mcr &= ~UART_MCR_OUT1;
485         if (clr & TIOCM_OUT2)
486                 priv->mcr &= ~UART_MCR_OUT2;
487 
488         ark3116_write_reg(port->serial, UART_MCR, priv->mcr);
489 
490         mutex_unlock(&priv->hw_lock);
491 
492         return 0;
493 }
494 
495 static void ark3116_break_ctl(struct tty_struct *tty, int break_state)
496 {
497         struct usb_serial_port *port = tty->driver_data;
498         struct ark3116_private *priv = usb_get_serial_port_data(port);
499 
500         /* LCR is also used for other things: protect access */
501         mutex_lock(&priv->hw_lock);
502 
503         if (break_state)
504                 priv->lcr |= UART_LCR_SBC;
505         else
506                 priv->lcr &= ~UART_LCR_SBC;
507 
508         ark3116_write_reg(port->serial, UART_LCR, priv->lcr);
509 
510         mutex_unlock(&priv->hw_lock);
511 }
512 
513 static void ark3116_update_msr(struct usb_serial_port *port, __u8 msr)
514 {
515         struct ark3116_private *priv = usb_get_serial_port_data(port);
516         unsigned long flags;
517 
518         spin_lock_irqsave(&priv->status_lock, flags);
519         priv->msr = msr;
520         spin_unlock_irqrestore(&priv->status_lock, flags);
521 
522         if (msr & UART_MSR_ANY_DELTA) {
523                 /* update input line counters */
524                 if (msr & UART_MSR_DCTS)
525                         port->icount.cts++;
526                 if (msr & UART_MSR_DDSR)
527                         port->icount.dsr++;
528                 if (msr & UART_MSR_DDCD)
529                         port->icount.dcd++;
530                 if (msr & UART_MSR_TERI)
531                         port->icount.rng++;
532                 wake_up_interruptible(&port->port.delta_msr_wait);
533         }
534 }
535 
536 static void ark3116_update_lsr(struct usb_serial_port *port, __u8 lsr)
537 {
538         struct ark3116_private *priv = usb_get_serial_port_data(port);
539         unsigned long flags;
540 
541         spin_lock_irqsave(&priv->status_lock, flags);
542         /* combine bits */
543         priv->lsr |= lsr;
544         spin_unlock_irqrestore(&priv->status_lock, flags);
545 
546         if (lsr&UART_LSR_BRK_ERROR_BITS) {
547                 if (lsr & UART_LSR_BI)
548                         port->icount.brk++;
549                 if (lsr & UART_LSR_FE)
550                         port->icount.frame++;
551                 if (lsr & UART_LSR_PE)
552                         port->icount.parity++;
553                 if (lsr & UART_LSR_OE)
554                         port->icount.overrun++;
555         }
556 }
557 
558 static void ark3116_read_int_callback(struct urb *urb)
559 {
560         struct usb_serial_port *port = urb->context;
561         int status = urb->status;
562         const __u8 *data = urb->transfer_buffer;
563         int result;
564 
565         switch (status) {
566         case -ECONNRESET:
567         case -ENOENT:
568         case -ESHUTDOWN:
569                 /* this urb is terminated, clean up */
570                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
571                         __func__, status);
572                 return;
573         default:
574                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
575                         __func__, status);
576                 break;
577         case 0: /* success */
578                 /* discovered this by trail and error... */
579                 if ((urb->actual_length == 4) && (data[0] == 0xe8)) {
580                         const __u8 id = data[1]&UART_IIR_ID;
581                         dev_dbg(&port->dev, "%s: iir=%02x\n", __func__, data[1]);
582                         if (id == UART_IIR_MSI) {
583                                 dev_dbg(&port->dev, "%s: msr=%02x\n",
584                                         __func__, data[3]);
585                                 ark3116_update_msr(port, data[3]);
586                                 break;
587                         } else if (id == UART_IIR_RLSI) {
588                                 dev_dbg(&port->dev, "%s: lsr=%02x\n",
589                                         __func__, data[2]);
590                                 ark3116_update_lsr(port, data[2]);
591                                 break;
592                         }
593                 }
594                 /*
595                  * Not sure what this data meant...
596                  */
597                 usb_serial_debug_data(&port->dev, __func__,
598                                       urb->actual_length,
599                                       urb->transfer_buffer);
600                 break;
601         }
602 
603         result = usb_submit_urb(urb, GFP_ATOMIC);
604         if (result)
605                 dev_err(&urb->dev->dev,
606                         "%s - Error %d submitting interrupt urb\n",
607                         __func__, result);
608 }
609 
610 
611 /* Data comes in via the bulk (data) URB, errors/interrupts via the int URB.
612  * This means that we cannot be sure which data byte has an associated error
613  * condition, so we report an error for all data in the next bulk read.
614  *
615  * Actually, there might even be a window between the bulk data leaving the
616  * ark and reading/resetting the lsr in the read_bulk_callback where an
617  * interrupt for the next data block could come in.
618  * Without somekind of ordering on the ark, we would have to report the
619  * error for the next block of data as well...
620  * For now, let's pretend this can't happen.
621  */
622 static void ark3116_process_read_urb(struct urb *urb)
623 {
624         struct usb_serial_port *port = urb->context;
625         struct ark3116_private *priv = usb_get_serial_port_data(port);
626         unsigned char *data = urb->transfer_buffer;
627         char tty_flag = TTY_NORMAL;
628         unsigned long flags;
629         __u32 lsr;
630 
631         /* update line status */
632         spin_lock_irqsave(&priv->status_lock, flags);
633         lsr = priv->lsr;
634         priv->lsr &= ~UART_LSR_BRK_ERROR_BITS;
635         spin_unlock_irqrestore(&priv->status_lock, flags);
636 
637         if (!urb->actual_length)
638                 return;
639 
640         if (lsr & UART_LSR_BRK_ERROR_BITS) {
641                 if (lsr & UART_LSR_BI)
642                         tty_flag = TTY_BREAK;
643                 else if (lsr & UART_LSR_PE)
644                         tty_flag = TTY_PARITY;
645                 else if (lsr & UART_LSR_FE)
646                         tty_flag = TTY_FRAME;
647 
648                 /* overrun is special, not associated with a char */
649                 if (lsr & UART_LSR_OE)
650                         tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
651         }
652         tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
653                                                         urb->actual_length);
654         tty_flip_buffer_push(&port->port);
655 }
656 
657 static struct usb_serial_driver ark3116_device = {
658         .driver = {
659                 .owner =        THIS_MODULE,
660                 .name =         "ark3116",
661         },
662         .id_table =             id_table,
663         .num_ports =            1,
664         .attach =               ark3116_attach,
665         .port_probe =           ark3116_port_probe,
666         .port_remove =          ark3116_port_remove,
667         .set_termios =          ark3116_set_termios,
668         .init_termios =         ark3116_init_termios,
669         .ioctl =                ark3116_ioctl,
670         .tiocmget =             ark3116_tiocmget,
671         .tiocmset =             ark3116_tiocmset,
672         .tiocmiwait =           usb_serial_generic_tiocmiwait,
673         .get_icount =           usb_serial_generic_get_icount,
674         .open =                 ark3116_open,
675         .close =                ark3116_close,
676         .break_ctl =            ark3116_break_ctl,
677         .read_int_callback =    ark3116_read_int_callback,
678         .process_read_urb =     ark3116_process_read_urb,
679 };
680 
681 static struct usb_serial_driver * const serial_drivers[] = {
682         &ark3116_device, NULL
683 };
684 
685 module_usb_serial_driver(serial_drivers, id_table);
686 
687 MODULE_LICENSE("GPL");
688 
689 MODULE_AUTHOR(DRIVER_AUTHOR);
690 MODULE_DESCRIPTION(DRIVER_DESC);
691 
692 /*
693  * The following describes what I learned from studying the old
694  * ark3116.c driver, disassembling the windows driver, and some lucky
695  * guesses. Since I do not have any datasheet or other
696  * documentation, inaccuracies are almost guaranteed.
697  *
698  * Some specs for the ARK3116 can be found here:
699  * http://web.archive.org/web/20060318000438/
700  *   www.arkmicro.com/en/products/view.php?id=10
701  * On that page, 2 GPIO pins are mentioned: I assume these are the
702  * OUT1 and OUT2 pins of the UART, so I added support for those
703  * through the MCR. Since the pins are not available on my hardware,
704  * I could not verify this.
705  * Also, it states there is "on-chip hardware flow control". I have
706  * discovered how to enable that. Unfortunately, I do not know how to
707  * enable XON/XOFF (software) flow control, which would need support
708  * from the chip as well to work. Because of the wording on the web
709  * page there is a real possibility the chip simply does not support
710  * software flow control.
711  *
712  * I got my ark3116 as part of a mobile phone adapter cable. On the
713  * PCB, the following numbered contacts are present:
714  *
715  *  1:- +5V
716  *  2:o DTR
717  *  3:i RX
718  *  4:i DCD
719  *  5:o RTS
720  *  6:o TX
721  *  7:i RI
722  *  8:i DSR
723  * 10:- 0V
724  * 11:i CTS
725  *
726  * On my chip, all signals seem to be 3.3V, but 5V tolerant. But that
727  * may be different for the one you have ;-).
728  *
729  * The windows driver limits the registers to 0-F, so I assume there
730  * are actually 16 present on the device.
731  *
732  * On an UART interrupt, 4 bytes of data come in on the interrupt
733  * endpoint. The bytes are 0xe8 IIR LSR MSR.
734  *
735  * The baudrate seems to be generated from the 12MHz crystal, using
736  * 4-times subsampling. So quot=12e6/(4*baud). Also see description
737  * of register E.
738  *
739  * Registers 0-7:
740  * These seem to be the same as for a regular 16450. The FCR is set
741  * to UART_FCR_DMA_SELECT (0x8), I guess to enable transfers between
742  * the UART and the USB bridge/DMA engine.
743  *
744  * Register 8:
745  * By trial and error, I found out that bit 0 enables hardware CTS,
746  * stopping TX when CTS is +5V. Bit 1 does the same for RTS, making
747  * RTS +5V when the 3116 cannot transfer the data to the USB bus
748  * (verified by disabling the reading URB). Note that as far as I can
749  * tell, the windows driver does NOT use this, so there might be some
750  * hardware bug or something.
751  *
752  * According to a patch provided here
753  * (http://lkml.org/lkml/2009/7/26/56), the ARK3116 can also be used
754  * as an IrDA dongle. Since I do not have such a thing, I could not
755  * investigate that aspect. However, I can speculate ;-).
756  *
757  * - IrDA encodes data differently than RS232. Most likely, one of
758  *   the bits in registers 9..E enables the IR ENDEC (encoder/decoder).
759  * - Depending on the IR transceiver, the input and output need to be
760  *   inverted, so there are probably bits for that as well.
761  * - IrDA is half-duplex, so there should be a bit for selecting that.
762  *
763  * This still leaves at least two registers unaccounted for. Perhaps
764  * The chip can do XON/XOFF or CRC in HW?
765  *
766  * Register 9:
767  * Set to 0x00 for IrDA, when the baudrate is initialised.
768  *
769  * Register A:
770  * Set to 0x01 for IrDA, at init.
771  *
772  * Register B:
773  * Set to 0x01 for IrDA, 0x00 for RS232, at init.
774  *
775  * Register C:
776  * Set to 00 for IrDA, at init.
777  *
778  * Register D:
779  * Set to 0x41 for IrDA, at init.
780  *
781  * Register E:
782  * Somekind of baudrate override. The windows driver seems to set
783  * this to 0x00 for normal baudrates, 0x01 for 460800, 0x02 for 921600.
784  * Since 460800 and 921600 cannot be obtained by dividing 3MHz by an integer,
785  * it could be somekind of subdivisor thingy.
786  * However,it does not seem to do anything: selecting 921600 (divisor 3,
787  * reg E=2), still gets 1 MHz. I also checked if registers 9, C or F would
788  * work, but they don't.
789  *
790  * Register F: unknown
791  */
792 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us