Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-10-30 08:42:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Char: moxa, little cleanup

Browse Source 
Cleanup of
- whitespace
- macros
- useless casts
- return (sth); -> return sth;
- types
- superfluous parenthesis and braces
- init tmp directly in moxa_get_serial_info
- commented defunct code
- commented prototypes
- MOXA/moxa printk case

Signed-off-by: Jiri Slaby <jirislaby@gmail.com>
Tested-by: Oyvind Aabling <Oyvind.Aabling@uni-c.dk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Jiri Slaby 2008-04-30 00:53:46 -07:00 committed by Linus Torvalds
parent a8f5cda067
commit eaa95a8da6
1 changed files with 62 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
drivers/char/moxa.c
View File

@ -54,7 +54,6 @@
#define MOXA_FW_HDRLEN 32 #define MOXA_FW_HDRLEN 32
#define MOXAMAJOR 172 #define MOXAMAJOR 172
#define MOXACUMAJOR 173
#define MAX_BOARDS 4 /* Don't change this value */ #define MAX_BOARDS 4 /* Don't change this value */
#define MAX_PORTS_PER_BOARD 32 /* Don't change this value */ #define MAX_PORTS_PER_BOARD 32 /* Don't change this value */
@ -246,7 +245,7 @@ static void moxa_wait_finish(void __iomem *ofsAddr)
printk(KERN_WARNING "moxa function expired\n"); printk(KERN_WARNING "moxa function expired\n");
} }
static void moxafunc(void __iomem *ofsAddr, int cmd, ushort arg) static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)
{ {
writew(arg, ofsAddr + FuncArg); writew(arg, ofsAddr + FuncArg);
writew(cmd, ofsAddr + FuncCode); writew(cmd, ofsAddr + FuncCode);
@ -478,7 +477,7 @@ static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
goto err; goto err;
tmp = readw(baseAddr + C320_status); tmp = readw(baseAddr + C320_status);
if (tmp != STS_init) { if (tmp != STS_init) {
printk(KERN_ERR "moxa: bios upload failed -- CPU/Basic " printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "
"module not found\n"); "module not found\n");
return -EIO; return -EIO;
} }
@ -487,7 +486,7 @@ static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
return 0; return 0;
err: err:
printk(KERN_ERR "moxa: bios upload failed -- board not found\n"); printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");
return -EIO; return -EIO;
} }
@ -497,7 +496,7 @@ static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,
void __iomem *baseAddr = brd->basemem; void __iomem *baseAddr = brd->basemem;
if (len < 7168) { if (len < 7168) {
printk(KERN_ERR "moxa: invalid 320 bios -- too short\n"); printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");
return -EINVAL; return -EINVAL;
} }
@ -642,7 +641,7 @@ static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,
int retval, i; int retval, i;
if (len % 2) { if (len % 2) {
printk(KERN_ERR "moxa: bios length is not even\n"); printk(KERN_ERR "MOXA: bios length is not even\n");
return -EINVAL; return -EINVAL;
} }
@ -764,7 +763,7 @@ static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)
lens[a] = le16_to_cpu(hdr->len[a]); lens[a] = le16_to_cpu(hdr->len[a]);
if (lens[a] && len + lens[a] <= fw->size && if (lens[a] && len + lens[a] <= fw->size &&
moxa_check_fw(&fw->data[len])) moxa_check_fw(&fw->data[len]))
printk(KERN_WARNING "moxa firmware: unexpected input " printk(KERN_WARNING "MOXA firmware: unexpected input "
"at offset %u, but going on\n", (u32)len); "at offset %u, but going on\n", (u32)len);
if (!lens[a] && a < lencnt) { if (!lens[a] && a < lencnt) {
sprintf(rsn, "too few entries in fw file"); sprintf(rsn, "too few entries in fw file");
@ -965,7 +964,7 @@ static int __devinit moxa_pci_probe(struct pci_dev *pdev,
pci_set_drvdata(pdev, board); pci_set_drvdata(pdev, board);
return (0); return 0;
err_base: err_base:
iounmap(board->basemem); iounmap(board->basemem);
board->basemem = NULL; board->basemem = NULL;
@ -1016,10 +1015,8 @@ static int __init moxa_init(void)
moxaDriver->flags = TTY_DRIVER_REAL_RAW; moxaDriver->flags = TTY_DRIVER_REAL_RAW;
tty_set_operations(moxaDriver, &moxa_ops); tty_set_operations(moxaDriver, &moxa_ops);
pr_debug("Moxa tty devices major number = %d\n", ttymajor);
if (tty_register_driver(moxaDriver)) { if (tty_register_driver(moxaDriver)) {
printk(KERN_ERR "Couldn't install MOXA Smartio family driver !\n"); printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");
put_tty_driver(moxaDriver); put_tty_driver(moxaDriver);
return -1; return -1;
} }
@ -1043,7 +1040,7 @@ static int __init moxa_init(void)
brd->busType = MOXA_BUS_TYPE_ISA; brd->busType = MOXA_BUS_TYPE_ISA;
brd->basemem = ioremap(baseaddr[i], 0x4000); brd->basemem = ioremap(baseaddr[i], 0x4000);
if (!brd->basemem) { if (!brd->basemem) {
printk(KERN_ERR "moxa: can't remap %lx\n", printk(KERN_ERR "MOXA: can't remap %lx\n",
baseaddr[i]); baseaddr[i]);
continue; continue;
} }
@ -1063,7 +1060,7 @@ static int __init moxa_init(void)
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
retval = pci_register_driver(&moxa_pci_driver); retval = pci_register_driver(&moxa_pci_driver);
if (retval) { if (retval) {
printk(KERN_ERR "Can't register moxa pci driver!\n"); printk(KERN_ERR "Can't register MOXA pci driver!\n");
if (isabrds) if (isabrds)
retval = 0; retval = 0;
} }
@ -1074,7 +1071,7 @@ static int __init moxa_init(void)
static void __exit moxa_exit(void) static void __exit moxa_exit(void)
{ {
int i; unsigned int i;
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
pci_unregister_driver(&moxa_pci_driver); pci_unregister_driver(&moxa_pci_driver);
@ -1236,12 +1233,8 @@ static int moxa_write(struct tty_struct *tty,
len = MoxaPortWriteData(ch, buf, count); len = MoxaPortWriteData(ch, buf, count);
spin_unlock_bh(&moxa_lock); spin_unlock_bh(&moxa_lock);
/*********************************************
if ( !(ch->statusflags & LOWWAIT) &&
((len != count) || (MoxaPortTxFree(port) <= 100)) )
************************************************/
ch->statusflags |= LOWWAIT; ch->statusflags |= LOWWAIT;
return (len); return len;
} }
static int moxa_write_room(struct tty_struct *tty) static int moxa_write_room(struct tty_struct *tty)
@ -1249,10 +1242,10 @@ static int moxa_write_room(struct tty_struct *tty)
struct moxa_port *ch; struct moxa_port *ch;
if (tty->stopped) if (tty->stopped)
return (0); return 0;
ch = tty->driver_data; ch = tty->driver_data;
if (ch == NULL) if (ch == NULL)
return (0); return 0;
return MoxaPortTxFree(ch); return MoxaPortTxFree(ch);
} }
@ -1278,7 +1271,7 @@ static int moxa_chars_in_buffer(struct tty_struct *tty)
* routine. And since the open() failed, we return 0 here. TDJ * routine. And since the open() failed, we return 0 here. TDJ
*/ */
if (ch == NULL) if (ch == NULL)
return (0); return 0;
chars = MoxaPortTxQueue(ch); chars = MoxaPortTxQueue(ch);
if (chars) { if (chars) {
/* /*
@ -1288,7 +1281,7 @@ static int moxa_chars_in_buffer(struct tty_struct *tty)
if (!(ch->statusflags & EMPTYWAIT)) if (!(ch->statusflags & EMPTYWAIT))
moxa_setup_empty_event(tty); moxa_setup_empty_event(tty);
} }
return (chars); return chars;
} }
static void moxa_flush_chars(struct tty_struct *tty) static void moxa_flush_chars(struct tty_struct *tty)
@ -1308,9 +1301,7 @@ static void moxa_put_char(struct tty_struct *tty, unsigned char c)
spin_lock_bh(&moxa_lock); spin_lock_bh(&moxa_lock);
MoxaPortWriteData(ch, &c, 1); MoxaPortWriteData(ch, &c, 1);
spin_unlock_bh(&moxa_lock); spin_unlock_bh(&moxa_lock);
/************************************************
if ( !(ch->statusflags & LOWWAIT) && (MoxaPortTxFree(port) <= 100) )
*************************************************/
ch->statusflags |= LOWWAIT; ch->statusflags |= LOWWAIT;
} }
@ -1373,34 +1364,33 @@ static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
static void moxa_throttle(struct tty_struct *tty) static void moxa_throttle(struct tty_struct *tty)
{ {
struct moxa_port *ch = (struct moxa_port *) tty->driver_data; struct moxa_port *ch = tty->driver_data;
ch->statusflags |= THROTTLE; ch->statusflags |= THROTTLE;
} }
static void moxa_unthrottle(struct tty_struct *tty) static void moxa_unthrottle(struct tty_struct *tty)
{ {
struct moxa_port *ch = (struct moxa_port *) tty->driver_data; struct moxa_port *ch = tty->driver_data;
ch->statusflags &= ~THROTTLE; ch->statusflags &= ~THROTTLE;
} }
static void moxa_set_termios(struct tty_struct *tty, static void moxa_set_termios(struct tty_struct *tty,
struct ktermios *old_termios) struct ktermios *old_termios)
{ {
struct moxa_port *ch = (struct moxa_port *) tty->driver_data; struct moxa_port *ch = tty->driver_data;
if (ch == NULL) if (ch == NULL)
return; return;
moxa_set_tty_param(tty, old_termios); moxa_set_tty_param(tty, old_termios);
if (!(old_termios->c_cflag & CLOCAL) && if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
(tty->termios->c_cflag & CLOCAL))
wake_up_interruptible(&ch->open_wait); wake_up_interruptible(&ch->open_wait);
} }
static void moxa_stop(struct tty_struct *tty) static void moxa_stop(struct tty_struct *tty)
{ {
struct moxa_port *ch = (struct moxa_port *) tty->driver_data; struct moxa_port *ch = tty->driver_data;
if (ch == NULL) if (ch == NULL)
return; return;
@ -1411,7 +1401,7 @@ static void moxa_stop(struct tty_struct *tty)
static void moxa_start(struct tty_struct *tty) static void moxa_start(struct tty_struct *tty)
{ {
struct moxa_port *ch = (struct moxa_port *) tty->driver_data; struct moxa_port *ch = tty->driver_data;
if (ch == NULL) if (ch == NULL)
return; return;
@ -1444,7 +1434,7 @@ static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)
{ {
dcd = !!dcd; dcd = !!dcd;
if ((dcd != p->DCDState) && p->tty && C_CLOCAL(p->tty)) { if (dcd != p->DCDState && p->tty && C_CLOCAL(p->tty)) {
if (!dcd) if (!dcd)
tty_hangup(p->tty); tty_hangup(p->tty);
} }
@ -1552,12 +1542,10 @@ static void moxa_poll(unsigned long ignored)
static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios) static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)
{ {
register struct ktermios *ts; register struct ktermios *ts = tty->termios;
struct moxa_port *ch; struct moxa_port *ch = tty->driver_data;
int rts, cts, txflow, rxflow, xany, baud; int rts, cts, txflow, rxflow, xany, baud;
ch = (struct moxa_port *) tty->driver_data;
ts = tty->termios;
rts = cts = txflow = rxflow = xany = 0; rts = cts = txflow = rxflow = xany = 0;
if (ts->c_cflag & CRTSCTS) if (ts->c_cflag & CRTSCTS)
rts = cts = 1; rts = cts = 1;
@ -1614,7 +1602,7 @@ static void moxa_shut_down(struct moxa_port *ch)
static void MoxaPortFlushData(struct moxa_port *port, int mode) static void MoxaPortFlushData(struct moxa_port *port, int mode)
{ {
void __iomem *ofsAddr; void __iomem *ofsAddr;
if ((mode < 0) || (mode > 2)) if (mode < 0 || mode > 2)
return; return;
ofsAddr = port->tableAddr; ofsAddr = port->tableAddr;
moxafunc(ofsAddr, FC_FlushQueue, mode); moxafunc(ofsAddr, FC_FlushQueue, mode);
@ -1624,27 +1612,6 @@ static void MoxaPortFlushData(struct moxa_port *port, int mode)
} }
} }
/*****************************************************************************
* Port level functions: *
* 2. MoxaPortEnable(int port); *
* 3. MoxaPortDisable(int port); *
* 4. MoxaPortGetMaxBaud(int port); *
* 6. MoxaPortSetBaud(int port, long baud); *
* 8. MoxaPortSetTermio(int port, unsigned char *termio); *
* 9. MoxaPortGetLineOut(int port, int *dtrState, int *rtsState); *
* 10. MoxaPortLineCtrl(int port, int dtrState, int rtsState); *
* 11. MoxaPortFlowCtrl(int port, int rts, int cts, int rx, int tx,int xany); *
* 12. MoxaPortLineStatus(int port); *
* 15. MoxaPortFlushData(int port, int mode); *
* 16. MoxaPortWriteData(int port, unsigned char * buffer, int length); *
* 17. MoxaPortReadData(int port, struct tty_struct *tty); *
* 20. MoxaPortTxQueue(int port); *
* 21. MoxaPortTxFree(int port); *
* 22. MoxaPortRxQueue(int port); *
* 24. MoxaPortTxDisable(int port); *
* 25. MoxaPortTxEnable(int port); *
* 27. MoxaPortResetBrkCnt(int port); *
*****************************************************************************/
/* /*
* Moxa Port Number Description: * Moxa Port Number Description:
* *
@ -1849,16 +1816,16 @@ static void MoxaPortFlushData(struct moxa_port *port, int mode)
static void MoxaPortEnable(struct moxa_port *port) static void MoxaPortEnable(struct moxa_port *port)
{ {
void __iomem *ofsAddr; void __iomem *ofsAddr;
short lowwater = 512; u16 lowwater = 512;
ofsAddr = port->tableAddr; ofsAddr = port->tableAddr;
writew(lowwater, ofsAddr + Low_water); writew(lowwater, ofsAddr + Low_water);
if (port->board->boardType == MOXA_BOARD_C320_ISA || if (port->board->boardType == MOXA_BOARD_C320_ISA ||
port->board->boardType == MOXA_BOARD_C320_PCI) { port->board->boardType == MOXA_BOARD_C320_PCI)
moxafunc(ofsAddr, FC_SetBreakIrq, 0); moxafunc(ofsAddr, FC_SetBreakIrq, 0);
} else { else
writew(readw(ofsAddr + HostStat) | WakeupBreak, ofsAddr + HostStat); writew(readw(ofsAddr + HostStat) | WakeupBreak,
} ofsAddr + HostStat);
moxafunc(ofsAddr, FC_SetLineIrq, Magic_code); moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
moxafunc(ofsAddr, FC_FlushQueue, 2); moxafunc(ofsAddr, FC_FlushQueue, 2);
@ -1881,9 +1848,9 @@ static long MoxaPortGetMaxBaud(struct moxa_port *port)
{ {
if (port->board->boardType == MOXA_BOARD_C320_ISA || if (port->board->boardType == MOXA_BOARD_C320_ISA ||
port->board->boardType == MOXA_BOARD_C320_PCI) port->board->boardType == MOXA_BOARD_C320_PCI)
return (460800L); return 460800L;
else else
return (921600L); return 921600L;
} }
@ -1893,8 +1860,8 @@ static long MoxaPortSetBaud(struct moxa_port *port, long baud)
long max, clock; long max, clock;
unsigned int val; unsigned int val;
if ((baud < 50L) || ((max = MoxaPortGetMaxBaud(port)) == 0)) if (baud < 50L || (max = MoxaPortGetMaxBaud(port)) == 0)
return (0); return 0;
ofsAddr = port->tableAddr; ofsAddr = port->tableAddr;
if (baud > max) if (baud > max)
baud = max; baud = max;
@ -1907,7 +1874,7 @@ static long MoxaPortSetBaud(struct moxa_port *port, long baud)
val = clock / baud; val = clock / baud;
moxafunc(ofsAddr, FC_SetBaud, val); moxafunc(ofsAddr, FC_SetBaud, val);
baud = clock / val; baud = clock / val;
return (baud); return baud;
} }
static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio, static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
@ -1946,12 +1913,12 @@ static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
} else } else
mode |= MX_PARNONE; mode |= MX_PARNONE;
moxafunc(ofsAddr, FC_SetDataMode, (ushort) mode); moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);
if (port->board->boardType == MOXA_BOARD_C320_ISA || if (port->board->boardType == MOXA_BOARD_C320_ISA ||
port->board->boardType == MOXA_BOARD_C320_PCI) { port->board->boardType == MOXA_BOARD_C320_PCI) {
if (baud >= 921600L) if (baud >= 921600L)
return (-1); return -1;
} }
baud = MoxaPortSetBaud(port, baud); baud = MoxaPortSetBaud(port, baud);
@ -1962,24 +1929,23 @@ static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
moxa_wait_finish(ofsAddr); moxa_wait_finish(ofsAddr);
} }
return (baud); return baud;
} }
static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState, static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,
int *rtsState) int *rtsState)
{ {
if (dtrState) if (dtrState)
*dtrState = !!(port->lineCtrl & DTR_ON); *dtrState = !!(port->lineCtrl & DTR_ON);
if (rtsState) if (rtsState)
*rtsState = !!(port->lineCtrl & RTS_ON); *rtsState = !!(port->lineCtrl & RTS_ON);
return (0); return 0;
} }
static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts) static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)
{ {
int mode = 0; u8 mode = 0;
if (dtr) if (dtr)
mode |= DTR_ON; mode |= DTR_ON;
@ -2193,60 +2159,46 @@ static void MoxaPortTxEnable(struct moxa_port *port)
} }
static int moxa_get_serial_info(struct moxa_port *info, static int moxa_get_serial_info(struct moxa_port *info,
struct serial_struct __user *retinfo) struct serial_struct __user *retinfo)
{ {
struct serial_struct tmp; struct serial_struct tmp = {
.type = info->type,
memset(&tmp, 0, sizeof(tmp)); .line = info->tty->index,
tmp.type = info->type; .flags = info->asyncflags,
tmp.line = info->tty->index; .baud_base = 921600,
tmp.port = 0; .close_delay = info->close_delay
tmp.irq = 0; };
tmp.flags = info->asyncflags; return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
tmp.baud_base = 921600;
tmp.close_delay = info->close_delay;
tmp.custom_divisor = 0;
tmp.hub6 = 0;
if(copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
return -EFAULT;
return (0);
} }
static int moxa_set_serial_info(struct moxa_port *info, static int moxa_set_serial_info(struct moxa_port *info,
struct serial_struct __user *new_info) struct serial_struct __user *new_info)
{ {
struct serial_struct new_serial; struct serial_struct new_serial;
if(copy_from_user(&new_serial, new_info, sizeof(new_serial))) if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
return -EFAULT; return -EFAULT;
if ((new_serial.irq != 0) || if (new_serial.irq != 0 || new_serial.port != 0 ||
(new_serial.port != 0) || new_serial.custom_divisor != 0 ||
// (new_serial.type != info->type) || new_serial.baud_base != 921600)
(new_serial.custom_divisor != 0) || return -EPERM;
(new_serial.baud_base != 921600))
return (-EPERM);
if (!capable(CAP_SYS_ADMIN)) { if (!capable(CAP_SYS_ADMIN)) {
if (((new_serial.flags & ~ASYNC_USR_MASK) != if (((new_serial.flags & ~ASYNC_USR_MASK) !=
(info->asyncflags & ~ASYNC_USR_MASK))) (info->asyncflags & ~ASYNC_USR_MASK)))
return (-EPERM); return -EPERM;
} else { } else
info->close_delay = new_serial.close_delay * HZ / 100; info->close_delay = new_serial.close_delay * HZ / 100;
}
new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS); new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
new_serial.flags |= (info->asyncflags & ASYNC_FLAGS); new_serial.flags |= (info->asyncflags & ASYNC_FLAGS);
if (new_serial.type == PORT_16550A) { MoxaSetFifo(info, new_serial.type == PORT_16550A);
MoxaSetFifo(info, 1);
} else {
MoxaSetFifo(info, 0);
}
info->type = new_serial.type; info->type = new_serial.type;
return (0); return 0;
} }