2005-04-17 00:20:36 +02:00
|
|
|
/*****************************************************************************/
|
|
|
|
/*
|
|
|
|
* moxa.c -- MOXA Intellio family multiport serial driver.
|
|
|
|
*
|
2008-04-30 09:53:48 +02:00
|
|
|
* Copyright (C) 1999-2000 Moxa Technologies (support@moxa.com).
|
|
|
|
* Copyright (c) 2007 Jiri Slaby <jirislaby@gmail.com>
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* This code is loosely based on the Linux serial driver, written by
|
|
|
|
* Linus Torvalds, Theodore T'so and others.
|
|
|
|
*
|
|
|
|
* This program 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MOXA Intellio Series Driver
|
|
|
|
* for : LINUX
|
|
|
|
* date : 1999/1/7
|
|
|
|
* version : 5.1
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/errno.h>
|
2008-04-30 09:53:39 +02:00
|
|
|
#include <linux/firmware.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/serial.h>
|
|
|
|
#include <linux/tty_driver.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
#include "moxa.h"
|
|
|
|
|
2008-04-30 09:53:48 +02:00
|
|
|
#define MOXA_VERSION "6.0k"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
#define MOXA_FW_HDRLEN 32
|
|
|
|
|
2007-02-10 10:45:31 +01:00
|
|
|
#define MOXAMAJOR 172
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-02-10 10:45:31 +01:00
|
|
|
#define MAX_BOARDS 4 /* Don't change this value */
|
2005-04-17 00:20:36 +02:00
|
|
|
#define MAX_PORTS_PER_BOARD 32 /* Don't change this value */
|
2007-02-10 10:45:31 +01:00
|
|
|
#define MAX_PORTS (MAX_BOARDS * MAX_PORTS_PER_BOARD)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:47 +02:00
|
|
|
#define MOXA_IS_320(brd) ((brd)->boardType == MOXA_BOARD_C320_ISA || \
|
|
|
|
(brd)->boardType == MOXA_BOARD_C320_PCI)
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Define the Moxa PCI vendor and device IDs.
|
|
|
|
*/
|
2007-02-10 10:45:31 +01:00
|
|
|
#define MOXA_BUS_TYPE_ISA 0
|
|
|
|
#define MOXA_BUS_TYPE_PCI 1
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
enum {
|
|
|
|
MOXA_BOARD_C218_PCI = 1,
|
|
|
|
MOXA_BOARD_C218_ISA,
|
|
|
|
MOXA_BOARD_C320_PCI,
|
|
|
|
MOXA_BOARD_C320_ISA,
|
|
|
|
MOXA_BOARD_CP204J,
|
|
|
|
};
|
|
|
|
|
|
|
|
static char *moxa_brdname[] =
|
|
|
|
{
|
|
|
|
"C218 Turbo PCI series",
|
|
|
|
"C218 Turbo ISA series",
|
|
|
|
"C320 Turbo PCI series",
|
|
|
|
"C320 Turbo ISA series",
|
|
|
|
"CP-204J series",
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
static struct pci_device_id moxa_pcibrds[] = {
|
2007-02-10 10:45:30 +01:00
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),
|
|
|
|
.driver_data = MOXA_BOARD_C218_PCI },
|
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),
|
|
|
|
.driver_data = MOXA_BOARD_C320_PCI },
|
|
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),
|
|
|
|
.driver_data = MOXA_BOARD_CP204J },
|
2005-04-17 00:20:36 +02:00
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, moxa_pcibrds);
|
|
|
|
#endif /* CONFIG_PCI */
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
struct moxa_port;
|
|
|
|
|
2007-02-10 10:45:33 +01:00
|
|
|
static struct moxa_board_conf {
|
2005-04-17 00:20:36 +02:00
|
|
|
int boardType;
|
|
|
|
int numPorts;
|
|
|
|
int busType;
|
2007-02-10 10:45:33 +01:00
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
unsigned int ready;
|
2007-02-10 10:45:33 +01:00
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
struct moxa_port *ports;
|
|
|
|
|
2007-02-10 10:45:33 +01:00
|
|
|
void __iomem *basemem;
|
|
|
|
void __iomem *intNdx;
|
|
|
|
void __iomem *intPend;
|
|
|
|
void __iomem *intTable;
|
|
|
|
} moxa_boards[MAX_BOARDS];
|
|
|
|
|
|
|
|
struct mxser_mstatus {
|
|
|
|
tcflag_t cflag;
|
|
|
|
int cts;
|
|
|
|
int dsr;
|
|
|
|
int ri;
|
|
|
|
int dcd;
|
2007-02-10 10:45:30 +01:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-02-10 10:45:33 +01:00
|
|
|
struct moxaq_str {
|
|
|
|
int inq;
|
|
|
|
int outq;
|
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-02-10 10:45:33 +01:00
|
|
|
struct moxa_port {
|
2008-07-16 22:56:02 +02:00
|
|
|
struct tty_port port;
|
2008-04-30 09:53:40 +02:00
|
|
|
struct moxa_board_conf *board;
|
2008-04-30 09:53:43 +02:00
|
|
|
void __iomem *tableAddr;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
int type;
|
|
|
|
int cflag;
|
2008-04-30 09:53:43 +02:00
|
|
|
unsigned long statusflags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
u8 DCDState;
|
|
|
|
u8 lineCtrl;
|
|
|
|
u8 lowChkFlag;
|
2007-02-10 10:45:33 +01:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
struct mon_str {
|
|
|
|
int tick;
|
|
|
|
int rxcnt[MAX_PORTS];
|
|
|
|
int txcnt[MAX_PORTS];
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* statusflags */
|
|
|
|
#define TXSTOPPED 0x1
|
|
|
|
#define LOWWAIT 0x2
|
|
|
|
#define EMPTYWAIT 0x4
|
|
|
|
#define THROTTLE 0x8
|
|
|
|
|
|
|
|
#define SERIAL_DO_RESTART
|
|
|
|
|
|
|
|
#define WAKEUP_CHARS 256
|
|
|
|
|
|
|
|
static int ttymajor = MOXAMAJOR;
|
2008-04-30 09:53:43 +02:00
|
|
|
static struct mon_str moxaLog;
|
|
|
|
static unsigned int moxaFuncTout = HZ / 2;
|
2008-04-30 09:53:43 +02:00
|
|
|
static unsigned int moxaLowWaterChk;
|
2008-04-30 09:53:45 +02:00
|
|
|
static DEFINE_MUTEX(moxa_openlock);
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Variables for insmod */
|
|
|
|
#ifdef MODULE
|
2008-04-30 09:53:37 +02:00
|
|
|
static unsigned long baseaddr[MAX_BOARDS];
|
|
|
|
static unsigned int type[MAX_BOARDS];
|
|
|
|
static unsigned int numports[MAX_BOARDS];
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
MODULE_AUTHOR("William Chen");
|
|
|
|
MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#ifdef MODULE
|
2008-04-30 09:53:37 +02:00
|
|
|
module_param_array(type, uint, NULL, 0);
|
|
|
|
MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
|
|
|
|
module_param_array(baseaddr, ulong, NULL, 0);
|
|
|
|
MODULE_PARM_DESC(baseaddr, "base address");
|
|
|
|
module_param_array(numports, uint, NULL, 0);
|
|
|
|
MODULE_PARM_DESC(numports, "numports (ignored for C218)");
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
module_param(ttymajor, int, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* static functions:
|
|
|
|
*/
|
|
|
|
static int moxa_open(struct tty_struct *, struct file *);
|
|
|
|
static void moxa_close(struct tty_struct *, struct file *);
|
|
|
|
static int moxa_write(struct tty_struct *, const unsigned char *, int);
|
|
|
|
static int moxa_write_room(struct tty_struct *);
|
|
|
|
static void moxa_flush_buffer(struct tty_struct *);
|
|
|
|
static int moxa_chars_in_buffer(struct tty_struct *);
|
|
|
|
static void moxa_throttle(struct tty_struct *);
|
|
|
|
static void moxa_unthrottle(struct tty_struct *);
|
2006-12-08 11:38:45 +01:00
|
|
|
static void moxa_set_termios(struct tty_struct *, struct ktermios *);
|
2005-04-17 00:20:36 +02:00
|
|
|
static void moxa_stop(struct tty_struct *);
|
|
|
|
static void moxa_start(struct tty_struct *);
|
|
|
|
static void moxa_hangup(struct tty_struct *);
|
|
|
|
static int moxa_tiocmget(struct tty_struct *tty, struct file *file);
|
|
|
|
static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int set, unsigned int clear);
|
|
|
|
static void moxa_poll(unsigned long);
|
2008-02-08 13:18:43 +01:00
|
|
|
static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);
|
2007-10-18 12:06:24 +02:00
|
|
|
static void moxa_setup_empty_event(struct tty_struct *);
|
2008-10-13 11:39:58 +02:00
|
|
|
static void moxa_shut_down(struct tty_struct *);
|
2009-01-02 14:45:05 +01:00
|
|
|
static int moxa_carrier_raised(struct tty_port *);
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* moxa board interface functions:
|
|
|
|
*/
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortEnable(struct moxa_port *);
|
|
|
|
static void MoxaPortDisable(struct moxa_port *);
|
|
|
|
static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);
|
|
|
|
static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);
|
|
|
|
static void MoxaPortLineCtrl(struct moxa_port *, int, int);
|
|
|
|
static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
|
|
|
|
static int MoxaPortLineStatus(struct moxa_port *);
|
|
|
|
static void MoxaPortFlushData(struct moxa_port *, int);
|
2008-10-13 11:39:58 +02:00
|
|
|
static int MoxaPortWriteData(struct tty_struct *, const unsigned char *, int);
|
2008-04-30 09:53:43 +02:00
|
|
|
static int MoxaPortReadData(struct moxa_port *);
|
2008-04-30 09:53:40 +02:00
|
|
|
static int MoxaPortTxQueue(struct moxa_port *);
|
|
|
|
static int MoxaPortRxQueue(struct moxa_port *);
|
|
|
|
static int MoxaPortTxFree(struct moxa_port *);
|
|
|
|
static void MoxaPortTxDisable(struct moxa_port *);
|
|
|
|
static void MoxaPortTxEnable(struct moxa_port *);
|
2007-02-10 10:45:33 +01:00
|
|
|
static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);
|
|
|
|
static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaSetFifo(struct moxa_port *port, int enable);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
/*
|
|
|
|
* I/O functions
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void moxa_wait_finish(void __iomem *ofsAddr)
|
|
|
|
{
|
|
|
|
unsigned long end = jiffies + moxaFuncTout;
|
|
|
|
|
|
|
|
while (readw(ofsAddr + FuncCode) != 0)
|
|
|
|
if (time_after(jiffies, end))
|
|
|
|
return;
|
|
|
|
if (readw(ofsAddr + FuncCode) != 0 && printk_ratelimit())
|
|
|
|
printk(KERN_WARNING "moxa function expired\n");
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:46 +02:00
|
|
|
static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)
|
2008-04-30 09:53:43 +02:00
|
|
|
{
|
|
|
|
writew(arg, ofsAddr + FuncArg);
|
|
|
|
writew(cmd, ofsAddr + FuncCode);
|
|
|
|
moxa_wait_finish(ofsAddr);
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
static void moxa_low_water_check(void __iomem *ofsAddr)
|
|
|
|
{
|
|
|
|
u16 rptr, wptr, mask, len;
|
|
|
|
|
|
|
|
if (readb(ofsAddr + FlagStat) & Xoff_state) {
|
|
|
|
rptr = readw(ofsAddr + RXrptr);
|
|
|
|
wptr = readw(ofsAddr + RXwptr);
|
|
|
|
mask = readw(ofsAddr + RX_mask);
|
|
|
|
len = (wptr - rptr) & mask;
|
|
|
|
if (len <= Low_water)
|
|
|
|
moxafunc(ofsAddr, FC_SendXon, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
/*
|
|
|
|
* TTY operations
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int moxa_ioctl(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct moxa_port *ch = tty->driver_data;
|
|
|
|
void __user *argp = (void __user *)arg;
|
2008-04-30 09:53:45 +02:00
|
|
|
int status, ret = 0;
|
2008-04-30 09:53:43 +02:00
|
|
|
|
|
|
|
if (tty->index == MAX_PORTS) {
|
|
|
|
if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&
|
|
|
|
cmd != MOXA_GETMSTATUS)
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (!ch)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case MOXA_GETDATACOUNT:
|
|
|
|
moxaLog.tick = jiffies;
|
2008-04-30 09:53:45 +02:00
|
|
|
if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
2008-04-30 09:53:43 +02:00
|
|
|
case MOXA_FLUSH_QUEUE:
|
|
|
|
MoxaPortFlushData(ch, arg);
|
2008-04-30 09:53:45 +02:00
|
|
|
break;
|
2008-04-30 09:53:43 +02:00
|
|
|
case MOXA_GET_IOQUEUE: {
|
|
|
|
struct moxaq_str __user *argm = argp;
|
|
|
|
struct moxaq_str tmp;
|
|
|
|
struct moxa_port *p;
|
|
|
|
unsigned int i, j;
|
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
2008-04-30 09:53:43 +02:00
|
|
|
for (i = 0; i < MAX_BOARDS; i++) {
|
|
|
|
p = moxa_boards[i].ports;
|
|
|
|
for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
|
|
|
|
memset(&tmp, 0, sizeof(tmp));
|
|
|
|
if (moxa_boards[i].ready) {
|
|
|
|
tmp.inq = MoxaPortRxQueue(p);
|
|
|
|
tmp.outq = MoxaPortTxQueue(p);
|
|
|
|
}
|
2008-04-30 09:53:45 +02:00
|
|
|
if (copy_to_user(argm, &tmp, sizeof(tmp))) {
|
|
|
|
mutex_unlock(&moxa_openlock);
|
2008-04-30 09:53:43 +02:00
|
|
|
return -EFAULT;
|
2008-04-30 09:53:45 +02:00
|
|
|
}
|
2008-04-30 09:53:43 +02:00
|
|
|
}
|
|
|
|
}
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
break;
|
2008-04-30 09:53:43 +02:00
|
|
|
} case MOXA_GET_OQUEUE:
|
|
|
|
status = MoxaPortTxQueue(ch);
|
2008-04-30 09:53:45 +02:00
|
|
|
ret = put_user(status, (unsigned long __user *)argp);
|
|
|
|
break;
|
2008-04-30 09:53:43 +02:00
|
|
|
case MOXA_GET_IQUEUE:
|
|
|
|
status = MoxaPortRxQueue(ch);
|
2008-04-30 09:53:45 +02:00
|
|
|
ret = put_user(status, (unsigned long __user *)argp);
|
|
|
|
break;
|
2008-04-30 09:53:43 +02:00
|
|
|
case MOXA_GETMSTATUS: {
|
|
|
|
struct mxser_mstatus __user *argm = argp;
|
|
|
|
struct mxser_mstatus tmp;
|
|
|
|
struct moxa_port *p;
|
|
|
|
unsigned int i, j;
|
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
2008-04-30 09:53:43 +02:00
|
|
|
for (i = 0; i < MAX_BOARDS; i++) {
|
|
|
|
p = moxa_boards[i].ports;
|
|
|
|
for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
|
2008-10-13 11:39:58 +02:00
|
|
|
struct tty_struct *ttyp;
|
2008-04-30 09:53:43 +02:00
|
|
|
memset(&tmp, 0, sizeof(tmp));
|
|
|
|
if (!moxa_boards[i].ready)
|
|
|
|
goto copy;
|
|
|
|
|
|
|
|
status = MoxaPortLineStatus(p);
|
|
|
|
if (status & 1)
|
|
|
|
tmp.cts = 1;
|
|
|
|
if (status & 2)
|
|
|
|
tmp.dsr = 1;
|
|
|
|
if (status & 4)
|
|
|
|
tmp.dcd = 1;
|
|
|
|
|
2008-10-13 11:39:58 +02:00
|
|
|
ttyp = tty_port_tty_get(&p->port);
|
|
|
|
if (!ttyp || !ttyp->termios)
|
2008-04-30 09:53:43 +02:00
|
|
|
tmp.cflag = p->cflag;
|
|
|
|
else
|
2008-10-13 11:39:58 +02:00
|
|
|
tmp.cflag = ttyp->termios->c_cflag;
|
|
|
|
tty_kref_put(tty);
|
2008-04-30 09:53:43 +02:00
|
|
|
copy:
|
2008-04-30 09:53:45 +02:00
|
|
|
if (copy_to_user(argm, &tmp, sizeof(tmp))) {
|
|
|
|
mutex_unlock(&moxa_openlock);
|
2008-04-30 09:53:43 +02:00
|
|
|
return -EFAULT;
|
2008-04-30 09:53:45 +02:00
|
|
|
}
|
2008-04-30 09:53:43 +02:00
|
|
|
}
|
|
|
|
}
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
break;
|
2008-04-30 09:53:43 +02:00
|
|
|
}
|
|
|
|
case TIOCGSERIAL:
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
ret = moxa_get_serial_info(ch, argp);
|
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
break;
|
2008-04-30 09:53:43 +02:00
|
|
|
case TIOCSSERIAL:
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
ret = moxa_set_serial_info(ch, argp);
|
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -ENOIOCTLCMD;
|
2008-04-30 09:53:43 +02:00
|
|
|
}
|
2008-04-30 09:53:45 +02:00
|
|
|
return ret;
|
2008-04-30 09:53:43 +02:00
|
|
|
}
|
|
|
|
|
2008-07-22 12:18:03 +02:00
|
|
|
static int moxa_break_ctl(struct tty_struct *tty, int state)
|
2008-04-30 09:53:43 +02:00
|
|
|
{
|
|
|
|
struct moxa_port *port = tty->driver_data;
|
|
|
|
|
|
|
|
moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,
|
|
|
|
Magic_code);
|
2008-07-22 12:18:03 +02:00
|
|
|
return 0;
|
2008-04-30 09:53:43 +02:00
|
|
|
}
|
|
|
|
|
2006-10-02 11:17:18 +02:00
|
|
|
static const struct tty_operations moxa_ops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.open = moxa_open,
|
|
|
|
.close = moxa_close,
|
|
|
|
.write = moxa_write,
|
|
|
|
.write_room = moxa_write_room,
|
|
|
|
.flush_buffer = moxa_flush_buffer,
|
|
|
|
.chars_in_buffer = moxa_chars_in_buffer,
|
|
|
|
.ioctl = moxa_ioctl,
|
|
|
|
.throttle = moxa_throttle,
|
|
|
|
.unthrottle = moxa_unthrottle,
|
|
|
|
.set_termios = moxa_set_termios,
|
|
|
|
.stop = moxa_stop,
|
|
|
|
.start = moxa_start,
|
|
|
|
.hangup = moxa_hangup,
|
2008-04-30 09:53:43 +02:00
|
|
|
.break_ctl = moxa_break_ctl,
|
2005-04-17 00:20:36 +02:00
|
|
|
.tiocmget = moxa_tiocmget,
|
|
|
|
.tiocmset = moxa_tiocmset,
|
|
|
|
};
|
|
|
|
|
2009-01-02 14:45:05 +01:00
|
|
|
static const struct tty_port_operations moxa_port_ops = {
|
|
|
|
.carrier_raised = moxa_carrier_raised,
|
|
|
|
};
|
|
|
|
|
2007-02-10 10:45:27 +01:00
|
|
|
static struct tty_driver *moxaDriver;
|
|
|
|
static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);
|
2006-06-27 11:53:55 +02:00
|
|
|
static DEFINE_SPINLOCK(moxa_lock);
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 05:54:13 +01:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
/*
|
|
|
|
* HW init
|
|
|
|
*/
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)
|
|
|
|
{
|
|
|
|
switch (brd->boardType) {
|
|
|
|
case MOXA_BOARD_C218_ISA:
|
|
|
|
case MOXA_BOARD_C218_PCI:
|
|
|
|
if (model != 1)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
case MOXA_BOARD_CP204J:
|
|
|
|
if (model != 3)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (model != 2)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
err:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_check_fw(const void *ptr)
|
|
|
|
{
|
|
|
|
const __le16 *lptr = ptr;
|
|
|
|
|
|
|
|
if (*lptr != cpu_to_le16(0x7980))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
void __iomem *baseAddr = brd->basemem;
|
|
|
|
u16 tmp;
|
|
|
|
|
|
|
|
writeb(HW_reset, baseAddr + Control_reg); /* reset */
|
|
|
|
msleep(10);
|
|
|
|
memset_io(baseAddr, 0, 4096);
|
|
|
|
memcpy_toio(baseAddr, buf, len); /* download BIOS */
|
|
|
|
writeb(0, baseAddr + Control_reg); /* restart */
|
|
|
|
|
|
|
|
msleep(2000);
|
|
|
|
|
|
|
|
switch (brd->boardType) {
|
|
|
|
case MOXA_BOARD_C218_ISA:
|
|
|
|
case MOXA_BOARD_C218_PCI:
|
|
|
|
tmp = readw(baseAddr + C218_key);
|
|
|
|
if (tmp != C218_KeyCode)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
case MOXA_BOARD_CP204J:
|
|
|
|
tmp = readw(baseAddr + C218_key);
|
|
|
|
if (tmp != CP204J_KeyCode)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
tmp = readw(baseAddr + C320_key);
|
|
|
|
if (tmp != C320_KeyCode)
|
|
|
|
goto err;
|
|
|
|
tmp = readw(baseAddr + C320_status);
|
|
|
|
if (tmp != STS_init) {
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "
|
2008-04-30 09:53:39 +02:00
|
|
|
"module not found\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err:
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");
|
2008-04-30 09:53:39 +02:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
void __iomem *baseAddr = brd->basemem;
|
|
|
|
|
|
|
|
if (len < 7168) {
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");
|
2008-04-30 09:53:39 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
writew(len - 7168 - 2, baseAddr + C320bapi_len);
|
|
|
|
writeb(1, baseAddr + Control_reg); /* Select Page 1 */
|
|
|
|
memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);
|
|
|
|
writeb(2, baseAddr + Control_reg); /* Select Page 2 */
|
|
|
|
memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,
|
2008-04-30 09:53:39 +02:00
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
void __iomem *baseAddr = brd->basemem;
|
2008-10-16 07:04:19 +02:00
|
|
|
const __le16 *uptr = ptr;
|
2008-04-30 09:53:39 +02:00
|
|
|
size_t wlen, len2, j;
|
2008-04-30 09:53:39 +02:00
|
|
|
unsigned long key, loadbuf, loadlen, checksum, checksum_ok;
|
2008-04-30 09:53:47 +02:00
|
|
|
unsigned int i, retry;
|
2008-04-30 09:53:39 +02:00
|
|
|
u16 usum, keycode;
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :
|
|
|
|
C218_KeyCode;
|
2008-04-30 09:53:39 +02:00
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
switch (brd->boardType) {
|
|
|
|
case MOXA_BOARD_CP204J:
|
|
|
|
case MOXA_BOARD_C218_ISA:
|
|
|
|
case MOXA_BOARD_C218_PCI:
|
|
|
|
key = C218_key;
|
|
|
|
loadbuf = C218_LoadBuf;
|
|
|
|
loadlen = C218DLoad_len;
|
|
|
|
checksum = C218check_sum;
|
|
|
|
checksum_ok = C218chksum_ok;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
key = C320_key;
|
|
|
|
keycode = C320_KeyCode;
|
|
|
|
loadbuf = C320_LoadBuf;
|
|
|
|
loadlen = C320DLoad_len;
|
|
|
|
checksum = C320check_sum;
|
|
|
|
checksum_ok = C320chksum_ok;
|
|
|
|
break;
|
2008-04-30 09:53:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
usum = 0;
|
|
|
|
wlen = len >> 1;
|
|
|
|
for (i = 0; i < wlen; i++)
|
|
|
|
usum += le16_to_cpu(uptr[i]);
|
|
|
|
retry = 0;
|
|
|
|
do {
|
|
|
|
wlen = len >> 1;
|
|
|
|
j = 0;
|
|
|
|
while (wlen) {
|
|
|
|
len2 = (wlen > 2048) ? 2048 : wlen;
|
|
|
|
wlen -= len2;
|
2008-04-30 09:53:39 +02:00
|
|
|
memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);
|
2008-04-30 09:53:39 +02:00
|
|
|
j += len2 << 1;
|
2008-04-30 09:53:39 +02:00
|
|
|
|
|
|
|
writew(len2, baseAddr + loadlen);
|
|
|
|
writew(0, baseAddr + key);
|
|
|
|
for (i = 0; i < 100; i++) {
|
|
|
|
if (readw(baseAddr + key) == keycode)
|
2008-04-30 09:53:39 +02:00
|
|
|
break;
|
|
|
|
msleep(10);
|
|
|
|
}
|
2008-04-30 09:53:39 +02:00
|
|
|
if (readw(baseAddr + key) != keycode)
|
2008-04-30 09:53:39 +02:00
|
|
|
return -EIO;
|
|
|
|
}
|
2008-04-30 09:53:39 +02:00
|
|
|
writew(0, baseAddr + loadlen);
|
|
|
|
writew(usum, baseAddr + checksum);
|
|
|
|
writew(0, baseAddr + key);
|
|
|
|
for (i = 0; i < 100; i++) {
|
|
|
|
if (readw(baseAddr + key) == keycode)
|
2008-04-30 09:53:39 +02:00
|
|
|
break;
|
|
|
|
msleep(10);
|
|
|
|
}
|
|
|
|
retry++;
|
2008-04-30 09:53:39 +02:00
|
|
|
} while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));
|
|
|
|
if (readb(baseAddr + checksum_ok) != 1)
|
2008-04-30 09:53:39 +02:00
|
|
|
return -EIO;
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
writew(0, baseAddr + key);
|
2008-04-30 09:53:39 +02:00
|
|
|
for (i = 0; i < 600; i++) {
|
|
|
|
if (readw(baseAddr + Magic_no) == Magic_code)
|
|
|
|
break;
|
|
|
|
msleep(10);
|
|
|
|
}
|
|
|
|
if (readw(baseAddr + Magic_no) != Magic_code)
|
|
|
|
return -EIO;
|
|
|
|
|
2008-04-30 09:53:47 +02:00
|
|
|
if (MOXA_IS_320(brd)) {
|
2008-04-30 09:53:39 +02:00
|
|
|
if (brd->busType == MOXA_BUS_TYPE_PCI) { /* ASIC board */
|
|
|
|
writew(0x3800, baseAddr + TMS320_PORT1);
|
|
|
|
writew(0x3900, baseAddr + TMS320_PORT2);
|
|
|
|
writew(28499, baseAddr + TMS320_CLOCK);
|
|
|
|
} else {
|
|
|
|
writew(0x3200, baseAddr + TMS320_PORT1);
|
|
|
|
writew(0x3400, baseAddr + TMS320_PORT2);
|
|
|
|
writew(19999, baseAddr + TMS320_CLOCK);
|
|
|
|
}
|
2008-04-30 09:53:39 +02:00
|
|
|
}
|
|
|
|
writew(1, baseAddr + Disable_IRQ);
|
|
|
|
writew(0, baseAddr + Magic_no);
|
|
|
|
for (i = 0; i < 500; i++) {
|
|
|
|
if (readw(baseAddr + Magic_no) == Magic_code)
|
|
|
|
break;
|
|
|
|
msleep(10);
|
|
|
|
}
|
|
|
|
if (readw(baseAddr + Magic_no) != Magic_code)
|
|
|
|
return -EIO;
|
|
|
|
|
2008-04-30 09:53:47 +02:00
|
|
|
if (MOXA_IS_320(brd)) {
|
2008-04-30 09:53:39 +02:00
|
|
|
j = readw(baseAddr + Module_cnt);
|
|
|
|
if (j <= 0)
|
|
|
|
return -EIO;
|
|
|
|
brd->numPorts = j * 8;
|
|
|
|
writew(j, baseAddr + Module_no);
|
|
|
|
writew(0, baseAddr + Magic_no);
|
|
|
|
for (i = 0; i < 600; i++) {
|
|
|
|
if (readw(baseAddr + Magic_no) == Magic_code)
|
|
|
|
break;
|
|
|
|
msleep(10);
|
|
|
|
}
|
|
|
|
if (readw(baseAddr + Magic_no) != Magic_code)
|
|
|
|
return -EIO;
|
2008-04-30 09:53:39 +02:00
|
|
|
}
|
|
|
|
brd->intNdx = baseAddr + IRQindex;
|
|
|
|
brd->intPend = baseAddr + IRQpending;
|
|
|
|
brd->intTable = baseAddr + IRQtable;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
void __iomem *ofsAddr, *baseAddr = brd->basemem;
|
|
|
|
struct moxa_port *port;
|
|
|
|
int retval, i;
|
|
|
|
|
|
|
|
if (len % 2) {
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_ERR "MOXA: bios length is not even\n");
|
2008-04-30 09:53:39 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
retval = moxa_real_load_code(brd, ptr, len); /* may change numPorts */
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
switch (brd->boardType) {
|
|
|
|
case MOXA_BOARD_C218_ISA:
|
|
|
|
case MOXA_BOARD_C218_PCI:
|
|
|
|
case MOXA_BOARD_CP204J:
|
|
|
|
port = brd->ports;
|
|
|
|
for (i = 0; i < brd->numPorts; i++, port++) {
|
2008-04-30 09:53:40 +02:00
|
|
|
port->board = brd;
|
2008-04-30 09:53:39 +02:00
|
|
|
port->DCDState = 0;
|
|
|
|
port->tableAddr = baseAddr + Extern_table +
|
|
|
|
Extern_size * i;
|
|
|
|
ofsAddr = port->tableAddr;
|
|
|
|
writew(C218rx_mask, ofsAddr + RX_mask);
|
|
|
|
writew(C218tx_mask, ofsAddr + TX_mask);
|
|
|
|
writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);
|
|
|
|
writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);
|
|
|
|
|
|
|
|
writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);
|
|
|
|
writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);
|
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
port = brd->ports;
|
|
|
|
for (i = 0; i < brd->numPorts; i++, port++) {
|
2008-04-30 09:53:40 +02:00
|
|
|
port->board = brd;
|
2008-04-30 09:53:39 +02:00
|
|
|
port->DCDState = 0;
|
|
|
|
port->tableAddr = baseAddr + Extern_table +
|
|
|
|
Extern_size * i;
|
|
|
|
ofsAddr = port->tableAddr;
|
|
|
|
switch (brd->numPorts) {
|
|
|
|
case 8:
|
|
|
|
writew(C320p8rx_mask, ofsAddr + RX_mask);
|
|
|
|
writew(C320p8tx_mask, ofsAddr + TX_mask);
|
|
|
|
writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);
|
|
|
|
writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);
|
|
|
|
writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);
|
|
|
|
writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
writew(C320p16rx_mask, ofsAddr + RX_mask);
|
|
|
|
writew(C320p16tx_mask, ofsAddr + TX_mask);
|
|
|
|
writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);
|
|
|
|
writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);
|
|
|
|
writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);
|
|
|
|
writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 24:
|
|
|
|
writew(C320p24rx_mask, ofsAddr + RX_mask);
|
|
|
|
writew(C320p24tx_mask, ofsAddr + TX_mask);
|
|
|
|
writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);
|
|
|
|
writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);
|
|
|
|
writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);
|
|
|
|
writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
|
|
|
|
break;
|
|
|
|
case 32:
|
|
|
|
writew(C320p32rx_mask, ofsAddr + RX_mask);
|
|
|
|
writew(C320p32tx_mask, ofsAddr + TX_mask);
|
|
|
|
writew(C320p32tx_ofs, ofsAddr + Ofs_txb);
|
|
|
|
writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);
|
|
|
|
writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);
|
|
|
|
writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);
|
|
|
|
writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)
|
|
|
|
{
|
2008-07-08 18:37:15 +02:00
|
|
|
const void *ptr = fw->data;
|
2008-04-30 09:53:39 +02:00
|
|
|
char rsn[64];
|
|
|
|
u16 lens[5];
|
|
|
|
size_t len;
|
|
|
|
unsigned int a, lenp, lencnt;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
struct {
|
|
|
|
__le32 magic; /* 0x34303430 */
|
|
|
|
u8 reserved1[2];
|
|
|
|
u8 type; /* UNIX = 3 */
|
|
|
|
u8 model; /* C218T=1, C320T=2, CP204=3 */
|
|
|
|
u8 reserved2[8];
|
|
|
|
__le16 len[5];
|
2008-07-08 18:37:15 +02:00
|
|
|
} const *hdr = ptr;
|
2008-04-30 09:53:39 +02:00
|
|
|
|
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));
|
|
|
|
|
|
|
|
if (fw->size < MOXA_FW_HDRLEN) {
|
|
|
|
strcpy(rsn, "too short (even header won't fit)");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (hdr->magic != cpu_to_le32(0x30343034)) {
|
|
|
|
sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (hdr->type != 3) {
|
|
|
|
sprintf(rsn, "not for linux, type is %u", hdr->type);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (moxa_check_fw_model(brd, hdr->model)) {
|
|
|
|
sprintf(rsn, "not for this card, model is %u", hdr->model);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = MOXA_FW_HDRLEN;
|
|
|
|
lencnt = hdr->model == 2 ? 5 : 3;
|
|
|
|
for (a = 0; a < ARRAY_SIZE(lens); a++) {
|
|
|
|
lens[a] = le16_to_cpu(hdr->len[a]);
|
|
|
|
if (lens[a] && len + lens[a] <= fw->size &&
|
|
|
|
moxa_check_fw(&fw->data[len]))
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_WARNING "MOXA firmware: unexpected input "
|
2008-04-30 09:53:39 +02:00
|
|
|
"at offset %u, but going on\n", (u32)len);
|
|
|
|
if (!lens[a] && a < lencnt) {
|
|
|
|
sprintf(rsn, "too few entries in fw file");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
len += lens[a];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len != fw->size) {
|
|
|
|
sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,
|
|
|
|
(u32)len);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr += MOXA_FW_HDRLEN;
|
|
|
|
lenp = 0; /* bios */
|
|
|
|
|
|
|
|
strcpy(rsn, "read above");
|
|
|
|
|
|
|
|
ret = moxa_load_bios(brd, ptr, lens[lenp]);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* we skip the tty section (lens[1]), since we don't need it */
|
|
|
|
ptr += lens[lenp] + lens[lenp + 1];
|
|
|
|
lenp += 2; /* comm */
|
|
|
|
|
|
|
|
if (hdr->model == 2) {
|
|
|
|
ret = moxa_load_320b(brd, ptr, lens[lenp]);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
/* skip another tty */
|
|
|
|
ptr += lens[lenp] + lens[lenp + 1];
|
|
|
|
lenp += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = moxa_load_code(brd, ptr, lens[lenp]);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err:
|
|
|
|
printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)
|
|
|
|
{
|
|
|
|
const struct firmware *fw;
|
|
|
|
const char *file;
|
2008-04-30 09:53:41 +02:00
|
|
|
struct moxa_port *p;
|
|
|
|
unsigned int i;
|
2008-04-30 09:53:39 +02:00
|
|
|
int ret;
|
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (brd->ports == NULL) {
|
|
|
|
printk(KERN_ERR "cannot allocate memory for ports\n");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {
|
2008-07-16 22:57:18 +02:00
|
|
|
tty_port_init(&p->port);
|
2009-01-02 14:45:05 +01:00
|
|
|
p->port.ops = &moxa_port_ops;
|
2008-04-30 09:53:41 +02:00
|
|
|
p->type = PORT_16550A;
|
|
|
|
p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
switch (brd->boardType) {
|
|
|
|
case MOXA_BOARD_C218_ISA:
|
|
|
|
case MOXA_BOARD_C218_PCI:
|
|
|
|
file = "c218tunx.cod";
|
|
|
|
break;
|
|
|
|
case MOXA_BOARD_CP204J:
|
|
|
|
file = "cp204unx.cod";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
file = "c320tunx.cod";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = request_firmware(&fw, file, dev);
|
|
|
|
if (ret) {
|
2008-04-30 09:53:49 +02:00
|
|
|
printk(KERN_ERR "MOXA: request_firmware failed. Make sure "
|
|
|
|
"you've placed '%s' file into your firmware "
|
|
|
|
"loader directory (e.g. /lib/firmware)\n",
|
|
|
|
file);
|
2008-04-30 09:53:41 +02:00
|
|
|
goto err_free;
|
2008-04-30 09:53:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = moxa_load_fw(brd, fw);
|
|
|
|
|
|
|
|
release_firmware(fw);
|
2008-04-30 09:53:41 +02:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
goto err_free;
|
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
spin_lock_bh(&moxa_lock);
|
2008-04-30 09:53:41 +02:00
|
|
|
brd->ready = 1;
|
2008-04-30 09:53:42 +02:00
|
|
|
if (!timer_pending(&moxaTimer))
|
|
|
|
mod_timer(&moxaTimer, jiffies + HZ / 50);
|
2008-04-30 09:53:45 +02:00
|
|
|
spin_unlock_bh(&moxa_lock);
|
2008-04-30 09:53:42 +02:00
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
return 0;
|
|
|
|
err_free:
|
|
|
|
kfree(brd->ports);
|
|
|
|
err:
|
2008-04-30 09:53:39 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
static void moxa_board_deinit(struct moxa_board_conf *brd)
|
|
|
|
{
|
2008-04-30 09:53:45 +02:00
|
|
|
unsigned int a, opened;
|
|
|
|
|
|
|
|
mutex_lock(&moxa_openlock);
|
2008-04-30 09:53:43 +02:00
|
|
|
spin_lock_bh(&moxa_lock);
|
2008-04-30 09:53:41 +02:00
|
|
|
brd->ready = 0;
|
2008-04-30 09:53:43 +02:00
|
|
|
spin_unlock_bh(&moxa_lock);
|
2008-04-30 09:53:45 +02:00
|
|
|
|
|
|
|
/* pci hot-un-plug support */
|
|
|
|
for (a = 0; a < brd->numPorts; a++)
|
2008-10-13 11:39:58 +02:00
|
|
|
if (brd->ports[a].port.flags & ASYNC_INITIALIZED) {
|
|
|
|
struct tty_struct *tty = tty_port_tty_get(
|
|
|
|
&brd->ports[a].port);
|
|
|
|
if (tty) {
|
|
|
|
tty_hangup(tty);
|
|
|
|
tty_kref_put(tty);
|
|
|
|
}
|
|
|
|
}
|
2008-04-30 09:53:45 +02:00
|
|
|
while (1) {
|
|
|
|
opened = 0;
|
|
|
|
for (a = 0; a < brd->numPorts; a++)
|
2008-07-16 22:56:02 +02:00
|
|
|
if (brd->ports[a].port.flags & ASYNC_INITIALIZED)
|
2008-04-30 09:53:45 +02:00
|
|
|
opened++;
|
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
if (!opened)
|
|
|
|
break;
|
|
|
|
msleep(50);
|
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
iounmap(brd->basemem);
|
|
|
|
brd->basemem = NULL;
|
|
|
|
kfree(brd->ports);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_PCI
|
2007-02-10 10:45:35 +01:00
|
|
|
static int __devinit moxa_pci_probe(struct pci_dev *pdev,
|
|
|
|
const struct pci_device_id *ent)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-02-10 10:45:35 +01:00
|
|
|
struct moxa_board_conf *board;
|
|
|
|
unsigned int i;
|
|
|
|
int board_type = ent->driver_data;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = pci_enable_device(pdev);
|
2007-10-18 12:06:24 +02:00
|
|
|
if (retval) {
|
|
|
|
dev_err(&pdev->dev, "can't enable pci device\n");
|
2007-02-10 10:45:35 +01:00
|
|
|
goto err;
|
2007-10-18 12:06:24 +02:00
|
|
|
}
|
2007-02-10 10:45:35 +01:00
|
|
|
|
|
|
|
for (i = 0; i < MAX_BOARDS; i++)
|
|
|
|
if (moxa_boards[i].basemem == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
retval = -ENODEV;
|
|
|
|
if (i >= MAX_BOARDS) {
|
2007-10-18 12:06:24 +02:00
|
|
|
dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "
|
2007-02-10 10:45:35 +01:00
|
|
|
"found. Board is ignored.\n", MAX_BOARDS);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
board = &moxa_boards[i];
|
2008-04-30 09:53:37 +02:00
|
|
|
|
|
|
|
retval = pci_request_region(pdev, 2, "moxa-base");
|
|
|
|
if (retval) {
|
|
|
|
dev_err(&pdev->dev, "can't request pci region 2\n");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:54:19 +02:00
|
|
|
board->basemem = ioremap_nocache(pci_resource_start(pdev, 2), 0x4000);
|
2007-10-18 12:06:24 +02:00
|
|
|
if (board->basemem == NULL) {
|
|
|
|
dev_err(&pdev->dev, "can't remap io space 2\n");
|
2008-04-30 09:53:37 +02:00
|
|
|
goto err_reg;
|
2007-10-18 12:06:24 +02:00
|
|
|
}
|
2007-02-10 10:45:35 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
board->boardType = board_type;
|
|
|
|
switch (board_type) {
|
|
|
|
case MOXA_BOARD_C218_ISA:
|
|
|
|
case MOXA_BOARD_C218_PCI:
|
|
|
|
board->numPorts = 8;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MOXA_BOARD_CP204J:
|
|
|
|
board->numPorts = 4;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
board->numPorts = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
board->busType = MOXA_BUS_TYPE_PCI;
|
2007-02-10 10:45:36 +01:00
|
|
|
|
2008-04-30 09:53:39 +02:00
|
|
|
retval = moxa_init_board(board, &pdev->dev);
|
|
|
|
if (retval)
|
|
|
|
goto err_base;
|
|
|
|
|
2007-02-10 10:45:35 +01:00
|
|
|
pci_set_drvdata(pdev, board);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:48 +02:00
|
|
|
dev_info(&pdev->dev, "board '%s' ready (%u ports, firmware loaded)\n",
|
|
|
|
moxa_brdname[board_type - 1], board->numPorts);
|
|
|
|
|
2008-04-30 09:53:46 +02:00
|
|
|
return 0;
|
2008-04-30 09:53:39 +02:00
|
|
|
err_base:
|
|
|
|
iounmap(board->basemem);
|
|
|
|
board->basemem = NULL;
|
2008-04-30 09:53:37 +02:00
|
|
|
err_reg:
|
|
|
|
pci_release_region(pdev, 2);
|
2007-02-10 10:45:35 +01:00
|
|
|
err:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __devexit moxa_pci_remove(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct moxa_board_conf *brd = pci_get_drvdata(pdev);
|
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
moxa_board_deinit(brd);
|
|
|
|
|
2008-04-30 09:53:37 +02:00
|
|
|
pci_release_region(pdev, 2);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-02-10 10:45:36 +01:00
|
|
|
|
|
|
|
static struct pci_driver moxa_pci_driver = {
|
|
|
|
.name = "moxa",
|
|
|
|
.id_table = moxa_pcibrds,
|
|
|
|
.probe = moxa_pci_probe,
|
|
|
|
.remove = __devexit_p(moxa_pci_remove)
|
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif /* CONFIG_PCI */
|
|
|
|
|
|
|
|
static int __init moxa_init(void)
|
|
|
|
{
|
2008-04-30 09:53:41 +02:00
|
|
|
unsigned int isabrds = 0;
|
2008-04-30 09:53:37 +02:00
|
|
|
int retval = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-10-18 12:06:24 +02:00
|
|
|
printk(KERN_INFO "MOXA Intellio family driver version %s\n",
|
|
|
|
MOXA_VERSION);
|
2005-04-17 00:20:36 +02:00
|
|
|
moxaDriver = alloc_tty_driver(MAX_PORTS + 1);
|
|
|
|
if (!moxaDriver)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
moxaDriver->owner = THIS_MODULE;
|
2005-09-03 17:26:49 +02:00
|
|
|
moxaDriver->name = "ttyMX";
|
2005-04-17 00:20:36 +02:00
|
|
|
moxaDriver->major = ttymajor;
|
|
|
|
moxaDriver->minor_start = 0;
|
|
|
|
moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;
|
|
|
|
moxaDriver->subtype = SERIAL_TYPE_NORMAL;
|
|
|
|
moxaDriver->init_termios = tty_std_termios;
|
|
|
|
moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
|
2006-12-08 11:38:45 +01:00
|
|
|
moxaDriver->init_termios.c_ispeed = 9600;
|
|
|
|
moxaDriver->init_termios.c_ospeed = 9600;
|
2005-04-17 00:20:36 +02:00
|
|
|
moxaDriver->flags = TTY_DRIVER_REAL_RAW;
|
|
|
|
tty_set_operations(moxaDriver, &moxa_ops);
|
|
|
|
|
|
|
|
if (tty_register_driver(moxaDriver)) {
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
put_tty_driver(moxaDriver);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:37 +02:00
|
|
|
/* Find the boards defined from module args. */
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef MODULE
|
2008-04-30 09:53:37 +02:00
|
|
|
{
|
|
|
|
struct moxa_board_conf *brd = moxa_boards;
|
2008-04-30 09:53:41 +02:00
|
|
|
unsigned int i;
|
2005-04-17 00:20:36 +02:00
|
|
|
for (i = 0; i < MAX_BOARDS; i++) {
|
2008-04-30 09:53:37 +02:00
|
|
|
if (!baseaddr[i])
|
|
|
|
break;
|
|
|
|
if (type[i] == MOXA_BOARD_C218_ISA ||
|
|
|
|
type[i] == MOXA_BOARD_C320_ISA) {
|
2007-10-18 12:06:24 +02:00
|
|
|
pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",
|
2008-04-30 09:53:37 +02:00
|
|
|
isabrds + 1, moxa_brdname[type[i] - 1],
|
|
|
|
baseaddr[i]);
|
|
|
|
brd->boardType = type[i];
|
|
|
|
brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :
|
|
|
|
numports[i];
|
|
|
|
brd->busType = MOXA_BUS_TYPE_ISA;
|
2008-04-30 09:54:19 +02:00
|
|
|
brd->basemem = ioremap_nocache(baseaddr[i], 0x4000);
|
2008-04-30 09:53:37 +02:00
|
|
|
if (!brd->basemem) {
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_ERR "MOXA: can't remap %lx\n",
|
2008-04-30 09:53:37 +02:00
|
|
|
baseaddr[i]);
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
}
|
2008-04-30 09:53:39 +02:00
|
|
|
if (moxa_init_board(brd, NULL)) {
|
|
|
|
iounmap(brd->basemem);
|
|
|
|
brd->basemem = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
2008-04-30 09:53:37 +02:00
|
|
|
|
2008-04-30 09:53:48 +02:00
|
|
|
printk(KERN_INFO "MOXA isa board found at 0x%.8lu and "
|
|
|
|
"ready (%u ports, firmware loaded)\n",
|
|
|
|
baseaddr[i], brd->numPorts);
|
|
|
|
|
2008-04-30 09:53:37 +02:00
|
|
|
brd++;
|
|
|
|
isabrds++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
2008-04-30 09:53:37 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
2007-02-10 10:45:36 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_PCI
|
2007-02-10 10:45:36 +01:00
|
|
|
retval = pci_register_driver(&moxa_pci_driver);
|
|
|
|
if (retval) {
|
2008-04-30 09:53:46 +02:00
|
|
|
printk(KERN_ERR "Can't register MOXA pci driver!\n");
|
2008-04-30 09:53:37 +02:00
|
|
|
if (isabrds)
|
2007-02-10 10:45:36 +01:00
|
|
|
retval = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
#endif
|
2007-02-10 10:45:36 +01:00
|
|
|
|
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit moxa_exit(void)
|
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
unsigned int i;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-02-10 10:45:35 +01:00
|
|
|
#ifdef CONFIG_PCI
|
2007-02-10 10:45:36 +01:00
|
|
|
pci_unregister_driver(&moxa_pci_driver);
|
2007-02-10 10:45:35 +01:00
|
|
|
#endif
|
2007-02-10 10:45:36 +01:00
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
for (i = 0; i < MAX_BOARDS; i++) /* ISA boards */
|
|
|
|
if (moxa_boards[i].ready)
|
|
|
|
moxa_board_deinit(&moxa_boards[i]);
|
2008-04-30 09:53:45 +02:00
|
|
|
|
|
|
|
del_timer_sync(&moxaTimer);
|
|
|
|
|
|
|
|
if (tty_unregister_driver(moxaDriver))
|
|
|
|
printk(KERN_ERR "Couldn't unregister MOXA Intellio family "
|
|
|
|
"serial driver\n");
|
|
|
|
put_tty_driver(moxaDriver);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(moxa_init);
|
|
|
|
module_exit(moxa_exit);
|
|
|
|
|
2008-10-13 11:39:58 +02:00
|
|
|
static void moxa_close_port(struct tty_struct *tty)
|
2008-04-30 09:53:45 +02:00
|
|
|
{
|
2008-10-13 11:39:58 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
|
|
|
moxa_shut_down(tty);
|
2008-04-30 09:53:45 +02:00
|
|
|
MoxaPortFlushData(ch, 2);
|
2008-07-16 22:56:02 +02:00
|
|
|
ch->port.flags &= ~ASYNC_NORMAL_ACTIVE;
|
2008-10-13 11:39:58 +02:00
|
|
|
tty->driver_data = NULL;
|
|
|
|
tty_port_tty_set(&ch->port, NULL);
|
2008-04-30 09:53:45 +02:00
|
|
|
}
|
|
|
|
|
2009-01-02 14:45:05 +01:00
|
|
|
static int moxa_carrier_raised(struct tty_port *port)
|
|
|
|
{
|
|
|
|
struct moxa_port *ch = container_of(port, struct moxa_port, port);
|
|
|
|
int dcd;
|
|
|
|
|
|
|
|
spin_lock_bh(&moxa_lock);
|
|
|
|
dcd = ch->DCDState;
|
|
|
|
spin_unlock_bh(&moxa_lock);
|
|
|
|
return dcd;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
static int moxa_block_till_ready(struct tty_struct *tty, struct file *filp,
|
|
|
|
struct moxa_port *ch)
|
|
|
|
{
|
2009-01-02 14:45:05 +01:00
|
|
|
struct tty_port *port = &ch->port;
|
2008-04-30 09:53:45 +02:00
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
int retval = 0;
|
|
|
|
u8 dcd;
|
|
|
|
|
|
|
|
while (1) {
|
2009-01-02 14:45:05 +01:00
|
|
|
prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
|
2008-04-30 09:53:45 +02:00
|
|
|
if (tty_hung_up_p(filp)) {
|
|
|
|
#ifdef SERIAL_DO_RESTART
|
|
|
|
retval = -ERESTARTSYS;
|
|
|
|
#else
|
|
|
|
retval = -EAGAIN;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
2009-01-02 14:45:05 +01:00
|
|
|
dcd = tty_port_carrier_raised(port);
|
2008-04-30 09:53:45 +02:00
|
|
|
if (dcd)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
retval = -ERESTARTSYS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
schedule();
|
|
|
|
}
|
2009-01-02 14:45:05 +01:00
|
|
|
finish_wait(&port->open_wait, &wait);
|
2008-04-30 09:53:45 +02:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int moxa_open(struct tty_struct *tty, struct file *filp)
|
|
|
|
{
|
2008-04-30 09:53:41 +02:00
|
|
|
struct moxa_board_conf *brd;
|
2007-02-10 10:45:33 +01:00
|
|
|
struct moxa_port *ch;
|
2005-04-17 00:20:36 +02:00
|
|
|
int port;
|
|
|
|
int retval;
|
|
|
|
|
2007-02-10 10:45:31 +01:00
|
|
|
port = tty->index;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (port == MAX_PORTS) {
|
2008-04-30 09:53:43 +02:00
|
|
|
return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:53:45 +02:00
|
|
|
if (mutex_lock_interruptible(&moxa_openlock))
|
|
|
|
return -ERESTARTSYS;
|
2008-04-30 09:53:41 +02:00
|
|
|
brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];
|
2008-04-30 09:53:45 +02:00
|
|
|
if (!brd->ready) {
|
|
|
|
mutex_unlock(&moxa_openlock);
|
2008-04-30 09:53:41 +02:00
|
|
|
return -ENODEV;
|
2008-04-30 09:53:45 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-06-11 15:56:44 +02:00
|
|
|
if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {
|
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:41 +02:00
|
|
|
ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
|
2008-07-16 22:56:02 +02:00
|
|
|
ch->port.count++;
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->driver_data = ch;
|
2008-10-13 11:39:58 +02:00
|
|
|
tty_port_tty_set(&ch->port, tty);
|
2008-07-16 22:56:02 +02:00
|
|
|
if (!(ch->port.flags & ASYNC_INITIALIZED)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
ch->statusflags = 0;
|
2008-02-08 13:18:43 +01:00
|
|
|
moxa_set_tty_param(tty, tty->termios);
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortLineCtrl(ch, 1, 1);
|
|
|
|
MoxaPortEnable(ch);
|
2008-04-30 09:53:45 +02:00
|
|
|
MoxaSetFifo(ch, ch->type == PORT_16550A);
|
2008-07-16 22:56:02 +02:00
|
|
|
ch->port.flags |= ASYNC_INITIALIZED;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_unlock(&moxa_openlock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
retval = 0;
|
|
|
|
if (!(filp->f_flags & O_NONBLOCK) && !C_CLOCAL(tty))
|
|
|
|
retval = moxa_block_till_ready(tty, filp, ch);
|
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
if (retval) {
|
2008-07-16 22:56:02 +02:00
|
|
|
if (ch->port.count) /* 0 means already hung up... */
|
|
|
|
if (--ch->port.count == 0)
|
2008-10-13 11:39:58 +02:00
|
|
|
moxa_close_port(tty);
|
2008-04-30 09:53:45 +02:00
|
|
|
} else
|
2008-07-16 22:56:02 +02:00
|
|
|
ch->port.flags |= ASYNC_NORMAL_ACTIVE;
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_unlock(&moxa_openlock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_close(struct tty_struct *tty, struct file *filp)
|
|
|
|
{
|
2007-02-10 10:45:33 +01:00
|
|
|
struct moxa_port *ch;
|
2005-04-17 00:20:36 +02:00
|
|
|
int port;
|
|
|
|
|
2007-02-10 10:45:31 +01:00
|
|
|
port = tty->index;
|
2008-04-30 09:53:45 +02:00
|
|
|
if (port == MAX_PORTS || tty_hung_up_p(filp))
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
ch = tty->driver_data;
|
|
|
|
if (ch == NULL)
|
|
|
|
goto unlock;
|
2008-07-16 22:56:02 +02:00
|
|
|
if (tty->count == 1 && ch->port.count != 1) {
|
2007-10-18 12:06:24 +02:00
|
|
|
printk(KERN_WARNING "moxa_close: bad serial port count; "
|
2008-07-16 22:56:02 +02:00
|
|
|
"tty->count is 1, ch->port.count is %d\n", ch->port.count);
|
|
|
|
ch->port.count = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-07-16 22:56:02 +02:00
|
|
|
if (--ch->port.count < 0) {
|
2007-10-18 12:06:24 +02:00
|
|
|
printk(KERN_WARNING "moxa_close: bad serial port count, "
|
|
|
|
"device=%s\n", tty->name);
|
2008-07-16 22:56:02 +02:00
|
|
|
ch->port.count = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-07-16 22:56:02 +02:00
|
|
|
if (ch->port.count)
|
2008-04-30 09:53:45 +02:00
|
|
|
goto unlock;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ch->cflag = tty->termios->c_cflag;
|
2008-07-16 22:56:02 +02:00
|
|
|
if (ch->port.flags & ASYNC_INITIALIZED) {
|
2007-10-18 12:06:24 +02:00
|
|
|
moxa_setup_empty_event(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_wait_until_sent(tty, 30 * HZ); /* 30 seconds timeout */
|
|
|
|
}
|
|
|
|
|
2008-10-13 11:39:58 +02:00
|
|
|
moxa_close_port(tty);
|
2008-04-30 09:53:45 +02:00
|
|
|
unlock:
|
|
|
|
mutex_unlock(&moxa_openlock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_write(struct tty_struct *tty,
|
|
|
|
const unsigned char *buf, int count)
|
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
|
|
|
int len;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (ch == NULL)
|
2008-04-30 09:53:40 +02:00
|
|
|
return 0;
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 05:54:13 +01:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
spin_lock_bh(&moxa_lock);
|
2008-10-13 11:39:58 +02:00
|
|
|
len = MoxaPortWriteData(tty, buf, count);
|
2008-04-30 09:53:43 +02:00
|
|
|
spin_unlock_bh(&moxa_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ch->statusflags |= LOWWAIT;
|
2008-04-30 09:53:46 +02:00
|
|
|
return len;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_write_room(struct tty_struct *tty)
|
|
|
|
{
|
2007-02-10 10:45:33 +01:00
|
|
|
struct moxa_port *ch;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (tty->stopped)
|
2008-04-30 09:53:46 +02:00
|
|
|
return 0;
|
2008-04-30 09:53:40 +02:00
|
|
|
ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ch == NULL)
|
2008-04-30 09:53:46 +02:00
|
|
|
return 0;
|
2008-04-30 09:53:40 +02:00
|
|
|
return MoxaPortTxFree(ch);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_flush_buffer(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (ch == NULL)
|
|
|
|
return;
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortFlushData(ch, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_wakeup(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_chars_in_buffer(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int chars;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sigh...I have to check if driver_data is NULL here, because
|
|
|
|
* if an open() fails, the TTY subsystem eventually calls
|
|
|
|
* tty_wait_until_sent(), which calls the driver's chars_in_buffer()
|
|
|
|
* routine. And since the open() failed, we return 0 here. TDJ
|
|
|
|
*/
|
|
|
|
if (ch == NULL)
|
2008-04-30 09:53:46 +02:00
|
|
|
return 0;
|
2008-04-30 09:53:59 +02:00
|
|
|
lock_kernel();
|
2008-04-30 09:53:40 +02:00
|
|
|
chars = MoxaPortTxQueue(ch);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (chars) {
|
|
|
|
/*
|
|
|
|
* Make it possible to wakeup anything waiting for output
|
|
|
|
* in tty_ioctl.c, etc.
|
|
|
|
*/
|
|
|
|
if (!(ch->statusflags & EMPTYWAIT))
|
2007-10-18 12:06:24 +02:00
|
|
|
moxa_setup_empty_event(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:53:59 +02:00
|
|
|
unlock_kernel();
|
2008-04-30 09:53:46 +02:00
|
|
|
return chars;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_tiocmget(struct tty_struct *tty, struct file *file)
|
|
|
|
{
|
2008-04-30 09:53:45 +02:00
|
|
|
struct moxa_port *ch;
|
2005-04-17 00:20:36 +02:00
|
|
|
int flag = 0, dtr, rts;
|
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
ch = tty->driver_data;
|
|
|
|
if (!ch) {
|
|
|
|
mutex_unlock(&moxa_openlock);
|
2008-04-30 09:53:43 +02:00
|
|
|
return -EINVAL;
|
2008-04-30 09:53:45 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortGetLineOut(ch, &dtr, &rts);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dtr)
|
|
|
|
flag |= TIOCM_DTR;
|
|
|
|
if (rts)
|
|
|
|
flag |= TIOCM_RTS;
|
2008-04-30 09:53:40 +02:00
|
|
|
dtr = MoxaPortLineStatus(ch);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dtr & 1)
|
|
|
|
flag |= TIOCM_CTS;
|
|
|
|
if (dtr & 2)
|
|
|
|
flag |= TIOCM_DSR;
|
|
|
|
if (dtr & 4)
|
|
|
|
flag |= TIOCM_CD;
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_unlock(&moxa_openlock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int set, unsigned int clear)
|
|
|
|
{
|
2008-04-30 09:53:45 +02:00
|
|
|
struct moxa_port *ch;
|
2005-04-17 00:20:36 +02:00
|
|
|
int port;
|
|
|
|
int dtr, rts;
|
|
|
|
|
2007-02-10 10:45:31 +01:00
|
|
|
port = tty->index;
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
ch = tty->driver_data;
|
|
|
|
if (!ch) {
|
|
|
|
mutex_unlock(&moxa_openlock);
|
2008-04-30 09:53:43 +02:00
|
|
|
return -EINVAL;
|
2008-04-30 09:53:45 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortGetLineOut(ch, &dtr, &rts);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (set & TIOCM_RTS)
|
|
|
|
rts = 1;
|
|
|
|
if (set & TIOCM_DTR)
|
|
|
|
dtr = 1;
|
|
|
|
if (clear & TIOCM_RTS)
|
|
|
|
rts = 0;
|
|
|
|
if (clear & TIOCM_DTR)
|
|
|
|
dtr = 0;
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortLineCtrl(ch, dtr, rts);
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_unlock(&moxa_openlock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_throttle(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ch->statusflags |= THROTTLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_unthrottle(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ch->statusflags &= ~THROTTLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_set_termios(struct tty_struct *tty,
|
2008-04-30 09:53:46 +02:00
|
|
|
struct ktermios *old_termios)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (ch == NULL)
|
|
|
|
return;
|
2008-02-08 13:18:43 +01:00
|
|
|
moxa_set_tty_param(tty, old_termios);
|
2008-04-30 09:53:46 +02:00
|
|
|
if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
|
2008-07-16 22:56:02 +02:00
|
|
|
wake_up_interruptible(&ch->port.open_wait);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_stop(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (ch == NULL)
|
|
|
|
return;
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortTxDisable(ch);
|
2005-04-17 00:20:36 +02:00
|
|
|
ch->statusflags |= TXSTOPPED;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void moxa_start(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (ch == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!(ch->statusflags & TXSTOPPED))
|
|
|
|
return;
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortTxEnable(ch);
|
2005-04-17 00:20:36 +02:00
|
|
|
ch->statusflags &= ~TXSTOPPED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_hangup(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:45 +02:00
|
|
|
struct moxa_port *ch;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_lock(&moxa_openlock);
|
|
|
|
ch = tty->driver_data;
|
|
|
|
if (ch == NULL) {
|
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
return;
|
|
|
|
}
|
2008-07-16 22:56:02 +02:00
|
|
|
ch->port.count = 0;
|
2008-10-13 11:39:58 +02:00
|
|
|
moxa_close_port(tty);
|
2008-04-30 09:53:45 +02:00
|
|
|
mutex_unlock(&moxa_openlock);
|
|
|
|
|
2008-07-16 22:56:02 +02:00
|
|
|
wake_up_interruptible(&ch->port.open_wait);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-13 11:39:58 +02:00
|
|
|
struct tty_struct *tty;
|
2008-04-30 09:53:43 +02:00
|
|
|
dcd = !!dcd;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-13 11:39:58 +02:00
|
|
|
if (dcd != p->DCDState) {
|
|
|
|
tty = tty_port_tty_get(&p->port);
|
|
|
|
if (tty && C_CLOCAL(tty) && !dcd)
|
|
|
|
tty_hangup(tty);
|
|
|
|
tty_kref_put(tty);
|
2008-04-30 09:53:43 +02:00
|
|
|
}
|
|
|
|
p->DCDState = dcd;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
static int moxa_poll_port(struct moxa_port *p, unsigned int handle,
|
|
|
|
u16 __iomem *ip)
|
|
|
|
{
|
2008-10-13 11:39:58 +02:00
|
|
|
struct tty_struct *tty = tty_port_tty_get(&p->port);
|
2008-04-30 09:53:43 +02:00
|
|
|
void __iomem *ofsAddr;
|
2008-07-16 22:56:02 +02:00
|
|
|
unsigned int inited = p->port.flags & ASYNC_INITIALIZED;
|
2008-04-30 09:53:43 +02:00
|
|
|
u16 intr;
|
|
|
|
|
|
|
|
if (tty) {
|
|
|
|
if ((p->statusflags & EMPTYWAIT) &&
|
|
|
|
MoxaPortTxQueue(p) == 0) {
|
|
|
|
p->statusflags &= ~EMPTYWAIT;
|
|
|
|
tty_wakeup(tty);
|
|
|
|
}
|
|
|
|
if ((p->statusflags & LOWWAIT) && !tty->stopped &&
|
|
|
|
MoxaPortTxQueue(p) <= WAKEUP_CHARS) {
|
|
|
|
p->statusflags &= ~LOWWAIT;
|
|
|
|
tty_wakeup(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inited && !(p->statusflags & THROTTLE) &&
|
|
|
|
MoxaPortRxQueue(p) > 0) { /* RX */
|
|
|
|
MoxaPortReadData(p);
|
|
|
|
tty_schedule_flip(tty);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
p->statusflags &= ~EMPTYWAIT;
|
|
|
|
MoxaPortFlushData(p, 0); /* flush RX */
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:53:42 +02:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
if (!handle) /* nothing else to do */
|
2009-04-06 18:34:04 +02:00
|
|
|
goto put;
|
2008-04-30 09:53:43 +02:00
|
|
|
|
|
|
|
intr = readw(ip); /* port irq status */
|
|
|
|
if (intr == 0)
|
2009-04-06 18:34:04 +02:00
|
|
|
goto put;
|
2008-04-30 09:53:43 +02:00
|
|
|
|
|
|
|
writew(0, ip); /* ACK port */
|
|
|
|
ofsAddr = p->tableAddr;
|
|
|
|
if (intr & IntrTx) /* disable tx intr */
|
|
|
|
writew(readw(ofsAddr + HostStat) & ~WakeupTx,
|
|
|
|
ofsAddr + HostStat);
|
|
|
|
|
|
|
|
if (!inited)
|
2009-04-06 18:34:04 +02:00
|
|
|
goto put;
|
2008-04-30 09:53:43 +02:00
|
|
|
|
|
|
|
if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) { /* BREAK */
|
|
|
|
tty_insert_flip_char(tty, 0, TTY_BREAK);
|
|
|
|
tty_schedule_flip(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intr & IntrLine)
|
|
|
|
moxa_new_dcdstate(p, readb(ofsAddr + FlagStat) & DCD_state);
|
2009-04-06 18:34:04 +02:00
|
|
|
put:
|
|
|
|
tty_kref_put(tty);
|
2008-04-30 09:53:43 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void moxa_poll(unsigned long ignored)
|
|
|
|
{
|
|
|
|
struct moxa_board_conf *brd;
|
|
|
|
u16 __iomem *ip;
|
2008-04-30 09:53:45 +02:00
|
|
|
unsigned int card, port, served = 0;
|
2008-04-30 09:53:43 +02:00
|
|
|
|
|
|
|
spin_lock(&moxa_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
for (card = 0; card < MAX_BOARDS; card++) {
|
2008-04-30 09:53:43 +02:00
|
|
|
brd = &moxa_boards[card];
|
|
|
|
if (!brd->ready)
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
2008-04-30 09:53:43 +02:00
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
served++;
|
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
ip = NULL;
|
|
|
|
if (readb(brd->intPend) == 0xff)
|
|
|
|
ip = brd->intTable + readb(brd->intNdx);
|
|
|
|
|
|
|
|
for (port = 0; port < brd->numPorts; port++)
|
|
|
|
moxa_poll_port(&brd->ports[port], !!ip, ip + port);
|
|
|
|
|
|
|
|
if (ip)
|
|
|
|
writeb(0, brd->intPend); /* ACK */
|
|
|
|
|
|
|
|
if (moxaLowWaterChk) {
|
|
|
|
struct moxa_port *p = brd->ports;
|
|
|
|
for (port = 0; port < brd->numPorts; port++, p++)
|
|
|
|
if (p->lowChkFlag) {
|
|
|
|
p->lowChkFlag = 0;
|
|
|
|
moxa_low_water_check(p->tableAddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-04-30 09:53:43 +02:00
|
|
|
moxaLowWaterChk = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
if (served)
|
|
|
|
mod_timer(&moxaTimer, jiffies + HZ / 50);
|
|
|
|
spin_unlock(&moxa_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2008-02-08 13:18:43 +01:00
|
|
|
static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
register struct ktermios *ts = tty->termios;
|
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2008-02-08 13:18:43 +01:00
|
|
|
int rts, cts, txflow, rxflow, xany, baud;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
rts = cts = txflow = rxflow = xany = 0;
|
|
|
|
if (ts->c_cflag & CRTSCTS)
|
|
|
|
rts = cts = 1;
|
|
|
|
if (ts->c_iflag & IXON)
|
|
|
|
txflow = 1;
|
|
|
|
if (ts->c_iflag & IXOFF)
|
|
|
|
rxflow = 1;
|
|
|
|
if (ts->c_iflag & IXANY)
|
|
|
|
xany = 1;
|
2008-02-08 13:18:43 +01:00
|
|
|
|
|
|
|
/* Clear the features we don't support */
|
|
|
|
ts->c_cflag &= ~CMSPAR;
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);
|
|
|
|
baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));
|
2008-02-08 13:18:43 +01:00
|
|
|
if (baud == -1)
|
|
|
|
baud = tty_termios_baud_rate(old_termios);
|
|
|
|
/* Not put the baud rate into the termios data */
|
|
|
|
tty_encode_baud_rate(tty, baud, baud);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-18 12:06:24 +02:00
|
|
|
static void moxa_setup_empty_event(struct tty_struct *tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-02-10 10:45:33 +01:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
spin_lock_bh(&moxa_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
ch->statusflags |= EMPTYWAIT;
|
2008-04-30 09:53:43 +02:00
|
|
|
spin_unlock_bh(&moxa_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-10-13 11:39:58 +02:00
|
|
|
static void moxa_shut_down(struct tty_struct *tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-13 11:39:58 +02:00
|
|
|
struct moxa_port *ch = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-16 22:56:02 +02:00
|
|
|
if (!(ch->port.flags & ASYNC_INITIALIZED))
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortDisable(ch);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're a modem control device and HUPCL is on, drop RTS & DTR.
|
|
|
|
*/
|
2008-10-13 11:39:58 +02:00
|
|
|
if (C_HUPCL(tty))
|
2008-04-30 09:53:40 +02:00
|
|
|
MoxaPortLineCtrl(ch, 0, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:45 +02:00
|
|
|
spin_lock_bh(&moxa_lock);
|
2008-07-16 22:56:02 +02:00
|
|
|
ch->port.flags &= ~ASYNC_INITIALIZED;
|
2008-04-30 09:53:45 +02:00
|
|
|
spin_unlock_bh(&moxa_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Driver level functions: *
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortFlushData(struct moxa_port *port, int mode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
void __iomem *ofsAddr;
|
2008-04-30 09:53:46 +02:00
|
|
|
if (mode < 0 || mode > 2)
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
2008-04-30 09:53:40 +02:00
|
|
|
ofsAddr = port->tableAddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
moxafunc(ofsAddr, FC_FlushQueue, mode);
|
|
|
|
if (mode != 1) {
|
2008-04-30 09:53:40 +02:00
|
|
|
port->lowChkFlag = 0;
|
2007-10-18 12:06:24 +02:00
|
|
|
moxa_low_water_check(ofsAddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Moxa Port Number Description:
|
|
|
|
*
|
|
|
|
* MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,
|
|
|
|
* the port number using in MOXA driver functions will be 0 to 31 for
|
|
|
|
* first MOXA board, 32 to 63 for second, 64 to 95 for third and 96
|
|
|
|
* to 127 for fourth. For example, if you setup three MOXA boards,
|
|
|
|
* first board is C218, second board is C320-16 and third board is
|
|
|
|
* C320-32. The port number of first board (C218 - 8 ports) is from
|
|
|
|
* 0 to 7. The port number of second board (C320 - 16 ports) is form
|
|
|
|
* 32 to 47. The port number of third board (C320 - 32 ports) is from
|
|
|
|
* 64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to
|
|
|
|
* 127 will be invalid.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Moxa Functions Description:
|
|
|
|
*
|
|
|
|
* Function 1: Driver initialization routine, this routine must be
|
|
|
|
* called when initialized driver.
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaDriverInit();
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 2: Moxa driver private IOCTL command processing.
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);
|
|
|
|
*
|
|
|
|
* unsigned int cmd : IOCTL command
|
|
|
|
* unsigned long arg : IOCTL argument
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
* return: 0 (OK)
|
|
|
|
* -EINVAL
|
|
|
|
* -ENOIOCTLCMD
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 6: Enable this port to start Tx/Rx data.
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaPortEnable(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 7: Disable this port
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaPortDisable(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 10: Setting baud rate of this port.
|
|
|
|
* Syntax:
|
2008-04-30 09:53:47 +02:00
|
|
|
* speed_t MoxaPortSetBaud(int port, speed_t baud);
|
2005-04-17 00:20:36 +02:00
|
|
|
* int port : port number (0 - 127)
|
|
|
|
* long baud : baud rate (50 - 115200)
|
|
|
|
*
|
|
|
|
* return: 0 : this port is invalid or baud < 50
|
|
|
|
* 50 - 115200 : the real baud rate set to the port, if
|
|
|
|
* the argument baud is large than maximun
|
|
|
|
* available baud rate, the real setting
|
|
|
|
* baud rate will be the maximun baud rate.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 12: Configure the port.
|
|
|
|
* Syntax:
|
2006-12-08 11:38:45 +01:00
|
|
|
* int MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);
|
2005-04-17 00:20:36 +02:00
|
|
|
* int port : port number (0 - 127)
|
2006-12-08 11:38:45 +01:00
|
|
|
* struct ktermios * termio : termio structure pointer
|
2006-10-01 08:27:24 +02:00
|
|
|
* speed_t baud : baud rate
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* return: -1 : this port is invalid or termio == NULL
|
|
|
|
* 0 : setting O.K.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 13: Get the DTR/RTS state of this port.
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
* int * dtrState : pointer to INT to receive the current DTR
|
|
|
|
* state. (if NULL, this function will not
|
|
|
|
* write to this address)
|
|
|
|
* int * rtsState : pointer to INT to receive the current RTS
|
|
|
|
* state. (if NULL, this function will not
|
|
|
|
* write to this address)
|
|
|
|
*
|
|
|
|
* return: -1 : this port is invalid
|
|
|
|
* 0 : O.K.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 14: Setting the DTR/RTS output state of this port.
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaPortLineCtrl(int port, int dtrState, int rtsState);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
* int dtrState : DTR output state (0: off, 1: on)
|
|
|
|
* int rtsState : RTS output state (0: off, 1: on)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 15: Setting the flow control of this port.
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,
|
|
|
|
* int txFlow,int xany);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
* int rtsFlow : H/W RTS flow control (0: no, 1: yes)
|
|
|
|
* int ctsFlow : H/W CTS flow control (0: no, 1: yes)
|
|
|
|
* int rxFlow : S/W Rx XON/XOFF flow control (0: no, 1: yes)
|
|
|
|
* int txFlow : S/W Tx XON/XOFF flow control (0: no, 1: yes)
|
|
|
|
* int xany : S/W XANY flow control (0: no, 1: yes)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 16: Get ths line status of this port
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaPortLineStatus(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
* return: Bit 0 - CTS state (0: off, 1: on)
|
|
|
|
* Bit 1 - DSR state (0: off, 1: on)
|
|
|
|
* Bit 2 - DCD state (0: off, 1: on)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 19: Flush the Rx/Tx buffer data of this port.
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaPortFlushData(int port, int mode);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
* int mode
|
|
|
|
* 0 : flush the Rx buffer
|
|
|
|
* 1 : flush the Tx buffer
|
|
|
|
* 2 : flush the Rx and Tx buffer
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 20: Write data.
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaPortWriteData(int port, unsigned char * buffer, int length);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
* unsigned char * buffer : pointer to write data buffer.
|
|
|
|
* int length : write data length
|
|
|
|
*
|
|
|
|
* return: 0 - length : real write data length
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 21: Read data.
|
|
|
|
* Syntax:
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 05:54:13 +01:00
|
|
|
* int MoxaPortReadData(int port, struct tty_struct *tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
* int port : port number (0 - 127)
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 05:54:13 +01:00
|
|
|
* struct tty_struct *tty : tty for data
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* return: 0 - length : real read data length
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 24: Get the Tx buffer current queued data bytes
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaPortTxQueue(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
* return: .. : Tx buffer current queued data bytes
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 25: Get the Tx buffer current free space
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaPortTxFree(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
* return: .. : Tx buffer current free space
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 26: Get the Rx buffer current queued data bytes
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaPortRxQueue(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
* return: .. : Rx buffer current queued data bytes
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 28: Disable port data transmission.
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaPortTxDisable(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 29: Enable port data transmission.
|
|
|
|
* Syntax:
|
|
|
|
* void MoxaPortTxEnable(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Function 31: Get the received BREAK signal count and reset it.
|
|
|
|
* Syntax:
|
|
|
|
* int MoxaPortResetBrkCnt(int port);
|
|
|
|
* int port : port number (0 - 127)
|
|
|
|
*
|
|
|
|
* return: 0 - .. : BREAK signal count
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortEnable(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
void __iomem *ofsAddr;
|
2008-04-30 09:53:46 +02:00
|
|
|
u16 lowwater = 512;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
ofsAddr = port->tableAddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
writew(lowwater, ofsAddr + Low_water);
|
2008-04-30 09:53:47 +02:00
|
|
|
if (MOXA_IS_320(port->board))
|
2005-04-17 00:20:36 +02:00
|
|
|
moxafunc(ofsAddr, FC_SetBreakIrq, 0);
|
2008-04-30 09:53:46 +02:00
|
|
|
else
|
|
|
|
writew(readw(ofsAddr + HostStat) | WakeupBreak,
|
|
|
|
ofsAddr + HostStat);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
|
|
|
|
moxafunc(ofsAddr, FC_FlushQueue, 2);
|
|
|
|
|
|
|
|
moxafunc(ofsAddr, FC_EnableCH, Magic_code);
|
|
|
|
MoxaPortLineStatus(port);
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortDisable(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
void __iomem *ofsAddr = port->tableAddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */
|
|
|
|
moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);
|
|
|
|
writew(0, ofsAddr + HostStat);
|
|
|
|
moxafunc(ofsAddr, FC_DisableCH, Magic_code);
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:47 +02:00
|
|
|
static speed_t MoxaPortSetBaud(struct moxa_port *port, speed_t baud)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:47 +02:00
|
|
|
void __iomem *ofsAddr = port->tableAddr;
|
|
|
|
unsigned int clock, val;
|
|
|
|
speed_t max;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:47 +02:00
|
|
|
max = MOXA_IS_320(port->board) ? 460800 : 921600;
|
|
|
|
if (baud < 50)
|
2008-04-30 09:53:46 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (baud > max)
|
|
|
|
baud = max;
|
2008-04-30 09:53:47 +02:00
|
|
|
clock = 921600;
|
2005-04-17 00:20:36 +02:00
|
|
|
val = clock / baud;
|
|
|
|
moxafunc(ofsAddr, FC_SetBaud, val);
|
|
|
|
baud = clock / val;
|
2008-04-30 09:53:46 +02:00
|
|
|
return baud;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
|
|
|
|
speed_t baud)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
void __iomem *ofsAddr;
|
|
|
|
tcflag_t cflag;
|
|
|
|
tcflag_t mode = 0;
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
ofsAddr = port->tableAddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
cflag = termio->c_cflag; /* termio->c_cflag */
|
|
|
|
|
|
|
|
mode = termio->c_cflag & CSIZE;
|
|
|
|
if (mode == CS5)
|
|
|
|
mode = MX_CS5;
|
|
|
|
else if (mode == CS6)
|
|
|
|
mode = MX_CS6;
|
|
|
|
else if (mode == CS7)
|
|
|
|
mode = MX_CS7;
|
|
|
|
else if (mode == CS8)
|
|
|
|
mode = MX_CS8;
|
|
|
|
|
|
|
|
if (termio->c_cflag & CSTOPB) {
|
|
|
|
if (mode == MX_CS5)
|
|
|
|
mode |= MX_STOP15;
|
|
|
|
else
|
|
|
|
mode |= MX_STOP2;
|
|
|
|
} else
|
|
|
|
mode |= MX_STOP1;
|
|
|
|
|
|
|
|
if (termio->c_cflag & PARENB) {
|
|
|
|
if (termio->c_cflag & PARODD)
|
|
|
|
mode |= MX_PARODD;
|
|
|
|
else
|
|
|
|
mode |= MX_PAREVEN;
|
|
|
|
} else
|
|
|
|
mode |= MX_PARNONE;
|
|
|
|
|
2008-04-30 09:53:46 +02:00
|
|
|
moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:47 +02:00
|
|
|
if (MOXA_IS_320(port->board) && baud >= 921600)
|
|
|
|
return -1;
|
|
|
|
|
2008-02-08 13:18:43 +01:00
|
|
|
baud = MoxaPortSetBaud(port, baud);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (termio->c_iflag & (IXON | IXOFF | IXANY)) {
|
|
|
|
writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);
|
|
|
|
writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);
|
|
|
|
writeb(FC_SetXonXoff, ofsAddr + FuncCode);
|
2007-10-18 12:06:24 +02:00
|
|
|
moxa_wait_finish(ofsAddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
}
|
2008-04-30 09:53:46 +02:00
|
|
|
return baud;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,
|
|
|
|
int *rtsState)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
if (dtrState)
|
|
|
|
*dtrState = !!(port->lineCtrl & DTR_ON);
|
|
|
|
if (rtsState)
|
|
|
|
*rtsState = !!(port->lineCtrl & RTS_ON);
|
|
|
|
|
2008-04-30 09:53:46 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
u8 mode = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (dtr)
|
|
|
|
mode |= DTR_ON;
|
|
|
|
if (rts)
|
|
|
|
mode |= RTS_ON;
|
2008-04-30 09:53:40 +02:00
|
|
|
port->lineCtrl = mode;
|
|
|
|
moxafunc(port->tableAddr, FC_LineControl, mode);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,
|
|
|
|
int txflow, int rxflow, int txany)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
int mode = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (rts)
|
|
|
|
mode |= RTS_FlowCtl;
|
|
|
|
if (cts)
|
|
|
|
mode |= CTS_FlowCtl;
|
|
|
|
if (txflow)
|
|
|
|
mode |= Tx_FlowCtl;
|
|
|
|
if (rxflow)
|
|
|
|
mode |= Rx_FlowCtl;
|
|
|
|
if (txany)
|
|
|
|
mode |= IXM_IXANY;
|
2008-04-30 09:53:40 +02:00
|
|
|
moxafunc(port->tableAddr, FC_SetFlowCtl, mode);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static int MoxaPortLineStatus(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
void __iomem *ofsAddr;
|
|
|
|
int val;
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
ofsAddr = port->tableAddr;
|
2008-04-30 09:53:47 +02:00
|
|
|
if (MOXA_IS_320(port->board)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
moxafunc(ofsAddr, FC_LineStatus, 0);
|
|
|
|
val = readw(ofsAddr + FuncArg);
|
|
|
|
} else {
|
|
|
|
val = readw(ofsAddr + FlagStat) >> 4;
|
|
|
|
}
|
|
|
|
val &= 0x0B;
|
2008-04-30 09:53:43 +02:00
|
|
|
if (val & 8)
|
2005-04-17 00:20:36 +02:00
|
|
|
val |= 4;
|
2008-04-30 09:53:45 +02:00
|
|
|
spin_lock_bh(&moxa_lock);
|
2008-04-30 09:53:43 +02:00
|
|
|
moxa_new_dcdstate(port, val & 8);
|
2008-04-30 09:53:45 +02:00
|
|
|
spin_unlock_bh(&moxa_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
val &= 7;
|
2008-04-30 09:53:43 +02:00
|
|
|
return val;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-10-13 11:39:58 +02:00
|
|
|
static int MoxaPortWriteData(struct tty_struct *tty,
|
2008-04-30 09:53:44 +02:00
|
|
|
const unsigned char *buffer, int len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-13 11:39:58 +02:00
|
|
|
struct moxa_port *port = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
void __iomem *baseAddr, *ofsAddr, *ofs;
|
2008-04-30 09:53:44 +02:00
|
|
|
unsigned int c, total;
|
|
|
|
u16 head, tail, tx_mask, spage, epage;
|
|
|
|
u16 pageno, pageofs, bufhead;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
ofsAddr = port->tableAddr;
|
|
|
|
baseAddr = port->board->basemem;
|
2005-04-17 00:20:36 +02:00
|
|
|
tx_mask = readw(ofsAddr + TX_mask);
|
|
|
|
spage = readw(ofsAddr + Page_txb);
|
|
|
|
epage = readw(ofsAddr + EndPage_txb);
|
|
|
|
tail = readw(ofsAddr + TXwptr);
|
|
|
|
head = readw(ofsAddr + TXrptr);
|
2008-04-30 09:53:44 +02:00
|
|
|
c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (c > len)
|
|
|
|
c = len;
|
2008-07-16 22:56:02 +02:00
|
|
|
moxaLog.txcnt[port->port.tty->index] += c;
|
2005-04-17 00:20:36 +02:00
|
|
|
total = c;
|
|
|
|
if (spage == epage) {
|
|
|
|
bufhead = readw(ofsAddr + Ofs_txb);
|
|
|
|
writew(spage, baseAddr + Control_reg);
|
|
|
|
while (c > 0) {
|
|
|
|
if (head > tail)
|
|
|
|
len = head - tail - 1;
|
|
|
|
else
|
|
|
|
len = tx_mask + 1 - tail;
|
|
|
|
len = (c > len) ? len : c;
|
|
|
|
ofs = baseAddr + DynPage_addr + bufhead + tail;
|
2008-04-30 09:53:44 +02:00
|
|
|
memcpy_toio(ofs, buffer, len);
|
|
|
|
buffer += len;
|
2005-04-17 00:20:36 +02:00
|
|
|
tail = (tail + len) & tx_mask;
|
|
|
|
c -= len;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pageno = spage + (tail >> 13);
|
|
|
|
pageofs = tail & Page_mask;
|
2008-04-30 09:53:44 +02:00
|
|
|
while (c > 0) {
|
|
|
|
len = Page_size - pageofs;
|
|
|
|
if (len > c)
|
|
|
|
len = c;
|
2005-04-17 00:20:36 +02:00
|
|
|
writeb(pageno, baseAddr + Control_reg);
|
|
|
|
ofs = baseAddr + DynPage_addr + pageofs;
|
2008-04-30 09:53:44 +02:00
|
|
|
memcpy_toio(ofs, buffer, len);
|
|
|
|
buffer += len;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (++pageno == epage)
|
|
|
|
pageno = spage;
|
|
|
|
pageofs = 0;
|
2008-04-30 09:53:44 +02:00
|
|
|
c -= len;
|
|
|
|
}
|
|
|
|
tail = (tail + total) & tx_mask;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:53:44 +02:00
|
|
|
writew(tail, ofsAddr + TXwptr);
|
2005-04-17 00:20:36 +02:00
|
|
|
writeb(1, ofsAddr + CD180TXirq); /* start to send */
|
2008-04-30 09:53:44 +02:00
|
|
|
return total;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:43 +02:00
|
|
|
static int MoxaPortReadData(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-07-16 22:56:02 +02:00
|
|
|
struct tty_struct *tty = port->port.tty;
|
2008-04-30 09:53:44 +02:00
|
|
|
unsigned char *dst;
|
2005-04-17 00:20:36 +02:00
|
|
|
void __iomem *baseAddr, *ofsAddr, *ofs;
|
2008-04-30 09:53:44 +02:00
|
|
|
unsigned int count, len, total;
|
|
|
|
u16 tail, rx_mask, spage, epage;
|
|
|
|
u16 pageno, pageofs, bufhead, head;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
ofsAddr = port->tableAddr;
|
|
|
|
baseAddr = port->board->basemem;
|
2005-04-17 00:20:36 +02:00
|
|
|
head = readw(ofsAddr + RXrptr);
|
|
|
|
tail = readw(ofsAddr + RXwptr);
|
|
|
|
rx_mask = readw(ofsAddr + RX_mask);
|
|
|
|
spage = readw(ofsAddr + Page_rxb);
|
|
|
|
epage = readw(ofsAddr + EndPage_rxb);
|
2008-04-30 09:53:44 +02:00
|
|
|
count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (count == 0)
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 05:54:13 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 05:54:13 +01:00
|
|
|
total = count;
|
2008-04-30 09:53:43 +02:00
|
|
|
moxaLog.rxcnt[tty->index] += total;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (spage == epage) {
|
|
|
|
bufhead = readw(ofsAddr + Ofs_rxb);
|
|
|
|
writew(spage, baseAddr + Control_reg);
|
|
|
|
while (count > 0) {
|
|
|
|
ofs = baseAddr + DynPage_addr + bufhead + head;
|
2008-04-30 09:53:44 +02:00
|
|
|
len = (tail >= head) ? (tail - head) :
|
|
|
|
(rx_mask + 1 - head);
|
|
|
|
len = tty_prepare_flip_string(tty, &dst,
|
|
|
|
min(len, count));
|
|
|
|
memcpy_fromio(dst, ofs, len);
|
2005-04-17 00:20:36 +02:00
|
|
|
head = (head + len) & rx_mask;
|
|
|
|
count -= len;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pageno = spage + (head >> 13);
|
|
|
|
pageofs = head & Page_mask;
|
2008-04-30 09:53:44 +02:00
|
|
|
while (count > 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
writew(pageno, baseAddr + Control_reg);
|
|
|
|
ofs = baseAddr + DynPage_addr + pageofs;
|
2008-04-30 09:53:44 +02:00
|
|
|
len = tty_prepare_flip_string(tty, &dst,
|
|
|
|
min(Page_size - pageofs, count));
|
|
|
|
memcpy_fromio(dst, ofs, len);
|
|
|
|
|
|
|
|
count -= len;
|
|
|
|
pageofs = (pageofs + len) & Page_mask;
|
|
|
|
if (pageofs == 0 && ++pageno == epage)
|
2005-04-17 00:20:36 +02:00
|
|
|
pageno = spage;
|
2008-04-30 09:53:44 +02:00
|
|
|
}
|
|
|
|
head = (head + total) & rx_mask;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:53:44 +02:00
|
|
|
writew(head, ofsAddr + RXrptr);
|
|
|
|
if (readb(ofsAddr + FlagStat) & Xoff_state) {
|
2005-04-17 00:20:36 +02:00
|
|
|
moxaLowWaterChk = 1;
|
2008-04-30 09:53:40 +02:00
|
|
|
port->lowChkFlag = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:53:44 +02:00
|
|
|
return total;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static int MoxaPortTxQueue(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
void __iomem *ofsAddr = port->tableAddr;
|
2008-04-30 09:53:44 +02:00
|
|
|
u16 rptr, wptr, mask;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
rptr = readw(ofsAddr + TXrptr);
|
|
|
|
wptr = readw(ofsAddr + TXwptr);
|
|
|
|
mask = readw(ofsAddr + TX_mask);
|
2008-04-30 09:53:44 +02:00
|
|
|
return (wptr - rptr) & mask;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static int MoxaPortTxFree(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
void __iomem *ofsAddr = port->tableAddr;
|
2008-04-30 09:53:44 +02:00
|
|
|
u16 rptr, wptr, mask;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
rptr = readw(ofsAddr + TXrptr);
|
|
|
|
wptr = readw(ofsAddr + TXwptr);
|
|
|
|
mask = readw(ofsAddr + TX_mask);
|
2008-04-30 09:53:44 +02:00
|
|
|
return mask - ((wptr - rptr) & mask);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static int MoxaPortRxQueue(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
void __iomem *ofsAddr = port->tableAddr;
|
2008-04-30 09:53:44 +02:00
|
|
|
u16 rptr, wptr, mask;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
rptr = readw(ofsAddr + RXrptr);
|
|
|
|
wptr = readw(ofsAddr + RXwptr);
|
|
|
|
mask = readw(ofsAddr + RX_mask);
|
2008-04-30 09:53:44 +02:00
|
|
|
return (wptr - rptr) & mask;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortTxDisable(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaPortTxEnable(struct moxa_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
moxafunc(port->tableAddr, FC_SetXonState, Magic_code);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-10 10:45:33 +01:00
|
|
|
static int moxa_get_serial_info(struct moxa_port *info,
|
2008-04-30 09:53:46 +02:00
|
|
|
struct serial_struct __user *retinfo)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:46 +02:00
|
|
|
struct serial_struct tmp = {
|
|
|
|
.type = info->type,
|
2008-07-16 22:56:02 +02:00
|
|
|
.line = info->port.tty->index,
|
|
|
|
.flags = info->port.flags,
|
2008-04-30 09:53:46 +02:00
|
|
|
.baud_base = 921600,
|
2008-07-16 22:57:18 +02:00
|
|
|
.close_delay = info->port.close_delay
|
2008-04-30 09:53:46 +02:00
|
|
|
};
|
|
|
|
return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-10 10:45:33 +01:00
|
|
|
static int moxa_set_serial_info(struct moxa_port *info,
|
2008-04-30 09:53:46 +02:00
|
|
|
struct serial_struct __user *new_info)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct serial_struct new_serial;
|
|
|
|
|
2008-04-30 09:53:46 +02:00
|
|
|
if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EFAULT;
|
|
|
|
|
2008-04-30 09:53:46 +02:00
|
|
|
if (new_serial.irq != 0 || new_serial.port != 0 ||
|
|
|
|
new_serial.custom_divisor != 0 ||
|
|
|
|
new_serial.baud_base != 921600)
|
|
|
|
return -EPERM;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
|
|
|
if (((new_serial.flags & ~ASYNC_USR_MASK) !=
|
2008-07-16 22:56:02 +02:00
|
|
|
(info->port.flags & ~ASYNC_USR_MASK)))
|
2008-04-30 09:53:46 +02:00
|
|
|
return -EPERM;
|
|
|
|
} else
|
2008-07-16 22:57:18 +02:00
|
|
|
info->port.close_delay = new_serial.close_delay * HZ / 100;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
|
2008-07-16 22:56:02 +02:00
|
|
|
new_serial.flags |= (info->port.flags & ASYNC_FLAGS);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:53:46 +02:00
|
|
|
MoxaSetFifo(info, new_serial.type == PORT_16550A);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
info->type = new_serial.type;
|
2008-04-30 09:53:46 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Static local functions: *
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-04-30 09:53:40 +02:00
|
|
|
static void MoxaSetFifo(struct moxa_port *port, int enable)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:40 +02:00
|
|
|
void __iomem *ofsAddr = port->tableAddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!enable) {
|
|
|
|
moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);
|
|
|
|
moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);
|
|
|
|
} else {
|
|
|
|
moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);
|
|
|
|
moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);
|
|
|
|
}
|
|
|
|
}
|