← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-n900/saucy

« back to all changes in this revision

Viewing changes to drivers/usb/serial/ark3116.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Poirier
  • Date: 2011-02-18 09:43:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110218094331-eyubsja4f9k0yhmq
Tags: 2.6.35-1.1
Initial release.

Show diffs side-by-side

added added

removed removed

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