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