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, ×tamp);
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);
