rt serial 的编写

/*
 * Copyright (C) 2005-2007 Jan Kiszka <jan.kiszka@web.de>.
 *
 * Xenomai is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Xenomai is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Xenomai; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <linux/version.h>
#include <linux/module.h>
#include <linux/ioport.h>
#include <asm/io.h>

#include <rtdm/rtserial.h>
#include <rtdm/rtdm_driver.h>

#define RT_16550_DRIVER_NAME    "xeno_16550A"

#define MAX_DEVICES        8

#define IN_BUFFER_SIZE        4096
#define OUT_BUFFER_SIZE        4096

#define DEFAULT_BAUD_BASE    115200
#define DEFAULT_TX_FIFO        16

#define PARITY_MASK        0x03
#define DATA_BITS_MASK        0x03
#define STOP_BITS_MASK        0x01
#define FIFO_MASK        0xC0
#define EVENT_MASK        0x0F

#define LCR_DLAB        0x80

#define FCR_FIFO        0x01
#define FCR_RESET_RX        0x02
#define FCR_RESET_TX        0x04

#define IER_RX            0x01
#define IER_TX            0x02
#define IER_STAT        0x04
#define IER_MODEM        0x08

#define IIR_MODEM        0x00
#define IIR_PIRQ        0x01
#define IIR_TX            0x02
#define IIR_RX            0x04
#define IIR_STAT        0x06
#define IIR_MASK        0x07

#define RHR            0    /* Receive Holding Buffer */
#define THR            0    /* Transmit Holding Buffer */
#define DLL            0    /* Divisor Latch LSB */
#define IER            1    /* Interrupt Enable Register */
#define DLM            1    /* Divisor Latch MSB */
#define IIR            2    /* Interrupt Id Register */
#define FCR            2    /* Fifo Control Register */
#define LCR            3    /* Line Control Register */
#define MCR            4    /* Modem Control Register */
#define LSR            5    /* Line Status Register */
#define MSR            6    /* Modem Status Register */

struct rt_16550_context {
    struct rtser_config config;    /* current device configuration */

rtdm_irq_t irq_handle;        /* device IRQ handle */
    rtdm_lock_t lock;        /* lock to protect context struct */

unsigned long base_addr;    /* hardware IO base address */
#ifdef CONFIG_XENO_DRIVERS_16550A_ANY
    int io_mode;            /* hardware IO-access mode */
#endif
    int tx_fifo;            /* cached global tx_fifo[<device>] */

int in_head;            /* RX ring buffer, head pointer */
    int in_tail;            /* RX ring buffer, tail pointer */
    size_t in_npend;        /* pending bytes in RX ring */
    int in_nwait;            /* bytes the user waits for */
    rtdm_event_t in_event;        /* raised to unblock reader */
    char in_buf[IN_BUFFER_SIZE];    /* RX ring buffer */
    volatile unsigned long in_lock;    /* single-reader lock */
    uint64_t *in_history;        /* RX timestamp buffer */

int out_head;            /* TX ring buffer, head pointer */
    int out_tail;            /* TX ring buffer, tail pointer */
    size_t out_npend;        /* pending bytes in TX ring */
    rtdm_event_t out_event;        /* raised to unblock writer */
    char out_buf[OUT_BUFFER_SIZE];    /* TX ring buffer */
    rtdm_mutex_t out_lock;        /* single-writer mutex */

uint64_t last_timestamp;    /* timestamp of last event */
    int ioc_events;            /* recorded events */
    rtdm_event_t ioc_event;        /* raised to unblock event waiter */
    volatile unsigned long ioc_event_lock;    /* single-waiter lock */

int ier_status;            /* IER cache */
    int mcr_status;            /* MCR cache */
    int status;            /* cache for LSR + soft-states */
    int saved_errors;        /* error cache for RTIOC_GET_STATUS */
};

static const struct rtser_config default_config = {
    0xFFFF, RTSER_DEF_BAUD, RTSER_DEF_PARITY, RTSER_DEF_BITS,
    RTSER_DEF_STOPB, RTSER_DEF_HAND, RTSER_DEF_FIFO_DEPTH, 0,
    RTSER_DEF_TIMEOUT, RTSER_DEF_TIMEOUT, RTSER_DEF_TIMEOUT,
    RTSER_DEF_TIMESTAMP_HISTORY, RTSER_DEF_EVENT_MASK, RTSER_DEF_RS485
};

static struct rtdm_device *device[MAX_DEVICES];

static unsigned int irq[MAX_DEVICES];
static unsigned long irqtype[MAX_DEVICES] = {
    [0 ... MAX_DEVICES-1] = RTDM_IRQTYPE_SHARED | RTDM_IRQTYPE_EDGE
};
static unsigned int baud_base[MAX_DEVICES];
static int tx_fifo[MAX_DEVICES];
static unsigned int start_index;

compat_module_param_array(irq, uint, MAX_DEVICES, 0400);
compat_module_param_array(baud_base, uint, MAX_DEVICES, 0400);
compat_module_param_array(tx_fifo, int, MAX_DEVICES, 0400);

MODULE_PARM_DESC(irq, "IRQ numbers of the serial devices");
MODULE_PARM_DESC(baud_base, "Maximum baud rate of the serial device "
         "(internal clock rate / 16)");
MODULE_PARM_DESC(tx_fifo, "Transmitter FIFO size");

module_param(start_index, uint, 0400);
MODULE_PARM_DESC(start_index, "First device instance number to be used");

MODULE_LICENSE("GPL");
MODULE_AUTHOR("jan.kiszka@web.de");

#include "16550A_io.h"
#include "16550A_pnp.h"
#include "16550A_pci.h"

static inline int rt_16550_rx_interrupt(struct rt_16550_context *ctx,
                    uint64_t * timestamp)
{
    unsigned long base = ctx->base_addr;
    int mode = rt_16550_io_mode_from_ctx(ctx);
    int rbytes = 0;
    int lsr = 0;
    int c;

do {
        c = rt_16550_reg_in(mode, base, RHR);    /* read input char */

ctx->in_buf[ctx->in_tail] = c;
        if (ctx->in_history)
            ctx->in_history[ctx->in_tail] = *timestamp;
        ctx->in_tail = (ctx->in_tail + 1) & (IN_BUFFER_SIZE - 1);

if (++ctx->in_npend > IN_BUFFER_SIZE) {
            lsr |= RTSER_SOFT_OVERRUN_ERR;
            ctx->in_npend--;
        }

rbytes++;
        lsr &= ~RTSER_LSR_DATA;
        lsr |= (rt_16550_reg_in(mode, base, LSR) &
            (RTSER_LSR_DATA | RTSER_LSR_OVERRUN_ERR |
             RTSER_LSR_PARITY_ERR | RTSER_LSR_FRAMING_ERR |
             RTSER_LSR_BREAK_IND));
    } while (testbits(lsr, RTSER_LSR_DATA));

/* save new errors */
    ctx->status |= lsr;

/* If we are enforcing the RTSCTS control flow and the input
       buffer is busy above the specified high watermark, clear
       RTS. */
/*    if (uart->i_count >= uart->config.rts_hiwm &&
        (uart->config.handshake & RT_UART_RTSCTS) != 0 &&
        (uart->modem & MCR_RTS) != 0) {
        uart->modem &= ~MCR_RTS;
        rt_16550_reg_out(mode, base, MCR, uart->modem);
    }*/

return rbytes;
}

static inline void rt_16550_tx_interrupt(struct rt_16550_context *ctx)
{
    int c;
    int count;
    unsigned long base = ctx->base_addr;
    int mode = rt_16550_io_mode_from_ctx(ctx);

/*    if (uart->modem & MSR_CTS)*/
    {
        for (count = ctx->tx_fifo;
             (count > 0) && (ctx->out_npend > 0);
             count--, ctx->out_npend--) {
            c = ctx->out_buf[ctx->out_head++];
            rt_16550_reg_out(mode, base, THR, c);
            ctx->out_head &= (OUT_BUFFER_SIZE - 1);
        }
    }
}

static inline void rt_16550_stat_interrupt(struct rt_16550_context *ctx)
{
    unsigned long base = ctx->base_addr;
    int mode = rt_16550_io_mode_from_ctx(ctx);

ctx->status |= (rt_16550_reg_in(mode, base, LSR) &
            (RTSER_LSR_OVERRUN_ERR | RTSER_LSR_PARITY_ERR |
             RTSER_LSR_FRAMING_ERR | RTSER_LSR_BREAK_IND));
}

static int rt_16550_interrupt(rtdm_irq_t * irq_context)
{
    struct rt_16550_context *ctx;
    unsigned long base;
    int mode;
    int iir;
    uint64_t timestamp = rtdm_clock_read();
    int rbytes = 0;
    int events = 0;
    int modem;
    int ret = RTDM_IRQ_NONE;

ctx = rtdm_irq_get_arg(irq_context, struct rt_16550_context);
    base = ctx->base_addr;
    mode = rt_16550_io_mode_from_ctx(ctx);

rtdm_lock_get(&ctx->lock);

while (1) {
        iir = rt_16550_reg_in(mode, base, IIR) & IIR_MASK;
        if (testbits(iir, IIR_PIRQ))
            break;

if (iir == IIR_RX) {
            rbytes += rt_16550_rx_interrupt(ctx, &timestamp);
            events |= RTSER_EVENT_RXPEND;
        } else if (iir == IIR_STAT)
            rt_16550_stat_interrupt(ctx);
        else if (iir == IIR_TX)
            rt_16550_tx_interrupt(ctx);
        else if (iir == IIR_MODEM) {
            modem = rt_16550_reg_in(mode, base, MSR);
            if (modem & (modem << 4))
                events |= RTSER_EVENT_MODEMHI;
            if ((modem ^ 0xF0) & (modem << 4))
                events |= RTSER_EVENT_MODEMLO;
        }

ret = RTDM_IRQ_HANDLED;
    }

if (ctx->in_nwait > 0) {
        if ((ctx->in_nwait <= rbytes) || ctx->status) {
            ctx->in_nwait = 0;
            rtdm_event_signal(&ctx->in_event);
        } else
            ctx->in_nwait -= rbytes;
    }

if (ctx->status) {
        events |= RTSER_EVENT_ERRPEND;
        ctx->ier_status &= ~IER_STAT;
    }

if (testbits(events, ctx->config.event_mask)) {
        int old_events = ctx->ioc_events;

ctx->last_timestamp = timestamp;
        ctx->ioc_events = events;

if (!old_events)
            rtdm_event_signal(&ctx->ioc_event);
    }

if (testbits(ctx->ier_status, IER_TX) && (ctx->out_npend == 0)) {
        /* mask transmitter empty interrupt */
        ctx->ier_status &= ~IER_TX;

rtdm_event_signal(&ctx->out_event);
    }

/* update interrupt mask */
    rt_16550_reg_out(mode, base, IER, ctx->ier_status);

rtdm_lock_put(&ctx->lock);

return ret;
}

static int rt_16550_set_config(struct rt_16550_context *ctx,
                   const struct rtser_config *config,
                   uint64_t **in_history_ptr)
{
    rtdm_lockctx_t lock_ctx;
    unsigned long base = ctx->base_addr;
    int mode = rt_16550_io_mode_from_ctx(ctx);
    int err = 0;

/* make line configuration atomic and IRQ-safe */
    rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

if (testbits(config->config_mask, RTSER_SET_BAUD)) {
        int dev_id = container_of(((void *)ctx),
                      struct rtdm_dev_context,
                      dev_private)->device->device_id;
        int baud_div;

ctx->config.baud_rate = config->baud_rate;
        baud_div = (baud_base[dev_id] + (ctx->config.baud_rate>>1)) /
            ctx->config.baud_rate;
        rt_16550_reg_out(mode, base, LCR, LCR_DLAB);
        rt_16550_reg_out(mode, base, DLL, baud_div & 0xff);
        rt_16550_reg_out(mode, base, DLM, baud_div >> 8);
    }

if (testbits(config->config_mask, RTSER_SET_PARITY))
        ctx->config.parity = config->parity & PARITY_MASK;
    if (testbits(config->config_mask, RTSER_SET_DATA_BITS))
        ctx->config.data_bits = config->data_bits & DATA_BITS_MASK;
    if (testbits(config->config_mask, RTSER_SET_STOP_BITS))
        ctx->config.stop_bits = config->stop_bits & STOP_BITS_MASK;

if (testbits(config->config_mask, RTSER_SET_PARITY |
                      RTSER_SET_DATA_BITS |
                      RTSER_SET_STOP_BITS |
                      RTSER_SET_BAUD)) {
        rt_16550_reg_out(mode, base, LCR,
                 (ctx->config.parity << 3) |
                 (ctx->config.stop_bits << 2) |
                 ctx->config.data_bits);
        ctx->status = 0;
        ctx->ioc_events &= ~RTSER_EVENT_ERRPEND;
    }

if (testbits(config->config_mask, RTSER_SET_FIFO_DEPTH)) {
        ctx->config.fifo_depth = config->fifo_depth & FIFO_MASK;
        rt_16550_reg_out(mode, base, FCR,
                 FCR_FIFO | FCR_RESET_RX | FCR_RESET_TX);
        rt_16550_reg_out(mode, base, FCR,
                 FCR_FIFO | ctx->config.fifo_depth);
    }

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

/* Timeout manipulation is not atomic. The user is supposed to take
       care not to use and change timeouts at the same time. */
    if (testbits(config->config_mask, RTSER_SET_TIMEOUT_RX))
        ctx->config.rx_timeout = config->rx_timeout;
    if (testbits(config->config_mask, RTSER_SET_TIMEOUT_TX))
        ctx->config.tx_timeout = config->tx_timeout;
    if (testbits(config->config_mask, RTSER_SET_TIMEOUT_EVENT))
        ctx->config.event_timeout = config->event_timeout;

if (testbits(config->config_mask, RTSER_SET_TIMESTAMP_HISTORY)) {
        /* change timestamp history atomically */
        rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

if (testbits
            (config->timestamp_history, RTSER_RX_TIMESTAMP_HISTORY)) {
            if (!ctx->in_history) {
                ctx->in_history = *in_history_ptr;
                *in_history_ptr = NULL;
                if (!ctx->in_history)
                    err = -ENOMEM;
            }
        } else {
            *in_history_ptr = ctx->in_history;
            ctx->in_history = NULL;
        }

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);
    }

if (testbits(config->config_mask, RTSER_SET_EVENT_MASK)) {
        /* change event mask atomically */
        rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

ctx->config.event_mask = config->event_mask & EVENT_MASK;
        ctx->ioc_events = 0;

if (testbits(config->event_mask, RTSER_EVENT_RXPEND) &&
            (ctx->in_npend > 0))
            ctx->ioc_events |= RTSER_EVENT_RXPEND;

if (testbits(config->event_mask, RTSER_EVENT_ERRPEND)
            && ctx->status)
            ctx->ioc_events |= RTSER_EVENT_ERRPEND;

if (testbits(config->event_mask,
                 RTSER_EVENT_MODEMHI | RTSER_EVENT_MODEMLO))
            /* enable modem status interrupt */
            ctx->ier_status |= IER_MODEM;
        else
            /* disable modem status interrupt */
            ctx->ier_status &= ~IER_MODEM;
        rt_16550_reg_out(mode, base, IER, ctx->ier_status);

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);
    }

if (testbits(config->config_mask, RTSER_SET_HANDSHAKE)) {
        /* change handshake atomically */
        rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

ctx->config.handshake = config->handshake;

switch (ctx->config.handshake) {
        case RTSER_RTSCTS_HAND:
            // ...?

default:    /* RTSER_NO_HAND */
            ctx->mcr_status =
                RTSER_MCR_DTR | RTSER_MCR_RTS | RTSER_MCR_OUT2;
            break;
        }
        rt_16550_reg_out(mode, base, MCR, ctx->mcr_status);

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);
    }

return err;
}

void rt_16550_cleanup_ctx(struct rt_16550_context *ctx)
{
    rtdm_event_destroy(&ctx->in_event);
    rtdm_event_destroy(&ctx->out_event);
    rtdm_event_destroy(&ctx->ioc_event);
    rtdm_mutex_destroy(&ctx->out_lock);
}

int rt_16550_open(struct rtdm_dev_context *context,
          rtdm_user_info_t * user_info, int oflags)
{
    struct rt_16550_context *ctx;
    int dev_id = context->device->device_id;
    int err;
    uint64_t *dummy;
    rtdm_lockctx_t lock_ctx;

ctx = (struct rt_16550_context *)context->dev_private;

/* IPC initialisation - cannot fail with used parameters */
    rtdm_lock_init(&ctx->lock);
    rtdm_event_init(&ctx->in_event, 0);
    rtdm_event_init(&ctx->out_event, 0);
    rtdm_event_init(&ctx->ioc_event, 0);
    rtdm_mutex_init(&ctx->out_lock);

rt_16550_init_io_ctx(dev_id, ctx);

ctx->tx_fifo = tx_fifo[dev_id];

ctx->in_head = 0;
    ctx->in_tail = 0;
    ctx->in_npend = 0;
    ctx->in_nwait = 0;
    ctx->in_lock = 0;
    ctx->in_history = NULL;

ctx->out_head = 0;
    ctx->out_tail = 0;
    ctx->out_npend = 0;

ctx->ioc_events = 0;
    ctx->ioc_event_lock = 0;
    ctx->status = 0;
    ctx->saved_errors = 0;

rt_16550_set_config(ctx, &default_config, &dummy);

err = rtdm_irq_request(&ctx->irq_handle, irq[dev_id],
                   rt_16550_interrupt, irqtype[dev_id],
                   context->device->proc_name, ctx);
    if (err) {
        /* reset DTR and RTS */
        rt_16550_reg_out(rt_16550_io_mode_from_ctx(ctx), ctx->base_addr,
                 MCR, 0);

rt_16550_cleanup_ctx(ctx);

return err;
    }

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

/* enable interrupts */
    ctx->ier_status = IER_RX;
    rt_16550_reg_out(rt_16550_io_mode_from_ctx(ctx), ctx->base_addr, IER,
             IER_RX);

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

return 0;
}

int rt_16550_close(struct rtdm_dev_context *context,
           rtdm_user_info_t * user_info)
{
    struct rt_16550_context *ctx;
    unsigned long base;
    int mode;
    uint64_t *in_history;
    rtdm_lockctx_t lock_ctx;

ctx = (struct rt_16550_context *)context->dev_private;
    base = ctx->base_addr;
    mode = rt_16550_io_mode_from_ctx(ctx);

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

/* reset DTR and RTS */
    rt_16550_reg_out(mode, base, MCR, 0);

/* mask all UART interrupts and clear pending ones. */
    rt_16550_reg_out(mode, base, IER, 0);
    rt_16550_reg_in(mode, base, IIR);
    rt_16550_reg_in(mode, base, LSR);
    rt_16550_reg_in(mode, base, RHR);
    rt_16550_reg_in(mode, base, MSR);

in_history = ctx->in_history;
    ctx->in_history = NULL;

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

rtdm_irq_free(&ctx->irq_handle);

rt_16550_cleanup_ctx(ctx);

kfree(in_history);

return 0;
}

int rt_16550_ioctl(struct rtdm_dev_context *context,
           rtdm_user_info_t * user_info,
           unsigned int request, void *arg)
{
    rtdm_lockctx_t lock_ctx;
    struct rt_16550_context *ctx;
    int err = 0;
    unsigned long base;
    int mode;

ctx = (struct rt_16550_context *)context->dev_private;
    base = ctx->base_addr;
    mode = rt_16550_io_mode_from_ctx(ctx);

switch (request) {
    case RTSER_RTIOC_GET_CONFIG:
        if (user_info)
            err =
                rtdm_safe_copy_to_user(user_info, arg,
                           &ctx->config,
                           sizeof(struct
                              rtser_config));
        else
            memcpy(arg, &ctx->config,
                   sizeof(struct rtser_config));
        break;

case RTSER_RTIOC_SET_CONFIG: {
        struct rtser_config *config;
        struct rtser_config config_buf;
        uint64_t *hist_buf = NULL;

config = (struct rtser_config *)arg;

if (user_info) {
            err =
                rtdm_safe_copy_from_user(user_info, &config_buf,
                             arg,
                             sizeof(struct
                                rtser_config));
            if (err)
                return err;

config = &config_buf;
        }

if (testbits(config->config_mask, RTSER_SET_BAUD) &&
            (config->baud_rate >
             baud_base[context->device->device_id] ||
             config->baud_rate <= 0))
            /* invalid baudrate for this port */
            return -EINVAL;

if (testbits(config->config_mask,
                 RTSER_SET_TIMESTAMP_HISTORY)) {
            /*
             * Reflect the call to non-RT as we will likely
             * allocate or free the buffer.
             */
            if (rtdm_in_rt_context())
                return -ENOSYS;

if (testbits(config->timestamp_history,
                     RTSER_RX_TIMESTAMP_HISTORY))
                hist_buf = kmalloc(IN_BUFFER_SIZE *
                           sizeof(nanosecs_abs_t),
                           GFP_KERNEL);
        }

rt_16550_set_config(ctx, config, &hist_buf);

if (hist_buf)
            kfree(hist_buf);

break;
    }

case RTSER_RTIOC_GET_STATUS: {
        int status;

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

status = ctx->saved_errors | ctx->status;
        ctx->status = 0;
        ctx->saved_errors = 0;
        ctx->ioc_events &= ~RTSER_EVENT_ERRPEND;

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

if (user_info) {
            struct rtser_status status_buf;

status_buf.line_status =
                rt_16550_reg_in(mode, base, LSR) | status;
            status_buf.modem_status =
                rt_16550_reg_in(mode, base, MSR);

err =
                rtdm_safe_copy_to_user(user_info, arg,
                           &status_buf,
                           sizeof(struct
                              rtser_status));
        } else {
            ((struct rtser_status *)arg)->line_status =
                rt_16550_reg_in(mode, base, LSR) | status;
            ((struct rtser_status *)arg)->modem_status =
                rt_16550_reg_in(mode, base, MSR);
        }
        break;
    }

case RTSER_RTIOC_GET_CONTROL:
        if (user_info)
            err =
                rtdm_safe_copy_to_user(user_info, arg,
                           &ctx->mcr_status,
                           sizeof(int));
        else
            *(int *)arg = ctx->mcr_status;

break;

case RTSER_RTIOC_SET_CONTROL: {
        int new_mcr = (long)arg;

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);
        ctx->mcr_status = new_mcr;
        rt_16550_reg_out(mode, base, MCR, new_mcr);
        rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);
        break;
    }

case RTSER_RTIOC_WAIT_EVENT: {
        struct rtser_event ev = { .rxpend_timestamp = 0 };
        rtdm_toseq_t timeout_seq;

if (!rtdm_in_rt_context())
            return -ENOSYS;

/* Only one waiter allowed, stop any further attempts here. */
        if (test_and_set_bit(0, &ctx->ioc_event_lock))
            return -EBUSY;

rtdm_toseq_init(&timeout_seq, ctx->config.event_timeout);

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

while (!ctx->ioc_events) {
            /* Only enable error interrupt
               when the user waits for it. */
            if (testbits(ctx->config.event_mask,
                     RTSER_EVENT_ERRPEND)) {
                ctx->ier_status |= IER_STAT;
                rt_16550_reg_out(mode, base, IER,
                         ctx->ier_status);
            }

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

err = rtdm_event_timedwait(&ctx->ioc_event,
                           ctx->config.event_timeout,
                           &timeout_seq);
            if (err) {
                /* Device has been closed? */
                if (err == -EIDRM)
                    err = -EBADF;
                goto wait_unlock_out;
            }

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);
        }

ev.events = ctx->ioc_events;
        ctx->ioc_events &=
            ~(RTSER_EVENT_MODEMHI | RTSER_EVENT_MODEMLO);

ev.last_timestamp = ctx->last_timestamp;
        ev.rx_pending = ctx->in_npend;

if (ctx->in_history)
            ev.rxpend_timestamp = ctx->in_history[ctx->in_head];

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

if (user_info)
            err =
                rtdm_safe_copy_to_user(user_info, arg, &ev,
                           sizeof(struct
                              rtser_event));
            else
                memcpy(arg, &ev, sizeof(struct rtser_event));

wait_unlock_out:
        /* release the simple event waiter lock */
        clear_bit(0, &ctx->ioc_event_lock);
        break;
    }

case RTSER_RTIOC_BREAK_CTL: {
        int lcr = ((long)arg & RTSER_BREAK_SET) << 6;

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

lcr |=
            (ctx->config.parity << 3) | (ctx->config.stop_bits << 2) |
            ctx->config.data_bits;

rt_16550_reg_out(mode, base, LCR, lcr);

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);
        break;
    }

case RTIOC_PURGE: {
        int fcr = 0;

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);
        if ((long)arg & RTDM_PURGE_RX_BUFFER) {
            ctx->in_head = 0;
            ctx->in_tail = 0;
            ctx->in_npend = 0;
            ctx->status = 0;
            fcr |= FCR_FIFO | FCR_RESET_RX;
            rt_16550_reg_in(mode, base, RHR);
        }
        if ((long)arg & RTDM_PURGE_TX_BUFFER) {
            ctx->out_head = 0;
            ctx->out_tail = 0;
            ctx->out_npend = 0;
            fcr |= FCR_FIFO | FCR_RESET_TX;
        }
        if (fcr) {
            rt_16550_reg_out(mode, base, FCR, fcr);
            rt_16550_reg_out(mode, base, FCR,
                     FCR_FIFO | ctx->config.fifo_depth);
        }
        rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);
        break;
    }

default:
        err = -ENOTTY;
    }

return err;
}

ssize_t rt_16550_read(struct rtdm_dev_context * context,
              rtdm_user_info_t * user_info, void *buf, size_t nbyte)
{
    struct rt_16550_context *ctx;
    rtdm_lockctx_t lock_ctx;
    size_t read = 0;
    int pending;
    int block;
    int subblock;
    int in_pos;
    char *out_pos = (char *)buf;
    rtdm_toseq_t timeout_seq;
    ssize_t ret = -EAGAIN;    /* for non-blocking read */
    int nonblocking;

if (nbyte == 0)
        return 0;

if (user_info && !rtdm_rw_user_ok(user_info, buf, nbyte))
        return -EFAULT;

ctx = (struct rt_16550_context *)context->dev_private;

rtdm_toseq_init(&timeout_seq, ctx->config.rx_timeout);

/* non-blocking is handled separately here */
    nonblocking = (ctx->config.rx_timeout < 0);

/* only one reader allowed, stop any further attempts here */
    if (test_and_set_bit(0, &ctx->in_lock))
        return -EBUSY;

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

while (1) {
        /* switch on error interrupt - the user is ready to listen */
        if (!testbits(ctx->ier_status, IER_STAT)) {
            ctx->ier_status |= IER_STAT;
            rt_16550_reg_out(rt_16550_io_mode_from_ctx(ctx),
                     ctx->base_addr, IER,
                     ctx->ier_status);
        }

if (ctx->status) {
            if (testbits(ctx->status, RTSER_LSR_BREAK_IND))
                ret = -EPIPE;
            else
                ret = -EIO;
            ctx->saved_errors = ctx->status &
                (RTSER_LSR_OVERRUN_ERR | RTSER_LSR_PARITY_ERR |
                 RTSER_LSR_FRAMING_ERR | RTSER_SOFT_OVERRUN_ERR);
            ctx->status = 0;
            break;
        }

pending = ctx->in_npend;

if (pending > 0) {
            block = subblock = (pending <= nbyte) ? pending : nbyte;
            in_pos = ctx->in_head;

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

/* Do we have to wrap around the buffer end? */
            if (in_pos + subblock > IN_BUFFER_SIZE) {
                /* Treat the block between head and buffer end
                   separately. */
                subblock = IN_BUFFER_SIZE - in_pos;

if (user_info) {
                    if (rtdm_copy_to_user
                        (user_info, out_pos,
                         &ctx->in_buf[in_pos],
                         subblock) != 0) {
                        ret = -EFAULT;
                        goto break_unlocked;
                    }
                } else
                    memcpy(out_pos, &ctx->in_buf[in_pos],
                           subblock);

read += subblock;
                out_pos += subblock;

subblock = block - subblock;
                in_pos = 0;
            }

if (user_info) {
                if (rtdm_copy_to_user(user_info, out_pos,
                              &ctx->in_buf[in_pos],
                              subblock) != 0) {
                    ret = -EFAULT;
                    goto break_unlocked;
                }
            } else
                memcpy(out_pos, &ctx->in_buf[in_pos], subblock);

read += subblock;
            out_pos += subblock;
            nbyte -= block;

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

ctx->in_head =
                (ctx->in_head + block) & (IN_BUFFER_SIZE - 1);
            if ((ctx->in_npend -= block) == 0)
                ctx->ioc_events &= ~RTSER_EVENT_RXPEND;

if (nbyte == 0)
                break; /* All requested bytes read. */

continue;
        }

if (nonblocking)
            /* ret was set to EAGAIN in case of a real
               non-blocking call or contains the error
               returned by rtdm_event_wait[_until] */
            break;

ctx->in_nwait = nbyte;

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

ret = rtdm_event_timedwait(&ctx->in_event,
                       ctx->config.rx_timeout,
                       &timeout_seq);
        if (ret < 0) {
            if (ret == -EIDRM) {
                /* Device has been closed -
                   return immediately. */
                return -EBADF;
            }

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

nonblocking = 1;
            if (ctx->in_npend > 0) {
                /* Final turn: collect pending bytes
                   before exit. */
                continue;
            }

ctx->in_nwait = 0;
            break;
        }

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);
    }

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

break_unlocked:
    /* Release the simple reader lock, */
    clear_bit(0, &ctx->in_lock);

if ((read > 0) && ((ret == 0) || (ret == -EAGAIN) ||
               (ret == -ETIMEDOUT) || (ret == -EINTR)))
        ret = read;

return ret;
}

ssize_t rt_16550_write(struct rtdm_dev_context * context,
               rtdm_user_info_t * user_info, const void *buf,
               size_t nbyte)
{
    struct rt_16550_context *ctx;
    rtdm_lockctx_t lock_ctx;
    size_t written = 0;
    int free;
    int block;
    int subblock;
    int out_pos;
    char *in_pos = (char *)buf;
    rtdm_toseq_t timeout_seq;
    ssize_t ret;

if (nbyte == 0)
        return 0;

if (user_info && !rtdm_read_user_ok(user_info, buf, nbyte))
        return -EFAULT;

ctx = (struct rt_16550_context *)context->dev_private;

rtdm_toseq_init(&timeout_seq, ctx->config.rx_timeout);

/* Make write operation atomic. */
    ret = rtdm_mutex_timedlock(&ctx->out_lock, ctx->config.rx_timeout,
                   &timeout_seq);
    if (ret)
        return ret;

while (nbyte > 0) {
        rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

free = OUT_BUFFER_SIZE - ctx->out_npend;

if (free > 0) {
            block = subblock = (nbyte <= free) ? nbyte : free;
            out_pos = ctx->out_tail;

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

/* Do we have to wrap around the buffer end? */
            if (out_pos + subblock > OUT_BUFFER_SIZE) {
                /* Treat the block between head and buffer
                   end separately. */
                subblock = OUT_BUFFER_SIZE - out_pos;

if (user_info) {
                    if (rtdm_copy_from_user
                        (user_info,
                         &ctx->out_buf[out_pos],
                         in_pos, subblock) != 0) {
                        ret = -EFAULT;
                        break;
                    }
                } else
                    memcpy(&ctx->out_buf[out_pos], in_pos,
                           subblock);

written += subblock;
                in_pos += subblock;

subblock = block - subblock;
                out_pos = 0;
            }

if (user_info) {
                if (rtdm_copy_from_user
                    (user_info, &ctx->out_buf[out_pos],
                     in_pos, subblock) != 0) {
                    ret = -EFAULT;
                    break;
                }
            } else
                memcpy(&ctx->out_buf[out_pos], in_pos, block);

written += subblock;
            in_pos += subblock;
            nbyte -= block;

rtdm_lock_get_irqsave(&ctx->lock, lock_ctx);

ctx->out_tail =
                (ctx->out_tail + block) & (OUT_BUFFER_SIZE - 1);
            ctx->out_npend += block;

/* unmask tx interrupt */
            ctx->ier_status |= IER_TX;
            rt_16550_reg_out(rt_16550_io_mode_from_ctx(ctx),
                     ctx->base_addr, IER,
                     ctx->ier_status);

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);
            continue;
        }

rtdm_lock_put_irqrestore(&ctx->lock, lock_ctx);

ret =
            rtdm_event_timedwait(&ctx->out_event,
                     ctx->config.tx_timeout,
                     &timeout_seq);
        if (ret < 0) {
            if (ret == -EIDRM) {
                /* Device has been closed -
                   return immediately. */
                return -EBADF;
            }
            if (ret == -EWOULDBLOCK) {
                /* Fix error code for non-blocking mode. */
                ret = -EAGAIN;
            }
            break;
        }
    }

rtdm_mutex_unlock(&ctx->out_lock);

if ((written > 0) && ((ret == 0) || (ret == -EAGAIN) ||
                  (ret == -ETIMEDOUT) || (ret == -EINTR)))
        ret = written;

return ret;
}

static const struct rtdm_device __initdata device_tmpl = {
    .struct_version        = RTDM_DEVICE_STRUCT_VER,

.device_flags        = RTDM_NAMED_DEVICE | RTDM_EXCLUSIVE,
    .context_size        = sizeof(struct rt_16550_context),
    .device_name        = "",

.open_nrt        = rt_16550_open,

.ops = {
        .close_nrt    = rt_16550_close,

.ioctl_rt    = rt_16550_ioctl,
        .ioctl_nrt    = rt_16550_ioctl,

.read_rt    = rt_16550_read,

.write_rt    = rt_16550_write,
    },

.device_class        = RTDM_CLASS_SERIAL,
    .device_sub_class    = RTDM_SUBCLASS_16550A,
    .profile_version    = RTSER_PROFILE_VER,
    .driver_name        = RT_16550_DRIVER_NAME,
    .driver_version        = RTDM_DRIVER_VER(1, 5, 2),
    .peripheral_name    = "UART 16550A",
    .provider_name        = "Jan Kiszka",
};

void rt_16550_exit(void);

int __init rt_16550_init(void)
{
    struct rtdm_device *dev;
    unsigned long base;
    int mode;
    int err;
    int i;

rt_16550_pnp_init();
    rt_16550_pci_init();

for (i = 0; i < MAX_DEVICES; i++) {
        if (!rt_16550_addr_param(i))
            continue;

err = -EINVAL;
        if (!irq[i] || !rt_16550_addr_param_valid(i))
            goto cleanup_out;

dev = kmalloc(sizeof(struct rtdm_device), GFP_KERNEL);
        err = -ENOMEM;
        if (!dev)
            goto cleanup_out;

memcpy(dev, &device_tmpl, sizeof(struct rtdm_device));
        snprintf(dev->device_name, RTDM_MAX_DEVNAME_LEN, "rtser%d",
             start_index + i);
        dev->device_id = i;

dev->proc_name = dev->device_name;

err = rt_16550_init_io(i, dev->device_name);
        if (err)
            goto kfree_out;

if (baud_base[i] == 0)
            baud_base[i] = DEFAULT_BAUD_BASE;

if (tx_fifo[i] == 0)
            tx_fifo[i] = DEFAULT_TX_FIFO;

/* Mask all UART interrupts and clear pending ones. */
        base = rt_16550_base_addr(i);
        mode = rt_16550_io_mode(i);
        rt_16550_reg_out(mode, base, IER, 0);
        rt_16550_reg_in(mode, base, IIR);
        rt_16550_reg_in(mode, base, LSR);
        rt_16550_reg_in(mode, base, RHR);
        rt_16550_reg_in(mode, base, MSR);

err = rtdm_dev_register(dev);

if (err)
            goto release_io_out;

device[i] = dev;
    }

return 0;

release_io_out:
    rt_16550_release_io(i);

kfree_out:
    kfree(dev);

cleanup_out:
    rt_16550_exit();

return err;
}

void rt_16550_exit(void)
{
    int i;

for (i = 0; i < MAX_DEVICES; i++)
        if (device[i]) {
            rtdm_dev_unregister(device[i], 1000);
            rt_16550_release_io(i);
            kfree(device[i]);
        }

rt_16550_pci_cleanup();
    rt_16550_pnp_cleanup();
}

module_init(rt_16550_init);
module_exit(rt_16550_exit);