Root/drivers/tty/moxa.c

1/*****************************************************************************/
2/*
3 * moxa.c -- MOXA Intellio family multiport serial driver.
4 *
5 * Copyright (C) 1999-2000 Moxa Technologies (support@moxa.com).
6 * Copyright (c) 2007 Jiri Slaby <jirislaby@gmail.com>
7 *
8 * This code is loosely based on the Linux serial driver, written by
9 * Linus Torvalds, Theodore T'so and others.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 */
16
17/*
18 * MOXA Intellio Series Driver
19 * for : LINUX
20 * date : 1999/1/7
21 * version : 5.1
22 */
23
24#include <linux/module.h>
25#include <linux/types.h>
26#include <linux/mm.h>
27#include <linux/ioport.h>
28#include <linux/errno.h>
29#include <linux/firmware.h>
30#include <linux/signal.h>
31#include <linux/sched.h>
32#include <linux/timer.h>
33#include <linux/interrupt.h>
34#include <linux/tty.h>
35#include <linux/tty_flip.h>
36#include <linux/major.h>
37#include <linux/string.h>
38#include <linux/fcntl.h>
39#include <linux/ptrace.h>
40#include <linux/serial.h>
41#include <linux/tty_driver.h>
42#include <linux/delay.h>
43#include <linux/pci.h>
44#include <linux/init.h>
45#include <linux/bitops.h>
46#include <linux/slab.h>
47#include <linux/ratelimit.h>
48
49#include <asm/io.h>
50#include <asm/uaccess.h>
51
52#include "moxa.h"
53
54#define MOXA_VERSION "6.0k"
55
56#define MOXA_FW_HDRLEN 32
57
58#define MOXAMAJOR 172
59
60#define MAX_BOARDS 4 /* Don't change this value */
61#define MAX_PORTS_PER_BOARD 32 /* Don't change this value */
62#define MAX_PORTS (MAX_BOARDS * MAX_PORTS_PER_BOARD)
63
64#define MOXA_IS_320(brd) ((brd)->boardType == MOXA_BOARD_C320_ISA || \
65        (brd)->boardType == MOXA_BOARD_C320_PCI)
66
67/*
68 * Define the Moxa PCI vendor and device IDs.
69 */
70#define MOXA_BUS_TYPE_ISA 0
71#define MOXA_BUS_TYPE_PCI 1
72
73enum {
74    MOXA_BOARD_C218_PCI = 1,
75    MOXA_BOARD_C218_ISA,
76    MOXA_BOARD_C320_PCI,
77    MOXA_BOARD_C320_ISA,
78    MOXA_BOARD_CP204J,
79};
80
81static char *moxa_brdname[] =
82{
83    "C218 Turbo PCI series",
84    "C218 Turbo ISA series",
85    "C320 Turbo PCI series",
86    "C320 Turbo ISA series",
87    "CP-204J series",
88};
89
90#ifdef CONFIG_PCI
91static struct pci_device_id moxa_pcibrds[] = {
92    { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),
93        .driver_data = MOXA_BOARD_C218_PCI },
94    { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),
95        .driver_data = MOXA_BOARD_C320_PCI },
96    { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),
97        .driver_data = MOXA_BOARD_CP204J },
98    { 0 }
99};
100MODULE_DEVICE_TABLE(pci, moxa_pcibrds);
101#endif /* CONFIG_PCI */
102
103struct moxa_port;
104
105static struct moxa_board_conf {
106    int boardType;
107    int numPorts;
108    int busType;
109
110    unsigned int ready;
111
112    struct moxa_port *ports;
113
114    void __iomem *basemem;
115    void __iomem *intNdx;
116    void __iomem *intPend;
117    void __iomem *intTable;
118} moxa_boards[MAX_BOARDS];
119
120struct mxser_mstatus {
121    tcflag_t cflag;
122    int cts;
123    int dsr;
124    int ri;
125    int dcd;
126};
127
128struct moxaq_str {
129    int inq;
130    int outq;
131};
132
133struct moxa_port {
134    struct tty_port port;
135    struct moxa_board_conf *board;
136    void __iomem *tableAddr;
137
138    int type;
139    int cflag;
140    unsigned long statusflags;
141
142    u8 DCDState; /* Protected by the port lock */
143    u8 lineCtrl;
144    u8 lowChkFlag;
145};
146
147struct mon_str {
148    int tick;
149    int rxcnt[MAX_PORTS];
150    int txcnt[MAX_PORTS];
151};
152
153/* statusflags */
154#define TXSTOPPED 1
155#define LOWWAIT 2
156#define EMPTYWAIT 3
157
158#define SERIAL_DO_RESTART
159
160#define WAKEUP_CHARS 256
161
162static int ttymajor = MOXAMAJOR;
163static struct mon_str moxaLog;
164static unsigned int moxaFuncTout = HZ / 2;
165static unsigned int moxaLowWaterChk;
166static DEFINE_MUTEX(moxa_openlock);
167static DEFINE_SPINLOCK(moxa_lock);
168
169static unsigned long baseaddr[MAX_BOARDS];
170static unsigned int type[MAX_BOARDS];
171static unsigned int numports[MAX_BOARDS];
172static struct tty_port moxa_service_port;
173
174MODULE_AUTHOR("William Chen");
175MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
176MODULE_LICENSE("GPL");
177MODULE_FIRMWARE("c218tunx.cod");
178MODULE_FIRMWARE("cp204unx.cod");
179MODULE_FIRMWARE("c320tunx.cod");
180
181module_param_array(type, uint, NULL, 0);
182MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
183module_param_array(baseaddr, ulong, NULL, 0);
184MODULE_PARM_DESC(baseaddr, "base address");
185module_param_array(numports, uint, NULL, 0);
186MODULE_PARM_DESC(numports, "numports (ignored for C218)");
187
188module_param(ttymajor, int, 0);
189
190/*
191 * static functions:
192 */
193static int moxa_open(struct tty_struct *, struct file *);
194static void moxa_close(struct tty_struct *, struct file *);
195static int moxa_write(struct tty_struct *, const unsigned char *, int);
196static int moxa_write_room(struct tty_struct *);
197static void moxa_flush_buffer(struct tty_struct *);
198static int moxa_chars_in_buffer(struct tty_struct *);
199static void moxa_set_termios(struct tty_struct *, struct ktermios *);
200static void moxa_stop(struct tty_struct *);
201static void moxa_start(struct tty_struct *);
202static void moxa_hangup(struct tty_struct *);
203static int moxa_tiocmget(struct tty_struct *tty);
204static int moxa_tiocmset(struct tty_struct *tty,
205             unsigned int set, unsigned int clear);
206static void moxa_poll(unsigned long);
207static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);
208static void moxa_shutdown(struct tty_port *);
209static int moxa_carrier_raised(struct tty_port *);
210static void moxa_dtr_rts(struct tty_port *, int);
211/*
212 * moxa board interface functions:
213 */
214static void MoxaPortEnable(struct moxa_port *);
215static void MoxaPortDisable(struct moxa_port *);
216static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);
217static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);
218static void MoxaPortLineCtrl(struct moxa_port *, int, int);
219static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
220static int MoxaPortLineStatus(struct moxa_port *);
221static void MoxaPortFlushData(struct moxa_port *, int);
222static int MoxaPortWriteData(struct tty_struct *, const unsigned char *, int);
223static int MoxaPortReadData(struct moxa_port *);
224static int MoxaPortTxQueue(struct moxa_port *);
225static int MoxaPortRxQueue(struct moxa_port *);
226static int MoxaPortTxFree(struct moxa_port *);
227static void MoxaPortTxDisable(struct moxa_port *);
228static void MoxaPortTxEnable(struct moxa_port *);
229static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);
230static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);
231static void MoxaSetFifo(struct moxa_port *port, int enable);
232
233/*
234 * I/O functions
235 */
236
237static DEFINE_SPINLOCK(moxafunc_lock);
238
239static void moxa_wait_finish(void __iomem *ofsAddr)
240{
241    unsigned long end = jiffies + moxaFuncTout;
242
243    while (readw(ofsAddr + FuncCode) != 0)
244        if (time_after(jiffies, end))
245            return;
246    if (readw(ofsAddr + FuncCode) != 0)
247        printk_ratelimited(KERN_WARNING "moxa function expired\n");
248}
249
250static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)
251{
252        unsigned long flags;
253        spin_lock_irqsave(&moxafunc_lock, flags);
254    writew(arg, ofsAddr + FuncArg);
255    writew(cmd, ofsAddr + FuncCode);
256    moxa_wait_finish(ofsAddr);
257    spin_unlock_irqrestore(&moxafunc_lock, flags);
258}
259
260static int moxafuncret(void __iomem *ofsAddr, u16 cmd, u16 arg)
261{
262        unsigned long flags;
263        u16 ret;
264        spin_lock_irqsave(&moxafunc_lock, flags);
265    writew(arg, ofsAddr + FuncArg);
266    writew(cmd, ofsAddr + FuncCode);
267    moxa_wait_finish(ofsAddr);
268    ret = readw(ofsAddr + FuncArg);
269    spin_unlock_irqrestore(&moxafunc_lock, flags);
270    return ret;
271}
272
273static void moxa_low_water_check(void __iomem *ofsAddr)
274{
275    u16 rptr, wptr, mask, len;
276
277    if (readb(ofsAddr + FlagStat) & Xoff_state) {
278        rptr = readw(ofsAddr + RXrptr);
279        wptr = readw(ofsAddr + RXwptr);
280        mask = readw(ofsAddr + RX_mask);
281        len = (wptr - rptr) & mask;
282        if (len <= Low_water)
283            moxafunc(ofsAddr, FC_SendXon, 0);
284    }
285}
286
287/*
288 * TTY operations
289 */
290
291static int moxa_ioctl(struct tty_struct *tty,
292              unsigned int cmd, unsigned long arg)
293{
294    struct moxa_port *ch = tty->driver_data;
295    void __user *argp = (void __user *)arg;
296    int status, ret = 0;
297
298    if (tty->index == MAX_PORTS) {
299        if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&
300                cmd != MOXA_GETMSTATUS)
301            return -EINVAL;
302    } else if (!ch)
303        return -ENODEV;
304
305    switch (cmd) {
306    case MOXA_GETDATACOUNT:
307        moxaLog.tick = jiffies;
308        if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))
309            ret = -EFAULT;
310        break;
311    case MOXA_FLUSH_QUEUE:
312        MoxaPortFlushData(ch, arg);
313        break;
314    case MOXA_GET_IOQUEUE: {
315        struct moxaq_str __user *argm = argp;
316        struct moxaq_str tmp;
317        struct moxa_port *p;
318        unsigned int i, j;
319
320        for (i = 0; i < MAX_BOARDS; i++) {
321            p = moxa_boards[i].ports;
322            for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
323                memset(&tmp, 0, sizeof(tmp));
324                spin_lock_bh(&moxa_lock);
325                if (moxa_boards[i].ready) {
326                    tmp.inq = MoxaPortRxQueue(p);
327                    tmp.outq = MoxaPortTxQueue(p);
328                }
329                spin_unlock_bh(&moxa_lock);
330                if (copy_to_user(argm, &tmp, sizeof(tmp)))
331                    return -EFAULT;
332            }
333        }
334        break;
335    } case MOXA_GET_OQUEUE:
336        status = MoxaPortTxQueue(ch);
337        ret = put_user(status, (unsigned long __user *)argp);
338        break;
339    case MOXA_GET_IQUEUE:
340        status = MoxaPortRxQueue(ch);
341        ret = put_user(status, (unsigned long __user *)argp);
342        break;
343    case MOXA_GETMSTATUS: {
344        struct mxser_mstatus __user *argm = argp;
345        struct mxser_mstatus tmp;
346        struct moxa_port *p;
347        unsigned int i, j;
348
349        for (i = 0; i < MAX_BOARDS; i++) {
350            p = moxa_boards[i].ports;
351            for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
352                struct tty_struct *ttyp;
353                memset(&tmp, 0, sizeof(tmp));
354                spin_lock_bh(&moxa_lock);
355                if (!moxa_boards[i].ready) {
356                        spin_unlock_bh(&moxa_lock);
357                    goto copy;
358                                }
359
360                status = MoxaPortLineStatus(p);
361                spin_unlock_bh(&moxa_lock);
362
363                if (status & 1)
364                    tmp.cts = 1;
365                if (status & 2)
366                    tmp.dsr = 1;
367                if (status & 4)
368                    tmp.dcd = 1;
369
370                ttyp = tty_port_tty_get(&p->port);
371                if (!ttyp)
372                    tmp.cflag = p->cflag;
373                else
374                    tmp.cflag = ttyp->termios.c_cflag;
375                tty_kref_put(ttyp);
376copy:
377                if (copy_to_user(argm, &tmp, sizeof(tmp)))
378                    return -EFAULT;
379            }
380        }
381        break;
382    }
383    case TIOCGSERIAL:
384            mutex_lock(&ch->port.mutex);
385        ret = moxa_get_serial_info(ch, argp);
386        mutex_unlock(&ch->port.mutex);
387        break;
388    case TIOCSSERIAL:
389            mutex_lock(&ch->port.mutex);
390        ret = moxa_set_serial_info(ch, argp);
391        mutex_unlock(&ch->port.mutex);
392        break;
393    default:
394        ret = -ENOIOCTLCMD;
395    }
396    return ret;
397}
398
399static int moxa_break_ctl(struct tty_struct *tty, int state)
400{
401    struct moxa_port *port = tty->driver_data;
402
403    moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,
404            Magic_code);
405    return 0;
406}
407
408static const struct tty_operations moxa_ops = {
409    .open = moxa_open,
410    .close = moxa_close,
411    .write = moxa_write,
412    .write_room = moxa_write_room,
413    .flush_buffer = moxa_flush_buffer,
414    .chars_in_buffer = moxa_chars_in_buffer,
415    .ioctl = moxa_ioctl,
416    .set_termios = moxa_set_termios,
417    .stop = moxa_stop,
418    .start = moxa_start,
419    .hangup = moxa_hangup,
420    .break_ctl = moxa_break_ctl,
421    .tiocmget = moxa_tiocmget,
422    .tiocmset = moxa_tiocmset,
423};
424
425static const struct tty_port_operations moxa_port_ops = {
426    .carrier_raised = moxa_carrier_raised,
427    .dtr_rts = moxa_dtr_rts,
428    .shutdown = moxa_shutdown,
429};
430
431static struct tty_driver *moxaDriver;
432static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);
433
434/*
435 * HW init
436 */
437
438static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)
439{
440    switch (brd->boardType) {
441    case MOXA_BOARD_C218_ISA:
442    case MOXA_BOARD_C218_PCI:
443        if (model != 1)
444            goto err;
445        break;
446    case MOXA_BOARD_CP204J:
447        if (model != 3)
448            goto err;
449        break;
450    default:
451        if (model != 2)
452            goto err;
453        break;
454    }
455    return 0;
456err:
457    return -EINVAL;
458}
459
460static int moxa_check_fw(const void *ptr)
461{
462    const __le16 *lptr = ptr;
463
464    if (*lptr != cpu_to_le16(0x7980))
465        return -EINVAL;
466
467    return 0;
468}
469
470static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
471        size_t len)
472{
473    void __iomem *baseAddr = brd->basemem;
474    u16 tmp;
475
476    writeb(HW_reset, baseAddr + Control_reg); /* reset */
477    msleep(10);
478    memset_io(baseAddr, 0, 4096);
479    memcpy_toio(baseAddr, buf, len); /* download BIOS */
480    writeb(0, baseAddr + Control_reg); /* restart */
481
482    msleep(2000);
483
484    switch (brd->boardType) {
485    case MOXA_BOARD_C218_ISA:
486    case MOXA_BOARD_C218_PCI:
487        tmp = readw(baseAddr + C218_key);
488        if (tmp != C218_KeyCode)
489            goto err;
490        break;
491    case MOXA_BOARD_CP204J:
492        tmp = readw(baseAddr + C218_key);
493        if (tmp != CP204J_KeyCode)
494            goto err;
495        break;
496    default:
497        tmp = readw(baseAddr + C320_key);
498        if (tmp != C320_KeyCode)
499            goto err;
500        tmp = readw(baseAddr + C320_status);
501        if (tmp != STS_init) {
502            printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "
503                    "module not found\n");
504            return -EIO;
505        }
506        break;
507    }
508
509    return 0;
510err:
511    printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");
512    return -EIO;
513}
514
515static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,
516        size_t len)
517{
518    void __iomem *baseAddr = brd->basemem;
519
520    if (len < 7168) {
521        printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");
522        return -EINVAL;
523    }
524
525    writew(len - 7168 - 2, baseAddr + C320bapi_len);
526    writeb(1, baseAddr + Control_reg); /* Select Page 1 */
527    memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);
528    writeb(2, baseAddr + Control_reg); /* Select Page 2 */
529    memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);
530
531    return 0;
532}
533
534static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,
535        size_t len)
536{
537    void __iomem *baseAddr = brd->basemem;
538    const __le16 *uptr = ptr;
539    size_t wlen, len2, j;
540    unsigned long key, loadbuf, loadlen, checksum, checksum_ok;
541    unsigned int i, retry;
542    u16 usum, keycode;
543
544    keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :
545                C218_KeyCode;
546
547    switch (brd->boardType) {
548    case MOXA_BOARD_CP204J:
549    case MOXA_BOARD_C218_ISA:
550    case MOXA_BOARD_C218_PCI:
551        key = C218_key;
552        loadbuf = C218_LoadBuf;
553        loadlen = C218DLoad_len;
554        checksum = C218check_sum;
555        checksum_ok = C218chksum_ok;
556        break;
557    default:
558        key = C320_key;
559        keycode = C320_KeyCode;
560        loadbuf = C320_LoadBuf;
561        loadlen = C320DLoad_len;
562        checksum = C320check_sum;
563        checksum_ok = C320chksum_ok;
564        break;
565    }
566
567    usum = 0;
568    wlen = len >> 1;
569    for (i = 0; i < wlen; i++)
570        usum += le16_to_cpu(uptr[i]);
571    retry = 0;
572    do {
573        wlen = len >> 1;
574        j = 0;
575        while (wlen) {
576            len2 = (wlen > 2048) ? 2048 : wlen;
577            wlen -= len2;
578            memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);
579            j += len2 << 1;
580
581            writew(len2, baseAddr + loadlen);
582            writew(0, baseAddr + key);
583            for (i = 0; i < 100; i++) {
584                if (readw(baseAddr + key) == keycode)
585                    break;
586                msleep(10);
587            }
588            if (readw(baseAddr + key) != keycode)
589                return -EIO;
590        }
591        writew(0, baseAddr + loadlen);
592        writew(usum, baseAddr + checksum);
593        writew(0, baseAddr + key);
594        for (i = 0; i < 100; i++) {
595            if (readw(baseAddr + key) == keycode)
596                break;
597            msleep(10);
598        }
599        retry++;
600    } while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));
601    if (readb(baseAddr + checksum_ok) != 1)
602        return -EIO;
603
604    writew(0, baseAddr + key);
605    for (i = 0; i < 600; i++) {
606        if (readw(baseAddr + Magic_no) == Magic_code)
607            break;
608        msleep(10);
609    }
610    if (readw(baseAddr + Magic_no) != Magic_code)
611        return -EIO;
612
613    if (MOXA_IS_320(brd)) {
614        if (brd->busType == MOXA_BUS_TYPE_PCI) { /* ASIC board */
615            writew(0x3800, baseAddr + TMS320_PORT1);
616            writew(0x3900, baseAddr + TMS320_PORT2);
617            writew(28499, baseAddr + TMS320_CLOCK);
618        } else {
619            writew(0x3200, baseAddr + TMS320_PORT1);
620            writew(0x3400, baseAddr + TMS320_PORT2);
621            writew(19999, baseAddr + TMS320_CLOCK);
622        }
623    }
624    writew(1, baseAddr + Disable_IRQ);
625    writew(0, baseAddr + Magic_no);
626    for (i = 0; i < 500; i++) {
627        if (readw(baseAddr + Magic_no) == Magic_code)
628            break;
629        msleep(10);
630    }
631    if (readw(baseAddr + Magic_no) != Magic_code)
632        return -EIO;
633
634    if (MOXA_IS_320(brd)) {
635        j = readw(baseAddr + Module_cnt);
636        if (j <= 0)
637            return -EIO;
638        brd->numPorts = j * 8;
639        writew(j, baseAddr + Module_no);
640        writew(0, baseAddr + Magic_no);
641        for (i = 0; i < 600; i++) {
642            if (readw(baseAddr + Magic_no) == Magic_code)
643                break;
644            msleep(10);
645        }
646        if (readw(baseAddr + Magic_no) != Magic_code)
647            return -EIO;
648    }
649    brd->intNdx = baseAddr + IRQindex;
650    brd->intPend = baseAddr + IRQpending;
651    brd->intTable = baseAddr + IRQtable;
652
653    return 0;
654}
655
656static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,
657        size_t len)
658{
659    void __iomem *ofsAddr, *baseAddr = brd->basemem;
660    struct moxa_port *port;
661    int retval, i;
662
663    if (len % 2) {
664        printk(KERN_ERR "MOXA: bios length is not even\n");
665        return -EINVAL;
666    }
667
668    retval = moxa_real_load_code(brd, ptr, len); /* may change numPorts */
669    if (retval)
670        return retval;
671
672    switch (brd->boardType) {
673    case MOXA_BOARD_C218_ISA:
674    case MOXA_BOARD_C218_PCI:
675    case MOXA_BOARD_CP204J:
676        port = brd->ports;
677        for (i = 0; i < brd->numPorts; i++, port++) {
678            port->board = brd;
679            port->DCDState = 0;
680            port->tableAddr = baseAddr + Extern_table +
681                    Extern_size * i;
682            ofsAddr = port->tableAddr;
683            writew(C218rx_mask, ofsAddr + RX_mask);
684            writew(C218tx_mask, ofsAddr + TX_mask);
685            writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);
686            writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);
687
688            writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);
689            writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);
690
691        }
692        break;
693    default:
694        port = brd->ports;
695        for (i = 0; i < brd->numPorts; i++, port++) {
696            port->board = brd;
697            port->DCDState = 0;
698            port->tableAddr = baseAddr + Extern_table +
699                    Extern_size * i;
700            ofsAddr = port->tableAddr;
701            switch (brd->numPorts) {
702            case 8:
703                writew(C320p8rx_mask, ofsAddr + RX_mask);
704                writew(C320p8tx_mask, ofsAddr + TX_mask);
705                writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);
706                writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);
707                writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);
708                writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);
709
710                break;
711            case 16:
712                writew(C320p16rx_mask, ofsAddr + RX_mask);
713                writew(C320p16tx_mask, ofsAddr + TX_mask);
714                writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);
715                writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);
716                writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);
717                writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);
718                break;
719
720            case 24:
721                writew(C320p24rx_mask, ofsAddr + RX_mask);
722                writew(C320p24tx_mask, ofsAddr + TX_mask);
723                writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);
724                writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);
725                writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);
726                writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
727                break;
728            case 32:
729                writew(C320p32rx_mask, ofsAddr + RX_mask);
730                writew(C320p32tx_mask, ofsAddr + TX_mask);
731                writew(C320p32tx_ofs, ofsAddr + Ofs_txb);
732                writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);
733                writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);
734                writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);
735                writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
736                break;
737            }
738        }
739        break;
740    }
741    return 0;
742}
743
744static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)
745{
746    const void *ptr = fw->data;
747    char rsn[64];
748    u16 lens[5];
749    size_t len;
750    unsigned int a, lenp, lencnt;
751    int ret = -EINVAL;
752    struct {
753        __le32 magic; /* 0x34303430 */
754        u8 reserved1[2];
755        u8 type; /* UNIX = 3 */
756        u8 model; /* C218T=1, C320T=2, CP204=3 */
757        u8 reserved2[8];
758        __le16 len[5];
759    } const *hdr = ptr;
760
761    BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));
762
763    if (fw->size < MOXA_FW_HDRLEN) {
764        strcpy(rsn, "too short (even header won't fit)");
765        goto err;
766    }
767    if (hdr->magic != cpu_to_le32(0x30343034)) {
768        sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));
769        goto err;
770    }
771    if (hdr->type != 3) {
772        sprintf(rsn, "not for linux, type is %u", hdr->type);
773        goto err;
774    }
775    if (moxa_check_fw_model(brd, hdr->model)) {
776        sprintf(rsn, "not for this card, model is %u", hdr->model);
777        goto err;
778    }
779
780    len = MOXA_FW_HDRLEN;
781    lencnt = hdr->model == 2 ? 5 : 3;
782    for (a = 0; a < ARRAY_SIZE(lens); a++) {
783        lens[a] = le16_to_cpu(hdr->len[a]);
784        if (lens[a] && len + lens[a] <= fw->size &&
785                moxa_check_fw(&fw->data[len]))
786            printk(KERN_WARNING "MOXA firmware: unexpected input "
787                "at offset %u, but going on\n", (u32)len);
788        if (!lens[a] && a < lencnt) {
789            sprintf(rsn, "too few entries in fw file");
790            goto err;
791        }
792        len += lens[a];
793    }
794
795    if (len != fw->size) {
796        sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,
797                (u32)len);
798        goto err;
799    }
800
801    ptr += MOXA_FW_HDRLEN;
802    lenp = 0; /* bios */
803
804    strcpy(rsn, "read above");
805
806    ret = moxa_load_bios(brd, ptr, lens[lenp]);
807    if (ret)
808        goto err;
809
810    /* we skip the tty section (lens[1]), since we don't need it */
811    ptr += lens[lenp] + lens[lenp + 1];
812    lenp += 2; /* comm */
813
814    if (hdr->model == 2) {
815        ret = moxa_load_320b(brd, ptr, lens[lenp]);
816        if (ret)
817            goto err;
818        /* skip another tty */
819        ptr += lens[lenp] + lens[lenp + 1];
820        lenp += 2;
821    }
822
823    ret = moxa_load_code(brd, ptr, lens[lenp]);
824    if (ret)
825        goto err;
826
827    return 0;
828err:
829    printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);
830    return ret;
831}
832
833static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)
834{
835    const struct firmware *fw;
836    const char *file;
837    struct moxa_port *p;
838    unsigned int i, first_idx;
839    int ret;
840
841    brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),
842            GFP_KERNEL);
843    if (brd->ports == NULL) {
844        printk(KERN_ERR "cannot allocate memory for ports\n");
845        ret = -ENOMEM;
846        goto err;
847    }
848
849    for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {
850        tty_port_init(&p->port);
851        p->port.ops = &moxa_port_ops;
852        p->type = PORT_16550A;
853        p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
854    }
855
856    switch (brd->boardType) {
857    case MOXA_BOARD_C218_ISA:
858    case MOXA_BOARD_C218_PCI:
859        file = "c218tunx.cod";
860        break;
861    case MOXA_BOARD_CP204J:
862        file = "cp204unx.cod";
863        break;
864    default:
865        file = "c320tunx.cod";
866        break;
867    }
868
869    ret = request_firmware(&fw, file, dev);
870    if (ret) {
871        printk(KERN_ERR "MOXA: request_firmware failed. Make sure "
872                "you've placed '%s' file into your firmware "
873                "loader directory (e.g. /lib/firmware)\n",
874                file);
875        goto err_free;
876    }
877
878    ret = moxa_load_fw(brd, fw);
879
880    release_firmware(fw);
881
882    if (ret)
883        goto err_free;
884
885    spin_lock_bh(&moxa_lock);
886    brd->ready = 1;
887    if (!timer_pending(&moxaTimer))
888        mod_timer(&moxaTimer, jiffies + HZ / 50);
889    spin_unlock_bh(&moxa_lock);
890
891    first_idx = (brd - moxa_boards) * MAX_PORTS_PER_BOARD;
892    for (i = 0; i < brd->numPorts; i++)
893        tty_port_register_device(&brd->ports[i].port, moxaDriver,
894                first_idx + i, dev);
895
896    return 0;
897err_free:
898    for (i = 0; i < MAX_PORTS_PER_BOARD; i++)
899        tty_port_destroy(&brd->ports[i].port);
900    kfree(brd->ports);
901err:
902    return ret;
903}
904
905static void moxa_board_deinit(struct moxa_board_conf *brd)
906{
907    unsigned int a, opened, first_idx;
908
909    mutex_lock(&moxa_openlock);
910    spin_lock_bh(&moxa_lock);
911    brd->ready = 0;
912    spin_unlock_bh(&moxa_lock);
913
914    /* pci hot-un-plug support */
915    for (a = 0; a < brd->numPorts; a++)
916        if (brd->ports[a].port.flags & ASYNC_INITIALIZED) {
917            struct tty_struct *tty = tty_port_tty_get(
918                        &brd->ports[a].port);
919            if (tty) {
920                tty_hangup(tty);
921                tty_kref_put(tty);
922            }
923        }
924    for (a = 0; a < MAX_PORTS_PER_BOARD; a++)
925        tty_port_destroy(&brd->ports[a].port);
926    while (1) {
927        opened = 0;
928        for (a = 0; a < brd->numPorts; a++)
929            if (brd->ports[a].port.flags & ASYNC_INITIALIZED)
930                opened++;
931        mutex_unlock(&moxa_openlock);
932        if (!opened)
933            break;
934        msleep(50);
935        mutex_lock(&moxa_openlock);
936    }
937
938    first_idx = (brd - moxa_boards) * MAX_PORTS_PER_BOARD;
939    for (a = 0; a < brd->numPorts; a++)
940        tty_unregister_device(moxaDriver, first_idx + a);
941
942    iounmap(brd->basemem);
943    brd->basemem = NULL;
944    kfree(brd->ports);
945}
946
947#ifdef CONFIG_PCI
948static int moxa_pci_probe(struct pci_dev *pdev,
949        const struct pci_device_id *ent)
950{
951    struct moxa_board_conf *board;
952    unsigned int i;
953    int board_type = ent->driver_data;
954    int retval;
955
956    retval = pci_enable_device(pdev);
957    if (retval) {
958        dev_err(&pdev->dev, "can't enable pci device\n");
959        goto err;
960    }
961
962    for (i = 0; i < MAX_BOARDS; i++)
963        if (moxa_boards[i].basemem == NULL)
964            break;
965
966    retval = -ENODEV;
967    if (i >= MAX_BOARDS) {
968        dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "
969                "found. Board is ignored.\n", MAX_BOARDS);
970        goto err;
971    }
972
973    board = &moxa_boards[i];
974
975    retval = pci_request_region(pdev, 2, "moxa-base");
976    if (retval) {
977        dev_err(&pdev->dev, "can't request pci region 2\n");
978        goto err;
979    }
980
981    board->basemem = ioremap_nocache(pci_resource_start(pdev, 2), 0x4000);
982    if (board->basemem == NULL) {
983        dev_err(&pdev->dev, "can't remap io space 2\n");
984        retval = -ENOMEM;
985        goto err_reg;
986    }
987
988    board->boardType = board_type;
989    switch (board_type) {
990    case MOXA_BOARD_C218_ISA:
991    case MOXA_BOARD_C218_PCI:
992        board->numPorts = 8;
993        break;
994
995    case MOXA_BOARD_CP204J:
996        board->numPorts = 4;
997        break;
998    default:
999        board->numPorts = 0;
1000        break;
1001    }
1002    board->busType = MOXA_BUS_TYPE_PCI;
1003
1004    retval = moxa_init_board(board, &pdev->dev);
1005    if (retval)
1006        goto err_base;
1007
1008    pci_set_drvdata(pdev, board);
1009
1010    dev_info(&pdev->dev, "board '%s' ready (%u ports, firmware loaded)\n",
1011            moxa_brdname[board_type - 1], board->numPorts);
1012
1013    return 0;
1014err_base:
1015    iounmap(board->basemem);
1016    board->basemem = NULL;
1017err_reg:
1018    pci_release_region(pdev, 2);
1019err:
1020    return retval;
1021}
1022
1023static void moxa_pci_remove(struct pci_dev *pdev)
1024{
1025    struct moxa_board_conf *brd = pci_get_drvdata(pdev);
1026
1027    moxa_board_deinit(brd);
1028
1029    pci_release_region(pdev, 2);
1030}
1031
1032static struct pci_driver moxa_pci_driver = {
1033    .name = "moxa",
1034    .id_table = moxa_pcibrds,
1035    .probe = moxa_pci_probe,
1036    .remove = moxa_pci_remove
1037};
1038#endif /* CONFIG_PCI */
1039
1040static int __init moxa_init(void)
1041{
1042    unsigned int isabrds = 0;
1043    int retval = 0;
1044    struct moxa_board_conf *brd = moxa_boards;
1045    unsigned int i;
1046
1047    printk(KERN_INFO "MOXA Intellio family driver version %s\n",
1048            MOXA_VERSION);
1049
1050    tty_port_init(&moxa_service_port);
1051
1052    moxaDriver = tty_alloc_driver(MAX_PORTS + 1,
1053            TTY_DRIVER_REAL_RAW |
1054            TTY_DRIVER_DYNAMIC_DEV);
1055    if (IS_ERR(moxaDriver))
1056        return PTR_ERR(moxaDriver);
1057
1058    moxaDriver->name = "ttyMX";
1059    moxaDriver->major = ttymajor;
1060    moxaDriver->minor_start = 0;
1061    moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;
1062    moxaDriver->subtype = SERIAL_TYPE_NORMAL;
1063    moxaDriver->init_termios = tty_std_termios;
1064    moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
1065    moxaDriver->init_termios.c_ispeed = 9600;
1066    moxaDriver->init_termios.c_ospeed = 9600;
1067    tty_set_operations(moxaDriver, &moxa_ops);
1068    /* Having one more port only for ioctls is ugly */
1069    tty_port_link_device(&moxa_service_port, moxaDriver, MAX_PORTS);
1070
1071    if (tty_register_driver(moxaDriver)) {
1072        printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");
1073        put_tty_driver(moxaDriver);
1074        return -1;
1075    }
1076
1077    /* Find the boards defined from module args. */
1078
1079    for (i = 0; i < MAX_BOARDS; i++) {
1080        if (!baseaddr[i])
1081            break;
1082        if (type[i] == MOXA_BOARD_C218_ISA ||
1083                type[i] == MOXA_BOARD_C320_ISA) {
1084            pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",
1085                    isabrds + 1, moxa_brdname[type[i] - 1],
1086                    baseaddr[i]);
1087            brd->boardType = type[i];
1088            brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :
1089                    numports[i];
1090            brd->busType = MOXA_BUS_TYPE_ISA;
1091            brd->basemem = ioremap_nocache(baseaddr[i], 0x4000);
1092            if (!brd->basemem) {
1093                printk(KERN_ERR "MOXA: can't remap %lx\n",
1094                        baseaddr[i]);
1095                continue;
1096            }
1097            if (moxa_init_board(brd, NULL)) {
1098                iounmap(brd->basemem);
1099                brd->basemem = NULL;
1100                continue;
1101            }
1102
1103            printk(KERN_INFO "MOXA isa board found at 0x%.8lu and "
1104                    "ready (%u ports, firmware loaded)\n",
1105                    baseaddr[i], brd->numPorts);
1106
1107            brd++;
1108            isabrds++;
1109        }
1110    }
1111
1112#ifdef CONFIG_PCI
1113    retval = pci_register_driver(&moxa_pci_driver);
1114    if (retval) {
1115        printk(KERN_ERR "Can't register MOXA pci driver!\n");
1116        if (isabrds)
1117            retval = 0;
1118    }
1119#endif
1120
1121    return retval;
1122}
1123
1124static void __exit moxa_exit(void)
1125{
1126    unsigned int i;
1127
1128#ifdef CONFIG_PCI
1129    pci_unregister_driver(&moxa_pci_driver);
1130#endif
1131
1132    for (i = 0; i < MAX_BOARDS; i++) /* ISA boards */
1133        if (moxa_boards[i].ready)
1134            moxa_board_deinit(&moxa_boards[i]);
1135
1136    del_timer_sync(&moxaTimer);
1137
1138    if (tty_unregister_driver(moxaDriver))
1139        printk(KERN_ERR "Couldn't unregister MOXA Intellio family "
1140                "serial driver\n");
1141    put_tty_driver(moxaDriver);
1142}
1143
1144module_init(moxa_init);
1145module_exit(moxa_exit);
1146
1147static void moxa_shutdown(struct tty_port *port)
1148{
1149    struct moxa_port *ch = container_of(port, struct moxa_port, port);
1150        MoxaPortDisable(ch);
1151    MoxaPortFlushData(ch, 2);
1152}
1153
1154static int moxa_carrier_raised(struct tty_port *port)
1155{
1156    struct moxa_port *ch = container_of(port, struct moxa_port, port);
1157    int dcd;
1158
1159    spin_lock_irq(&port->lock);
1160    dcd = ch->DCDState;
1161    spin_unlock_irq(&port->lock);
1162    return dcd;
1163}
1164
1165static void moxa_dtr_rts(struct tty_port *port, int onoff)
1166{
1167    struct moxa_port *ch = container_of(port, struct moxa_port, port);
1168    MoxaPortLineCtrl(ch, onoff, onoff);
1169}
1170
1171
1172static int moxa_open(struct tty_struct *tty, struct file *filp)
1173{
1174    struct moxa_board_conf *brd;
1175    struct moxa_port *ch;
1176    int port;
1177
1178    port = tty->index;
1179    if (port == MAX_PORTS) {
1180        return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
1181    }
1182    if (mutex_lock_interruptible(&moxa_openlock))
1183        return -ERESTARTSYS;
1184    brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];
1185    if (!brd->ready) {
1186        mutex_unlock(&moxa_openlock);
1187        return -ENODEV;
1188    }
1189
1190    if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {
1191        mutex_unlock(&moxa_openlock);
1192        return -ENODEV;
1193    }
1194
1195    ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
1196    ch->port.count++;
1197    tty->driver_data = ch;
1198    tty_port_tty_set(&ch->port, tty);
1199    mutex_lock(&ch->port.mutex);
1200    if (!(ch->port.flags & ASYNC_INITIALIZED)) {
1201        ch->statusflags = 0;
1202        moxa_set_tty_param(tty, &tty->termios);
1203        MoxaPortLineCtrl(ch, 1, 1);
1204        MoxaPortEnable(ch);
1205        MoxaSetFifo(ch, ch->type == PORT_16550A);
1206        ch->port.flags |= ASYNC_INITIALIZED;
1207    }
1208    mutex_unlock(&ch->port.mutex);
1209    mutex_unlock(&moxa_openlock);
1210
1211    return tty_port_block_til_ready(&ch->port, tty, filp);
1212}
1213
1214static void moxa_close(struct tty_struct *tty, struct file *filp)
1215{
1216    struct moxa_port *ch = tty->driver_data;
1217    ch->cflag = tty->termios.c_cflag;
1218    tty_port_close(&ch->port, tty, filp);
1219}
1220
1221static int moxa_write(struct tty_struct *tty,
1222              const unsigned char *buf, int count)
1223{
1224    struct moxa_port *ch = tty->driver_data;
1225    unsigned long flags;
1226    int len;
1227
1228    if (ch == NULL)
1229        return 0;
1230
1231    spin_lock_irqsave(&moxa_lock, flags);
1232    len = MoxaPortWriteData(tty, buf, count);
1233    spin_unlock_irqrestore(&moxa_lock, flags);
1234
1235    set_bit(LOWWAIT, &ch->statusflags);
1236    return len;
1237}
1238
1239static int moxa_write_room(struct tty_struct *tty)
1240{
1241    struct moxa_port *ch;
1242
1243    if (tty->stopped)
1244        return 0;
1245    ch = tty->driver_data;
1246    if (ch == NULL)
1247        return 0;
1248    return MoxaPortTxFree(ch);
1249}
1250
1251static void moxa_flush_buffer(struct tty_struct *tty)
1252{
1253    struct moxa_port *ch = tty->driver_data;
1254
1255    if (ch == NULL)
1256        return;
1257    MoxaPortFlushData(ch, 1);
1258    tty_wakeup(tty);
1259}
1260
1261static int moxa_chars_in_buffer(struct tty_struct *tty)
1262{
1263    struct moxa_port *ch = tty->driver_data;
1264    int chars;
1265
1266    chars = MoxaPortTxQueue(ch);
1267    if (chars)
1268        /*
1269         * Make it possible to wakeup anything waiting for output
1270         * in tty_ioctl.c, etc.
1271         */
1272            set_bit(EMPTYWAIT, &ch->statusflags);
1273    return chars;
1274}
1275
1276static int moxa_tiocmget(struct tty_struct *tty)
1277{
1278    struct moxa_port *ch = tty->driver_data;
1279    int flag = 0, dtr, rts;
1280
1281    MoxaPortGetLineOut(ch, &dtr, &rts);
1282    if (dtr)
1283        flag |= TIOCM_DTR;
1284    if (rts)
1285        flag |= TIOCM_RTS;
1286    dtr = MoxaPortLineStatus(ch);
1287    if (dtr & 1)
1288        flag |= TIOCM_CTS;
1289    if (dtr & 2)
1290        flag |= TIOCM_DSR;
1291    if (dtr & 4)
1292        flag |= TIOCM_CD;
1293    return flag;
1294}
1295
1296static int moxa_tiocmset(struct tty_struct *tty,
1297             unsigned int set, unsigned int clear)
1298{
1299    struct moxa_port *ch;
1300    int dtr, rts;
1301
1302    mutex_lock(&moxa_openlock);
1303    ch = tty->driver_data;
1304    if (!ch) {
1305        mutex_unlock(&moxa_openlock);
1306        return -EINVAL;
1307    }
1308
1309    MoxaPortGetLineOut(ch, &dtr, &rts);
1310    if (set & TIOCM_RTS)
1311        rts = 1;
1312    if (set & TIOCM_DTR)
1313        dtr = 1;
1314    if (clear & TIOCM_RTS)
1315        rts = 0;
1316    if (clear & TIOCM_DTR)
1317        dtr = 0;
1318    MoxaPortLineCtrl(ch, dtr, rts);
1319    mutex_unlock(&moxa_openlock);
1320    return 0;
1321}
1322
1323static void moxa_set_termios(struct tty_struct *tty,
1324        struct ktermios *old_termios)
1325{
1326    struct moxa_port *ch = tty->driver_data;
1327
1328    if (ch == NULL)
1329        return;
1330    moxa_set_tty_param(tty, old_termios);
1331    if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
1332        wake_up_interruptible(&ch->port.open_wait);
1333}
1334
1335static void moxa_stop(struct tty_struct *tty)
1336{
1337    struct moxa_port *ch = tty->driver_data;
1338
1339    if (ch == NULL)
1340        return;
1341    MoxaPortTxDisable(ch);
1342    set_bit(TXSTOPPED, &ch->statusflags);
1343}
1344
1345
1346static void moxa_start(struct tty_struct *tty)
1347{
1348    struct moxa_port *ch = tty->driver_data;
1349
1350    if (ch == NULL)
1351        return;
1352
1353    if (!test_bit(TXSTOPPED, &ch->statusflags))
1354        return;
1355
1356    MoxaPortTxEnable(ch);
1357    clear_bit(TXSTOPPED, &ch->statusflags);
1358}
1359
1360static void moxa_hangup(struct tty_struct *tty)
1361{
1362    struct moxa_port *ch = tty->driver_data;
1363    tty_port_hangup(&ch->port);
1364}
1365
1366static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)
1367{
1368    struct tty_struct *tty;
1369    unsigned long flags;
1370    dcd = !!dcd;
1371
1372    spin_lock_irqsave(&p->port.lock, flags);
1373    if (dcd != p->DCDState) {
1374            p->DCDState = dcd;
1375            spin_unlock_irqrestore(&p->port.lock, flags);
1376        tty = tty_port_tty_get(&p->port);
1377        if (tty && !C_CLOCAL(tty) && !dcd)
1378            tty_hangup(tty);
1379        tty_kref_put(tty);
1380    }
1381    else
1382        spin_unlock_irqrestore(&p->port.lock, flags);
1383}
1384
1385static int moxa_poll_port(struct moxa_port *p, unsigned int handle,
1386        u16 __iomem *ip)
1387{
1388    struct tty_struct *tty = tty_port_tty_get(&p->port);
1389    void __iomem *ofsAddr;
1390    unsigned int inited = p->port.flags & ASYNC_INITIALIZED;
1391    u16 intr;
1392
1393    if (tty) {
1394        if (test_bit(EMPTYWAIT, &p->statusflags) &&
1395                MoxaPortTxQueue(p) == 0) {
1396            clear_bit(EMPTYWAIT, &p->statusflags);
1397            tty_wakeup(tty);
1398        }
1399        if (test_bit(LOWWAIT, &p->statusflags) && !tty->stopped &&
1400                MoxaPortTxQueue(p) <= WAKEUP_CHARS) {
1401            clear_bit(LOWWAIT, &p->statusflags);
1402            tty_wakeup(tty);
1403        }
1404
1405        if (inited && !test_bit(TTY_THROTTLED, &tty->flags) &&
1406                MoxaPortRxQueue(p) > 0) { /* RX */
1407            MoxaPortReadData(p);
1408            tty_schedule_flip(&p->port);
1409        }
1410    } else {
1411        clear_bit(EMPTYWAIT, &p->statusflags);
1412        MoxaPortFlushData(p, 0); /* flush RX */
1413    }
1414
1415    if (!handle) /* nothing else to do */
1416        goto put;
1417
1418    intr = readw(ip); /* port irq status */
1419    if (intr == 0)
1420        goto put;
1421
1422    writew(0, ip); /* ACK port */
1423    ofsAddr = p->tableAddr;
1424    if (intr & IntrTx) /* disable tx intr */
1425        writew(readw(ofsAddr + HostStat) & ~WakeupTx,
1426                ofsAddr + HostStat);
1427
1428    if (!inited)
1429        goto put;
1430
1431    if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) { /* BREAK */
1432        tty_insert_flip_char(&p->port, 0, TTY_BREAK);
1433        tty_schedule_flip(&p->port);
1434    }
1435
1436    if (intr & IntrLine)
1437        moxa_new_dcdstate(p, readb(ofsAddr + FlagStat) & DCD_state);
1438put:
1439    tty_kref_put(tty);
1440
1441    return 0;
1442}
1443
1444static void moxa_poll(unsigned long ignored)
1445{
1446    struct moxa_board_conf *brd;
1447    u16 __iomem *ip;
1448    unsigned int card, port, served = 0;
1449
1450    spin_lock(&moxa_lock);
1451    for (card = 0; card < MAX_BOARDS; card++) {
1452        brd = &moxa_boards[card];
1453        if (!brd->ready)
1454            continue;
1455
1456        served++;
1457
1458        ip = NULL;
1459        if (readb(brd->intPend) == 0xff)
1460            ip = brd->intTable + readb(brd->intNdx);
1461
1462        for (port = 0; port < brd->numPorts; port++)
1463            moxa_poll_port(&brd->ports[port], !!ip, ip + port);
1464
1465        if (ip)
1466            writeb(0, brd->intPend); /* ACK */
1467
1468        if (moxaLowWaterChk) {
1469            struct moxa_port *p = brd->ports;
1470            for (port = 0; port < brd->numPorts; port++, p++)
1471                if (p->lowChkFlag) {
1472                    p->lowChkFlag = 0;
1473                    moxa_low_water_check(p->tableAddr);
1474                }
1475        }
1476    }
1477    moxaLowWaterChk = 0;
1478
1479    if (served)
1480        mod_timer(&moxaTimer, jiffies + HZ / 50);
1481    spin_unlock(&moxa_lock);
1482}
1483
1484/******************************************************************************/
1485
1486static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)
1487{
1488    register struct ktermios *ts = &tty->termios;
1489    struct moxa_port *ch = tty->driver_data;
1490    int rts, cts, txflow, rxflow, xany, baud;
1491
1492    rts = cts = txflow = rxflow = xany = 0;
1493    if (ts->c_cflag & CRTSCTS)
1494        rts = cts = 1;
1495    if (ts->c_iflag & IXON)
1496        txflow = 1;
1497    if (ts->c_iflag & IXOFF)
1498        rxflow = 1;
1499    if (ts->c_iflag & IXANY)
1500        xany = 1;
1501
1502    /* Clear the features we don't support */
1503    ts->c_cflag &= ~CMSPAR;
1504    MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);
1505    baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));
1506    if (baud == -1)
1507        baud = tty_termios_baud_rate(old_termios);
1508    /* Not put the baud rate into the termios data */
1509    tty_encode_baud_rate(tty, baud, baud);
1510}
1511
1512/*****************************************************************************
1513 * Driver level functions: *
1514 *****************************************************************************/
1515
1516static void MoxaPortFlushData(struct moxa_port *port, int mode)
1517{
1518    void __iomem *ofsAddr;
1519    if (mode < 0 || mode > 2)
1520        return;
1521    ofsAddr = port->tableAddr;
1522    moxafunc(ofsAddr, FC_FlushQueue, mode);
1523    if (mode != 1) {
1524        port->lowChkFlag = 0;
1525        moxa_low_water_check(ofsAddr);
1526    }
1527}
1528
1529/*
1530 * Moxa Port Number Description:
1531 *
1532 * MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,
1533 * the port number using in MOXA driver functions will be 0 to 31 for
1534 * first MOXA board, 32 to 63 for second, 64 to 95 for third and 96
1535 * to 127 for fourth. For example, if you setup three MOXA boards,
1536 * first board is C218, second board is C320-16 and third board is
1537 * C320-32. The port number of first board (C218 - 8 ports) is from
1538 * 0 to 7. The port number of second board (C320 - 16 ports) is form
1539 * 32 to 47. The port number of third board (C320 - 32 ports) is from
1540 * 64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to
1541 * 127 will be invalid.
1542 *
1543 *
1544 * Moxa Functions Description:
1545 *
1546 * Function 1: Driver initialization routine, this routine must be
1547 * called when initialized driver.
1548 * Syntax:
1549 * void MoxaDriverInit();
1550 *
1551 *
1552 * Function 2: Moxa driver private IOCTL command processing.
1553 * Syntax:
1554 * int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);
1555 *
1556 * unsigned int cmd : IOCTL command
1557 * unsigned long arg : IOCTL argument
1558 * int port : port number (0 - 127)
1559 *
1560 * return: 0 (OK)
1561 * -EINVAL
1562 * -ENOIOCTLCMD
1563 *
1564 *
1565 * Function 6: Enable this port to start Tx/Rx data.
1566 * Syntax:
1567 * void MoxaPortEnable(int port);
1568 * int port : port number (0 - 127)
1569 *
1570 *
1571 * Function 7: Disable this port
1572 * Syntax:
1573 * void MoxaPortDisable(int port);
1574 * int port : port number (0 - 127)
1575 *
1576 *
1577 * Function 10: Setting baud rate of this port.
1578 * Syntax:
1579 * speed_t MoxaPortSetBaud(int port, speed_t baud);
1580 * int port : port number (0 - 127)
1581 * long baud : baud rate (50 - 115200)
1582 *
1583 * return: 0 : this port is invalid or baud < 50
1584 * 50 - 115200 : the real baud rate set to the port, if
1585 * the argument baud is large than maximun
1586 * available baud rate, the real setting
1587 * baud rate will be the maximun baud rate.
1588 *
1589 *
1590 * Function 12: Configure the port.
1591 * Syntax:
1592 * int MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);
1593 * int port : port number (0 - 127)
1594 * struct ktermios * termio : termio structure pointer
1595 * speed_t baud : baud rate
1596 *
1597 * return: -1 : this port is invalid or termio == NULL
1598 * 0 : setting O.K.
1599 *
1600 *
1601 * Function 13: Get the DTR/RTS state of this port.
1602 * Syntax:
1603 * int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);
1604 * int port : port number (0 - 127)
1605 * int * dtrState : pointer to INT to receive the current DTR
1606 * state. (if NULL, this function will not
1607 * write to this address)
1608 * int * rtsState : pointer to INT to receive the current RTS
1609 * state. (if NULL, this function will not
1610 * write to this address)
1611 *
1612 * return: -1 : this port is invalid
1613 * 0 : O.K.
1614 *
1615 *
1616 * Function 14: Setting the DTR/RTS output state of this port.
1617 * Syntax:
1618 * void MoxaPortLineCtrl(int port, int dtrState, int rtsState);
1619 * int port : port number (0 - 127)
1620 * int dtrState : DTR output state (0: off, 1: on)
1621 * int rtsState : RTS output state (0: off, 1: on)
1622 *
1623 *
1624 * Function 15: Setting the flow control of this port.
1625 * Syntax:
1626 * void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,
1627 * int txFlow,int xany);
1628 * int port : port number (0 - 127)
1629 * int rtsFlow : H/W RTS flow control (0: no, 1: yes)
1630 * int ctsFlow : H/W CTS flow control (0: no, 1: yes)
1631 * int rxFlow : S/W Rx XON/XOFF flow control (0: no, 1: yes)
1632 * int txFlow : S/W Tx XON/XOFF flow control (0: no, 1: yes)
1633 * int xany : S/W XANY flow control (0: no, 1: yes)
1634 *
1635 *
1636 * Function 16: Get ths line status of this port
1637 * Syntax:
1638 * int MoxaPortLineStatus(int port);
1639 * int port : port number (0 - 127)
1640 *
1641 * return: Bit 0 - CTS state (0: off, 1: on)
1642 * Bit 1 - DSR state (0: off, 1: on)
1643 * Bit 2 - DCD state (0: off, 1: on)
1644 *
1645 *
1646 * Function 19: Flush the Rx/Tx buffer data of this port.
1647 * Syntax:
1648 * void MoxaPortFlushData(int port, int mode);
1649 * int port : port number (0 - 127)
1650 * int mode
1651 * 0 : flush the Rx buffer
1652 * 1 : flush the Tx buffer
1653 * 2 : flush the Rx and Tx buffer
1654 *
1655 *
1656 * Function 20: Write data.
1657 * Syntax:
1658 * int MoxaPortWriteData(int port, unsigned char * buffer, int length);
1659 * int port : port number (0 - 127)
1660 * unsigned char * buffer : pointer to write data buffer.
1661 * int length : write data length
1662 *
1663 * return: 0 - length : real write data length
1664 *
1665 *
1666 * Function 21: Read data.
1667 * Syntax:
1668 * int MoxaPortReadData(int port, struct tty_struct *tty);
1669 * int port : port number (0 - 127)
1670 * struct tty_struct *tty : tty for data
1671 *
1672 * return: 0 - length : real read data length
1673 *
1674 *
1675 * Function 24: Get the Tx buffer current queued data bytes
1676 * Syntax:
1677 * int MoxaPortTxQueue(int port);
1678 * int port : port number (0 - 127)
1679 *
1680 * return: .. : Tx buffer current queued data bytes
1681 *
1682 *
1683 * Function 25: Get the Tx buffer current free space
1684 * Syntax:
1685 * int MoxaPortTxFree(int port);
1686 * int port : port number (0 - 127)
1687 *
1688 * return: .. : Tx buffer current free space
1689 *
1690 *
1691 * Function 26: Get the Rx buffer current queued data bytes
1692 * Syntax:
1693 * int MoxaPortRxQueue(int port);
1694 * int port : port number (0 - 127)
1695 *
1696 * return: .. : Rx buffer current queued data bytes
1697 *
1698 *
1699 * Function 28: Disable port data transmission.
1700 * Syntax:
1701 * void MoxaPortTxDisable(int port);
1702 * int port : port number (0 - 127)
1703 *
1704 *
1705 * Function 29: Enable port data transmission.
1706 * Syntax:
1707 * void MoxaPortTxEnable(int port);
1708 * int port : port number (0 - 127)
1709 *
1710 *
1711 * Function 31: Get the received BREAK signal count and reset it.
1712 * Syntax:
1713 * int MoxaPortResetBrkCnt(int port);
1714 * int port : port number (0 - 127)
1715 *
1716 * return: 0 - .. : BREAK signal count
1717 *
1718 *
1719 */
1720
1721static void MoxaPortEnable(struct moxa_port *port)
1722{
1723    void __iomem *ofsAddr;
1724    u16 lowwater = 512;
1725
1726    ofsAddr = port->tableAddr;
1727    writew(lowwater, ofsAddr + Low_water);
1728    if (MOXA_IS_320(port->board))
1729        moxafunc(ofsAddr, FC_SetBreakIrq, 0);
1730    else
1731        writew(readw(ofsAddr + HostStat) | WakeupBreak,
1732                ofsAddr + HostStat);
1733
1734    moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
1735    moxafunc(ofsAddr, FC_FlushQueue, 2);
1736
1737    moxafunc(ofsAddr, FC_EnableCH, Magic_code);
1738    MoxaPortLineStatus(port);
1739}
1740
1741static void MoxaPortDisable(struct moxa_port *port)
1742{
1743    void __iomem *ofsAddr = port->tableAddr;
1744
1745    moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */
1746    moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);
1747    writew(0, ofsAddr + HostStat);
1748    moxafunc(ofsAddr, FC_DisableCH, Magic_code);
1749}
1750
1751static speed_t MoxaPortSetBaud(struct moxa_port *port, speed_t baud)
1752{
1753    void __iomem *ofsAddr = port->tableAddr;
1754    unsigned int clock, val;
1755    speed_t max;
1756
1757    max = MOXA_IS_320(port->board) ? 460800 : 921600;
1758    if (baud < 50)
1759        return 0;
1760    if (baud > max)
1761        baud = max;
1762    clock = 921600;
1763    val = clock / baud;
1764    moxafunc(ofsAddr, FC_SetBaud, val);
1765    baud = clock / val;
1766    return baud;
1767}
1768
1769static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
1770        speed_t baud)
1771{
1772    void __iomem *ofsAddr;
1773    tcflag_t mode = 0;
1774
1775    ofsAddr = port->tableAddr;
1776
1777    mode = termio->c_cflag & CSIZE;
1778    if (mode == CS5)
1779        mode = MX_CS5;
1780    else if (mode == CS6)
1781        mode = MX_CS6;
1782    else if (mode == CS7)
1783        mode = MX_CS7;
1784    else if (mode == CS8)
1785        mode = MX_CS8;
1786
1787    if (termio->c_cflag & CSTOPB) {
1788        if (mode == MX_CS5)
1789            mode |= MX_STOP15;
1790        else
1791            mode |= MX_STOP2;
1792    } else
1793        mode |= MX_STOP1;
1794
1795    if (termio->c_cflag & PARENB) {
1796        if (termio->c_cflag & PARODD)
1797            mode |= MX_PARODD;
1798        else
1799            mode |= MX_PAREVEN;
1800    } else
1801        mode |= MX_PARNONE;
1802
1803    moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);
1804
1805    if (MOXA_IS_320(port->board) && baud >= 921600)
1806        return -1;
1807
1808    baud = MoxaPortSetBaud(port, baud);
1809
1810    if (termio->c_iflag & (IXON | IXOFF | IXANY)) {
1811            spin_lock_irq(&moxafunc_lock);
1812        writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);
1813        writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);
1814        writeb(FC_SetXonXoff, ofsAddr + FuncCode);
1815        moxa_wait_finish(ofsAddr);
1816        spin_unlock_irq(&moxafunc_lock);
1817
1818    }
1819    return baud;
1820}
1821
1822static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,
1823        int *rtsState)
1824{
1825    if (dtrState)
1826        *dtrState = !!(port->lineCtrl & DTR_ON);
1827    if (rtsState)
1828        *rtsState = !!(port->lineCtrl & RTS_ON);
1829
1830    return 0;
1831}
1832
1833static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)
1834{
1835    u8 mode = 0;
1836
1837    if (dtr)
1838        mode |= DTR_ON;
1839    if (rts)
1840        mode |= RTS_ON;
1841    port->lineCtrl = mode;
1842    moxafunc(port->tableAddr, FC_LineControl, mode);
1843}
1844
1845static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,
1846        int txflow, int rxflow, int txany)
1847{
1848    int mode = 0;
1849
1850    if (rts)
1851        mode |= RTS_FlowCtl;
1852    if (cts)
1853        mode |= CTS_FlowCtl;
1854    if (txflow)
1855        mode |= Tx_FlowCtl;
1856    if (rxflow)
1857        mode |= Rx_FlowCtl;
1858    if (txany)
1859        mode |= IXM_IXANY;
1860    moxafunc(port->tableAddr, FC_SetFlowCtl, mode);
1861}
1862
1863static int MoxaPortLineStatus(struct moxa_port *port)
1864{
1865    void __iomem *ofsAddr;
1866    int val;
1867
1868    ofsAddr = port->tableAddr;
1869    if (MOXA_IS_320(port->board))
1870        val = moxafuncret(ofsAddr, FC_LineStatus, 0);
1871    else
1872        val = readw(ofsAddr + FlagStat) >> 4;
1873    val &= 0x0B;
1874    if (val & 8)
1875        val |= 4;
1876    moxa_new_dcdstate(port, val & 8);
1877    val &= 7;
1878    return val;
1879}
1880
1881static int MoxaPortWriteData(struct tty_struct *tty,
1882        const unsigned char *buffer, int len)
1883{
1884    struct moxa_port *port = tty->driver_data;
1885    void __iomem *baseAddr, *ofsAddr, *ofs;
1886    unsigned int c, total;
1887    u16 head, tail, tx_mask, spage, epage;
1888    u16 pageno, pageofs, bufhead;
1889
1890    ofsAddr = port->tableAddr;
1891    baseAddr = port->board->basemem;
1892    tx_mask = readw(ofsAddr + TX_mask);
1893    spage = readw(ofsAddr + Page_txb);
1894    epage = readw(ofsAddr + EndPage_txb);
1895    tail = readw(ofsAddr + TXwptr);
1896    head = readw(ofsAddr + TXrptr);
1897    c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);
1898    if (c > len)
1899        c = len;
1900    moxaLog.txcnt[port->port.tty->index] += c;
1901    total = c;
1902    if (spage == epage) {
1903        bufhead = readw(ofsAddr + Ofs_txb);
1904        writew(spage, baseAddr + Control_reg);
1905        while (c > 0) {
1906            if (head > tail)
1907                len = head - tail - 1;
1908            else
1909                len = tx_mask + 1 - tail;
1910            len = (c > len) ? len : c;
1911            ofs = baseAddr + DynPage_addr + bufhead + tail;
1912            memcpy_toio(ofs, buffer, len);
1913            buffer += len;
1914            tail = (tail + len) & tx_mask;
1915            c -= len;
1916        }
1917    } else {
1918        pageno = spage + (tail >> 13);
1919        pageofs = tail & Page_mask;
1920        while (c > 0) {
1921            len = Page_size - pageofs;
1922            if (len > c)
1923                len = c;
1924            writeb(pageno, baseAddr + Control_reg);
1925            ofs = baseAddr + DynPage_addr + pageofs;
1926            memcpy_toio(ofs, buffer, len);
1927            buffer += len;
1928            if (++pageno == epage)
1929                pageno = spage;
1930            pageofs = 0;
1931            c -= len;
1932        }
1933        tail = (tail + total) & tx_mask;
1934    }
1935    writew(tail, ofsAddr + TXwptr);
1936    writeb(1, ofsAddr + CD180TXirq); /* start to send */
1937    return total;
1938}
1939
1940static int MoxaPortReadData(struct moxa_port *port)
1941{
1942    struct tty_struct *tty = port->port.tty;
1943    unsigned char *dst;
1944    void __iomem *baseAddr, *ofsAddr, *ofs;
1945    unsigned int count, len, total;
1946    u16 tail, rx_mask, spage, epage;
1947    u16 pageno, pageofs, bufhead, head;
1948
1949    ofsAddr = port->tableAddr;
1950    baseAddr = port->board->basemem;
1951    head = readw(ofsAddr + RXrptr);
1952    tail = readw(ofsAddr + RXwptr);
1953    rx_mask = readw(ofsAddr + RX_mask);
1954    spage = readw(ofsAddr + Page_rxb);
1955    epage = readw(ofsAddr + EndPage_rxb);
1956    count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);
1957    if (count == 0)
1958        return 0;
1959
1960    total = count;
1961    moxaLog.rxcnt[tty->index] += total;
1962    if (spage == epage) {
1963        bufhead = readw(ofsAddr + Ofs_rxb);
1964        writew(spage, baseAddr + Control_reg);
1965        while (count > 0) {
1966            ofs = baseAddr + DynPage_addr + bufhead + head;
1967            len = (tail >= head) ? (tail - head) :
1968                    (rx_mask + 1 - head);
1969            len = tty_prepare_flip_string(&port->port, &dst,
1970                    min(len, count));
1971            memcpy_fromio(dst, ofs, len);
1972            head = (head + len) & rx_mask;
1973            count -= len;
1974        }
1975    } else {
1976        pageno = spage + (head >> 13);
1977        pageofs = head & Page_mask;
1978        while (count > 0) {
1979            writew(pageno, baseAddr + Control_reg);
1980            ofs = baseAddr + DynPage_addr + pageofs;
1981            len = tty_prepare_flip_string(&port->port, &dst,
1982                    min(Page_size - pageofs, count));
1983            memcpy_fromio(dst, ofs, len);
1984
1985            count -= len;
1986            pageofs = (pageofs + len) & Page_mask;
1987            if (pageofs == 0 && ++pageno == epage)
1988                pageno = spage;
1989        }
1990        head = (head + total) & rx_mask;
1991    }
1992    writew(head, ofsAddr + RXrptr);
1993    if (readb(ofsAddr + FlagStat) & Xoff_state) {
1994        moxaLowWaterChk = 1;
1995        port->lowChkFlag = 1;
1996    }
1997    return total;
1998}
1999
2000
2001static int MoxaPortTxQueue(struct moxa_port *port)
2002{
2003    void __iomem *ofsAddr = port->tableAddr;
2004    u16 rptr, wptr, mask;
2005
2006    rptr = readw(ofsAddr + TXrptr);
2007    wptr = readw(ofsAddr + TXwptr);
2008    mask = readw(ofsAddr + TX_mask);
2009    return (wptr - rptr) & mask;
2010}
2011
2012static int MoxaPortTxFree(struct moxa_port *port)
2013{
2014    void __iomem *ofsAddr = port->tableAddr;
2015    u16 rptr, wptr, mask;
2016
2017    rptr = readw(ofsAddr + TXrptr);
2018    wptr = readw(ofsAddr + TXwptr);
2019    mask = readw(ofsAddr + TX_mask);
2020    return mask - ((wptr - rptr) & mask);
2021}
2022
2023static int MoxaPortRxQueue(struct moxa_port *port)
2024{
2025    void __iomem *ofsAddr = port->tableAddr;
2026    u16 rptr, wptr, mask;
2027
2028    rptr = readw(ofsAddr + RXrptr);
2029    wptr = readw(ofsAddr + RXwptr);
2030    mask = readw(ofsAddr + RX_mask);
2031    return (wptr - rptr) & mask;
2032}
2033
2034static void MoxaPortTxDisable(struct moxa_port *port)
2035{
2036    moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);
2037}
2038
2039static void MoxaPortTxEnable(struct moxa_port *port)
2040{
2041    moxafunc(port->tableAddr, FC_SetXonState, Magic_code);
2042}
2043
2044static int moxa_get_serial_info(struct moxa_port *info,
2045        struct serial_struct __user *retinfo)
2046{
2047    struct serial_struct tmp = {
2048        .type = info->type,
2049        .line = info->port.tty->index,
2050        .flags = info->port.flags,
2051        .baud_base = 921600,
2052        .close_delay = info->port.close_delay
2053    };
2054    return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2055}
2056
2057
2058static int moxa_set_serial_info(struct moxa_port *info,
2059        struct serial_struct __user *new_info)
2060{
2061    struct serial_struct new_serial;
2062
2063    if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2064        return -EFAULT;
2065
2066    if (new_serial.irq != 0 || new_serial.port != 0 ||
2067            new_serial.custom_divisor != 0 ||
2068            new_serial.baud_base != 921600)
2069        return -EPERM;
2070
2071    if (!capable(CAP_SYS_ADMIN)) {
2072        if (((new_serial.flags & ~ASYNC_USR_MASK) !=
2073             (info->port.flags & ~ASYNC_USR_MASK)))
2074            return -EPERM;
2075    } else
2076        info->port.close_delay = new_serial.close_delay * HZ / 100;
2077
2078    new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
2079    new_serial.flags |= (info->port.flags & ASYNC_FLAGS);
2080
2081    MoxaSetFifo(info, new_serial.type == PORT_16550A);
2082
2083    info->type = new_serial.type;
2084    return 0;
2085}
2086
2087
2088
2089/*****************************************************************************
2090 * Static local functions: *
2091 *****************************************************************************/
2092
2093static void MoxaSetFifo(struct moxa_port *port, int enable)
2094{
2095    void __iomem *ofsAddr = port->tableAddr;
2096
2097    if (!enable) {
2098        moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);
2099        moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);
2100    } else {
2101        moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);
2102        moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);
2103    }
2104}
2105

Archive Download this file



interactive