Skip to content

L
linux-davinci
Commit d8d16e47 authored by Jiri Slaby's avatar Jiri Slaby Committed by Linus Torvalds
Browse files
Options

[PATCH] char/isicom: Whitespace cleanup 

Trailing spaces and tabs and space used for indentation deleted.  Indented
content of structures.  Switch/case indent.
Signed-off-by: default avatarJiri Slaby <xslaby@fi.muni.cz>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent d9e39538
Hide whitespace changes
Inline Side-by-side
Showing with 682 additions and 683 deletions
drivers/char/isicom.c
View file @ d8d16e47
...@@ -20,7 +20,7 @@ ...@@ -20,7 +20,7 @@
* 3/9/99 sameer Added support for ISI4616 cards. * 3/9/99 sameer Added support for ISI4616 cards.
* *
* 16/9/99 sameer We do not force RTS low anymore. * 16/9/99 sameer We do not force RTS low anymore.
* This is to prevent the firmware * This is to prevent the firmware
* from getting confused. * from getting confused.
* *
* 26/10/99 sameer Cosmetic changes:The driver now * 26/10/99 sameer Cosmetic changes:The driver now
...@@ -31,28 +31,28 @@ ...@@ -31,28 +31,28 @@
* *
* 10/5/00 sameer Fixed isicom_shutdown_board() * 10/5/00 sameer Fixed isicom_shutdown_board()
* to not lower DTR on all the ports * to not lower DTR on all the ports
* when the last port on the card is * when the last port on the card is
* closed. * closed.
* *
* 10/5/00 sameer Signal mask setup command added * 10/5/00 sameer Signal mask setup command added
* to isicom_setup_port and * to isicom_setup_port and
* isicom_shutdown_port. * isicom_shutdown_port.
* *
* 24/5/00 sameer The driver is now SMP aware. * 24/5/00 sameer The driver is now SMP aware.
* *
* *
* 27/11/00 Vinayak P Risbud Fixed the Driver Crash Problem * 27/11/00 Vinayak P Risbud Fixed the Driver Crash Problem
* *
* *
* 03/01/01 anil .s Added support for resetting the * 03/01/01 anil .s Added support for resetting the
* internal modems on ISI cards. * internal modems on ISI cards.
* *
* 08/02/01 anil .s Upgraded the driver for kernel * 08/02/01 anil .s Upgraded the driver for kernel
* 2.4.x * 2.4.x
* *
* 11/04/01 Kevin Fixed firmware load problem with * 11/04/01 Kevin Fixed firmware load problem with
* ISIHP-4X card * ISIHP-4X card
* *
* 30/04/01 anil .s Fixed the remote login through * 30/04/01 anil .s Fixed the remote login through
* ISI port problem. Now the link * ISI port problem. Now the link
* does not go down before password * does not go down before password
...@@ -62,9 +62,9 @@ ...@@ -62,9 +62,9 @@
* among ISI-PCI cards. * among ISI-PCI cards.
* *
* 03/05/01 anil .s Added support to display the version * 03/05/01 anil .s Added support to display the version
* info during insmod as well as module * info during insmod as well as module
* listing by lsmod. * listing by lsmod.
* *
* 10/05/01 anil .s Done the modifications to the source * 10/05/01 anil .s Done the modifications to the source
* file and Install script so that the * file and Install script so that the
* same installation can be used for * same installation can be used for
...@@ -73,19 +73,19 @@ ...@@ -73,19 +73,19 @@
* 06/06/01 anil .s Now we drop both dtr and rts during * 06/06/01 anil .s Now we drop both dtr and rts during
* shutdown_port as well as raise them * shutdown_port as well as raise them
* during isicom_config_port. * during isicom_config_port.
* *
* 09/06/01 acme@conectiva.com.br use capable, not suser, do * 09/06/01 acme@conectiva.com.br use capable, not suser, do
* restore_flags on failure in * restore_flags on failure in
* isicom_send_break, verify put_user * isicom_send_break, verify put_user
* result * result
* *
* 11/02/03 ranjeeth Added support for 230 Kbps and 460 Kbps * 11/02/03 ranjeeth Added support for 230 Kbps and 460 Kbps
* Baud index extended to 21 * Baud index extended to 21
* *
* 20/03/03 ranjeeth Made to work for Linux Advanced server. * 20/03/03 ranjeeth Made to work for Linux Advanced server.
* Taken care of license warning. * Taken care of license warning.
* *
* 10/12/03 Ravindra Made to work for Fedora Core 1 of * 10/12/03 Ravindra Made to work for Fedora Core 1 of
* Red Hat Distribution * Red Hat Distribution
* *
* 06/01/05 Alan Cox Merged the ISI and base kernel strands * 06/01/05 Alan Cox Merged the ISI and base kernel strands
...@@ -93,10 +93,10 @@ ...@@ -93,10 +93,10 @@
* *
* *********************************************************** * ***********************************************************
* *
* To use this driver you also need the support package. You * To use this driver you also need the support package. You
* can find this in RPM format on * can find this in RPM format on
* ftp://ftp.linux.org.uk/pub/linux/alan * ftp://ftp.linux.org.uk/pub/linux/alan
* *
* You can find the original tools for this direct from Multitech * You can find the original tools for this direct from Multitech
* ftp://ftp.multitech.com/ISI-Cards/ * ftp://ftp.multitech.com/ISI-Cards/
* *
...@@ -161,16 +161,15 @@ static unsigned long tx_count = 0; ...@@ -161,16 +161,15 @@ static unsigned long tx_count = 0;
static int ISILoad_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg); static int ISILoad_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
static void isicom_tx(unsigned long _data); static void isicom_tx(unsigned long _data);
static void isicom_start(struct tty_struct * tty); static void isicom_start(struct tty_struct *tty);
static unsigned char * tmp_buf; static unsigned char *tmp_buf;
static DECLARE_MUTEX(tmp_buf_sem); static DECLARE_MUTEX(tmp_buf_sem);
/* baud index mappings from linux defns to isi */ /* baud index mappings from linux defns to isi */
static signed char linuxb_to_isib[] = { static signed char linuxb_to_isib[] = {
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19
18, 19
}; };
struct isi_board { struct isi_board {
...@@ -216,7 +215,7 @@ static struct isi_port isi_ports[PORT_COUNT]; ...@@ -216,7 +215,7 @@ static struct isi_port isi_ports[PORT_COUNT];
* the kernel lock for the card and have the card in a position that * the kernel lock for the card and have the card in a position that
* it wants to talk. * it wants to talk.
*/ */
static int lock_card(struct isi_board *card) static int lock_card(struct isi_board *card)
{ {
char retries; char retries;
...@@ -225,7 +224,7 @@ static int lock_card(struct isi_board *card) ...@@ -225,7 +224,7 @@ static int lock_card(struct isi_board *card)
for (retries = 0; retries < 100; retries++) { for (retries = 0; retries < 100; retries++) {
spin_lock_irqsave(&card->card_lock, card->flags); spin_lock_irqsave(&card->card_lock, card->flags);
if (inw(base + 0xe) & 0x1) { if (inw(base + 0xe) & 0x1) {
return 1; return 1;
} else { } else {
spin_unlock_irqrestore(&card->card_lock, card->flags); spin_unlock_irqrestore(&card->card_lock, card->flags);
udelay(1000); /* 1ms */ udelay(1000); /* 1ms */
...@@ -244,7 +243,7 @@ static int lock_card_at_interrupt(struct isi_board *card) ...@@ -244,7 +243,7 @@ static int lock_card_at_interrupt(struct isi_board *card)
spin_lock_irqsave(&card->card_lock, card->flags); spin_lock_irqsave(&card->card_lock, card->flags);
if (inw(base + 0xe) & 0x1) if (inw(base + 0xe) & 0x1)
return 1; return 1;
else else
spin_unlock_irqrestore(&card->card_lock, card->flags); spin_unlock_irqrestore(&card->card_lock, card->flags);
} }
...@@ -260,119 +259,119 @@ static void unlock_card(struct isi_board *card) ...@@ -260,119 +259,119 @@ static void unlock_card(struct isi_board *card)
/* /*
* ISI Card specific ops ... * ISI Card specific ops ...
*/ */
static void raise_dtr(struct isi_port * port) static void raise_dtr(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
unsigned char channel = port->channel; unsigned char channel = port->channel;
if (!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | (channel << card->shift_count) | 0x02 , base); outw(0x8000 | (channel << card->shift_count) | 0x02, base);
outw(0x0504, base); outw(0x0504, base);
InterruptTheCard(base); InterruptTheCard(base);
port->status |= ISI_DTR; port->status |= ISI_DTR;
unlock_card(card); unlock_card(card);
} }
static inline void drop_dtr(struct isi_port * port) static inline void drop_dtr(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
unsigned char channel = port->channel; unsigned char channel = port->channel;
if (!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | (channel << card->shift_count) | 0x02 , base); outw(0x8000 | (channel << card->shift_count) | 0x02, base);
outw(0x0404, base); outw(0x0404, base);
InterruptTheCard(base); InterruptTheCard(base);
port->status &= ~ISI_DTR; port->status &= ~ISI_DTR;
unlock_card(card); unlock_card(card);
} }
static inline void raise_rts(struct isi_port * port) static inline void raise_rts(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
unsigned char channel = port->channel; unsigned char channel = port->channel;
if (!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | (channel << card->shift_count) | 0x02 , base); outw(0x8000 | (channel << card->shift_count) | 0x02, base);
outw(0x0a04, base); outw(0x0a04, base);
InterruptTheCard(base); InterruptTheCard(base);
port->status |= ISI_RTS; port->status |= ISI_RTS;
unlock_card(card); unlock_card(card);
} }
static inline void drop_rts(struct isi_port * port) static inline void drop_rts(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
unsigned char channel = port->channel; unsigned char channel = port->channel;
if (!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | (channel << card->shift_count) | 0x02 , base); outw(0x8000 | (channel << card->shift_count) | 0x02, base);
outw(0x0804, base); outw(0x0804, base);
InterruptTheCard(base); InterruptTheCard(base);
port->status &= ~ISI_RTS; port->status &= ~ISI_RTS;
unlock_card(card); unlock_card(card);
} }
static inline void raise_dtr_rts(struct isi_port * port) static inline void raise_dtr_rts(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
unsigned char channel = port->channel; unsigned char channel = port->channel;
if (!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | (channel << card->shift_count) | 0x02 , base); outw(0x8000 | (channel << card->shift_count) | 0x02, base);
outw(0x0f04, base); outw(0x0f04, base);
InterruptTheCard(base); InterruptTheCard(base);
port->status |= (ISI_DTR | ISI_RTS); port->status |= (ISI_DTR | ISI_RTS);
unlock_card(card); unlock_card(card);
} }
static void drop_dtr_rts(struct isi_port * port) static void drop_dtr_rts(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
unsigned char channel = port->channel; unsigned char channel = port->channel;
if (!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | (channel << card->shift_count) | 0x02 , base); outw(0x8000 | (channel << card->shift_count) | 0x02, base);
outw(0x0c04, base); outw(0x0c04, base);
InterruptTheCard(base); InterruptTheCard(base);
port->status &= ~(ISI_RTS | ISI_DTR); port->status &= ~(ISI_RTS | ISI_DTR);
unlock_card(card); unlock_card(card);
} }
static inline void kill_queue(struct isi_port * port, short queue) static inline void kill_queue(struct isi_port *port, short queue)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
unsigned char channel = port->channel; unsigned char channel = port->channel;
if (!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | (channel << card->shift_count) | 0x02 , base); outw(0x8000 | (channel << card->shift_count) | 0x02, base);
outw((queue << 8) | 0x06, base); outw((queue << 8) | 0x06, base);
InterruptTheCard(base); InterruptTheCard(base);
unlock_card(card); unlock_card(card);
} }
/* /*
* Firmware loader driver specific routines. This needs to mostly die * Firmware loader driver specific routines. This needs to mostly die
* and be replaced with request_firmware. * and be replaced with request_firmware.
*/ */
...@@ -386,19 +385,19 @@ static struct miscdevice isiloader_device = { ...@@ -386,19 +385,19 @@ static struct miscdevice isiloader_device = {
ISILOAD_MISC_MINOR, "isictl", &ISILoad_fops ISILOAD_MISC_MINOR, "isictl", &ISILoad_fops
}; };
static inline int WaitTillCardIsFree(unsigned short base) static inline int WaitTillCardIsFree(unsigned short base)
{ {
unsigned long count=0; unsigned long count=0;
while( (!(inw(base+0xe) & 0x1)) && (count++ < 6000000)); while( (!(inw(base+0xe) & 0x1)) && (count++ < 6000000));
if (inw(base+0xe)&0x1) if (inw(base+0xe)&0x1)
return 0; return 0;
else else
return 1; return 1;
} }
static int ISILoad_ioctl(struct inode *inode, struct file *filp, static int ISILoad_ioctl(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
unsigned int card, i, j, signature, status, portcount = 0; unsigned int card, i, j, signature, status, portcount = 0;
unsigned long t; unsigned long t;
...@@ -406,213 +405,211 @@ static int ISILoad_ioctl(struct inode *inode, struct file *filp, ...@@ -406,213 +405,211 @@ static int ISILoad_ioctl(struct inode *inode, struct file *filp,
bin_frame frame; bin_frame frame;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
/* exec_record exec_rec; */ /* exec_record exec_rec; */
if(get_user(card, (int __user *)argp)) if (get_user(card, (int __user *)argp))
return -EFAULT; return -EFAULT;
if(card < 0 || card >= BOARD_COUNT) if (card < 0 || card >= BOARD_COUNT)
return -ENXIO; return -ENXIO;
base=isi_card[card].base; base=isi_card[card].base;
if(base==0) if (base==0)
return -ENXIO; /* disabled or not used */ return -ENXIO; /* disabled or not used */
switch(cmd) { switch(cmd) {
case MIOCTL_RESET_CARD: case MIOCTL_RESET_CARD:
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
printk(KERN_DEBUG "ISILoad:Resetting Card%d at 0x%x ",card+1,base); printk(KERN_DEBUG "ISILoad:Resetting Card%d at 0x%x ",card+1,base);
inw(base+0x8); inw(base+0x8);
for(t=jiffies+HZ/100;time_before(jiffies, t);); for (t=jiffies+HZ/100;time_before(jiffies, t););
outw(0,base+0x8); /* Reset */ outw(0,base+0x8); /* Reset */
for(j=1;j<=3;j++) { for (j=1;j<=3;j++) {
for(t=jiffies+HZ;time_before(jiffies, t);); for (t=jiffies+HZ;time_before(jiffies, t););
printk("."); printk(".");
} }
signature=(inw(base+0x4)) & 0xff; signature=(inw(base+0x4)) & 0xff;
if (isi_card[card].isa) { if (isi_card[card].isa) {
if (!(inw(base+0xe) & 0x1) || (inw(base+0x2))) { if (!(inw(base+0xe) & 0x1) || (inw(base+0x2))) {
#ifdef ISICOM_DEBUG
printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe));
#endif
printk("\nISILoad:ISA Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
return -EIO;
}
}
else {
portcount = inw(base+0x2);
if (!(inw(base+0xe) & 0x1) || ((portcount!=0) && (portcount!=4) && (portcount!=8))) {
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe)); printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe));
#endif #endif
printk("\nISILoad:PCI Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base); printk("\nISILoad:ISA Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
return -EIO; return -EIO;
} }
} }
switch(signature) { else {
case 0xa5: portcount = inw(base+0x2);
case 0xbb: if (!(inw(base+0xe) & 0x1) || ((portcount!=0) && (portcount!=4) && (portcount!=8))) {
case 0xdd: #ifdef ISICOM_DEBUG
if (isi_card[card].isa) printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe));
isi_card[card].port_count = 8; #endif
else { printk("\nISILoad:PCI Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
if (portcount == 4) return -EIO;
isi_card[card].port_count = 4;
else
isi_card[card].port_count = 8;
}
isi_card[card].shift_count = 12;
break;
case 0xcc: isi_card[card].port_count = 16;
isi_card[card].shift_count = 11;
break;
default: printk("ISILoad:Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
#ifdef ISICOM_DEBUG
printk("Sig=0x%x\n",signature);
#endif
return -EIO;
} }
printk("-Done\n"); }
return put_user(signature,(unsigned __user *)argp); switch(signature) {
case 0xa5:
case 0xbb:
case 0xdd:
if (isi_card[card].isa)
isi_card[card].port_count = 8;
else {
if (portcount == 4)
isi_card[card].port_count = 4;
else
isi_card[card].port_count = 8;
}
isi_card[card].shift_count = 12;
break;
case 0xcc: isi_card[card].port_count = 16;
isi_card[card].shift_count = 11;
break;
default: printk("ISILoad:Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
#ifdef ISICOM_DEBUG
printk("Sig=0x%x\n",signature);
#endif
return -EIO;
}
printk("-Done\n");
return put_user(signature,(unsigned __user *)argp);
case MIOCTL_LOAD_FIRMWARE: case MIOCTL_LOAD_FIRMWARE:
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
if(copy_from_user(&frame, argp, sizeof(bin_frame))) if (copy_from_user(&frame, argp, sizeof(bin_frame)))
return -EFAULT; return -EFAULT;
if (WaitTillCardIsFree(base)) if (WaitTillCardIsFree(base))
return -EIO; return -EIO;
outw(0xf0,base); /* start upload sequence */ outw(0xf0,base); /* start upload sequence */
outw(0x00,base); outw(0x00,base);
outw((frame.addr), base);/* lsb of adderess */ outw((frame.addr), base); /* lsb of adderess */
word_count=(frame.count >> 1) + frame.count % 2; word_count=(frame.count >> 1) + frame.count % 2;
outw(word_count, base); outw(word_count, base);
InterruptTheCard(base); InterruptTheCard(base);
for(i=0;i<=0x2f;i++); /* a wee bit of delay */ for (i=0;i<=0x2f;i++); /* a wee bit of delay */
if (WaitTillCardIsFree(base)) if (WaitTillCardIsFree(base))
return -EIO; return -EIO;
if ((status=inw(base+0x4))!=0) { if ((status=inw(base+0x4))!=0) {
printk(KERN_WARNING "ISILoad:Card%d rejected load header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n", printk(KERN_WARNING "ISILoad:Card%d rejected load header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n",
card+1, frame.addr, frame.count, status); card+1, frame.addr, frame.count, status);
return -EIO; return -EIO;
} }
outsw(base, (void *) frame.bin_data, word_count); outsw(base, (void *) frame.bin_data, word_count);
InterruptTheCard(base); InterruptTheCard(base);
for(i=0;i<=0x0f;i++); /* another wee bit of delay */ for (i=0;i<=0x0f;i++); /* another wee bit of delay */
if (WaitTillCardIsFree(base)) if (WaitTillCardIsFree(base))
return -EIO; return -EIO;
if ((status=inw(base+0x4))!=0) { if ((status=inw(base+0x4))!=0) {
printk(KERN_ERR "ISILoad:Card%d got out of sync.Card Status:0x%x\n",card+1, status); printk(KERN_ERR "ISILoad:Card%d got out of sync.Card Status:0x%x\n",card+1, status);
return -EIO; return -EIO;
} }
return 0; return 0;
case MIOCTL_READ_FIRMWARE: case MIOCTL_READ_FIRMWARE:
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
if(copy_from_user(&frame, argp, sizeof(bin_header))) if (copy_from_user(&frame, argp, sizeof(bin_header)))
return -EFAULT; return -EFAULT;
if (WaitTillCardIsFree(base)) if (WaitTillCardIsFree(base))
return -EIO; return -EIO;
outw(0xf1,base); /* start download sequence */ outw(0xf1,base); /* start download sequence */
outw(0x00,base); outw(0x00,base);
outw((frame.addr), base);/* lsb of adderess */ outw((frame.addr), base); /* lsb of adderess */
word_count=(frame.count >> 1) + frame.count % 2; word_count=(frame.count >> 1) + frame.count % 2;
outw(word_count+1, base); outw(word_count+1, base);
InterruptTheCard(base); InterruptTheCard(base);
for(i=0;i<=0xf;i++); /* a wee bit of delay */ for (i=0;i<=0xf;i++); /* a wee bit of delay */
if (WaitTillCardIsFree(base)) if (WaitTillCardIsFree(base))
return -EIO; return -EIO;
if ((status=inw(base+0x4))!=0) { if ((status=inw(base+0x4))!=0) {
printk(KERN_WARNING "ISILoad:Card%d rejected verify header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n", printk(KERN_WARNING "ISILoad:Card%d rejected verify header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n",
card+1, frame.addr, frame.count, status); card+1, frame.addr, frame.count, status);
return -EIO; return -EIO;
} }
inw(base); inw(base);
insw(base, frame.bin_data, word_count); insw(base, frame.bin_data, word_count);
InterruptTheCard(base); InterruptTheCard(base);
for(i=0;i<=0x0f;i++); /* another wee bit of delay */ for (i=0;i<=0x0f;i++); /* another wee bit of delay */
if (WaitTillCardIsFree(base)) if (WaitTillCardIsFree(base))
return -EIO; return -EIO;
if ((status=inw(base+0x4))!=0) { if ((status=inw(base+0x4))!=0) {
printk(KERN_ERR "ISILoad:Card%d verify got out of sync.Card Status:0x%x\n",card+1, status); printk(KERN_ERR "ISILoad:Card%d verify got out of sync.Card Status:0x%x\n",card+1, status);
return -EIO; return -EIO;
} }
if(copy_to_user(argp, &frame, sizeof(bin_frame))) if (copy_to_user(argp, &frame, sizeof(bin_frame)))
return -EFAULT; return -EFAULT;
return 0; return 0;
case MIOCTL_XFER_CTRL: case MIOCTL_XFER_CTRL:
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
if (WaitTillCardIsFree(base)) if (WaitTillCardIsFree(base))
return -EIO; return -EIO;
outw(0xf2, base); outw(0xf2, base);
outw(0x800, base); outw(0x800, base);
outw(0x0, base); outw(0x0, base);
outw(0x0, base); outw(0x0, base);
InterruptTheCard(base); InterruptTheCard(base);
outw(0x0, base+0x4); /* for ISI4608 cards */ outw(0x0, base+0x4); /* for ISI4608 cards */
isi_card[card].status |= FIRMWARE_LOADED; isi_card[card].status |= FIRMWARE_LOADED;
return 0; return 0;
default: default:
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISILoad: Received Ioctl cmd 0x%x.\n", cmd); printk(KERN_DEBUG "ISILoad: Received Ioctl cmd 0x%x.\n", cmd);
#endif #endif
return -ENOIOCTLCMD; return -ENOIOCTLCMD;
} }
} }
/* /*
* ISICOM Driver specific routines ... * ISICOM Driver specific routines ...
* *
*/ */
static inline int isicom_paranoia_check(struct isi_port const * port, char *name, static inline int isicom_paranoia_check(struct isi_port const *port, char *name,
const char * routine) const char *routine)
{ {
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
static const char * badmagic = static const char *badmagic =
KERN_WARNING "ISICOM: Warning: bad isicom magic for dev %s in %s.\n"; KERN_WARNING "ISICOM: Warning: bad isicom magic for dev %s in %s.\n";
static const char * badport = static const char *badport =
KERN_WARNING "ISICOM: Warning: NULL isicom port for dev %s in %s.\n"; KERN_WARNING "ISICOM: Warning: NULL isicom port for dev %s in %s.\n";
if (!port) { if (!port) {
printk(badport, name, routine); printk(badport, name, routine);
return 1; return 1;
...@@ -620,13 +617,13 @@ static inline int isicom_paranoia_check(struct isi_port const * port, char *name ...@@ -620,13 +617,13 @@ static inline int isicom_paranoia_check(struct isi_port const * port, char *name
if (port->magic != ISICOM_MAGIC) { if (port->magic != ISICOM_MAGIC) {
printk(badmagic, name, routine); printk(badmagic, name, routine);
return 1; return 1;
} }
#endif #endif
return 0; return 0;
} }
/* /*
* Transmitter. * Transmitter.
* *
* We shovel data into the card buffers on a regular basis. The card * We shovel data into the card buffers on a regular basis. The card
* will do the rest of the work for us. * will do the rest of the work for us.
...@@ -636,25 +633,25 @@ static void isicom_tx(unsigned long _data) ...@@ -636,25 +633,25 @@ static void isicom_tx(unsigned long _data)
{ {
short count = (BOARD_COUNT-1), card, base; short count = (BOARD_COUNT-1), card, base;
short txcount, wrd, residue, word_count, cnt; short txcount, wrd, residue, word_count, cnt;
struct isi_port * port; struct isi_port *port;
struct tty_struct * tty; struct tty_struct *tty;
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
++tx_count; ++tx_count;
#endif #endif
/* find next active board */ /* find next active board */
card = (prev_card + 1) & 0x0003; card = (prev_card + 1) & 0x0003;
while(count-- > 0) { while(count-- > 0) {
if (isi_card[card].status & BOARD_ACTIVE) if (isi_card[card].status & BOARD_ACTIVE)
break; break;
card = (card + 1) & 0x0003; card = (card + 1) & 0x0003;
} }
if (!(isi_card[card].status & BOARD_ACTIVE)) if (!(isi_card[card].status & BOARD_ACTIVE))
goto sched_again; goto sched_again;
prev_card = card; prev_card = card;
count = isi_card[card].port_count; count = isi_card[card].port_count;
port = isi_card[card].ports; port = isi_card[card].ports;
base = isi_card[card].base; base = isi_card[card].base;
...@@ -663,18 +660,18 @@ static void isicom_tx(unsigned long _data) ...@@ -663,18 +660,18 @@ static void isicom_tx(unsigned long _data)
continue; continue;
/* port not active or tx disabled to force flow control */ /* port not active or tx disabled to force flow control */
if (!(port->flags & ASYNC_INITIALIZED) || if (!(port->flags & ASYNC_INITIALIZED) ||
!(port->status & ISI_TXOK)) !(port->status & ISI_TXOK))
unlock_card(&isi_card[card]); unlock_card(&isi_card[card]);
continue; continue;
tty = port->tty; tty = port->tty;
if(tty == NULL) { if (tty == NULL) {
unlock_card(&isi_card[card]); unlock_card(&isi_card[card]);
continue; continue;
} }
txcount = min_t(short, TX_SIZE, port->xmit_cnt); txcount = min_t(short, TX_SIZE, port->xmit_cnt);
if (txcount <= 0 || tty->stopped || tty->hw_stopped) { if (txcount <= 0 || tty->stopped || tty->hw_stopped) {
unlock_card(&isi_card[card]); unlock_card(&isi_card[card]);
...@@ -682,16 +679,16 @@ static void isicom_tx(unsigned long _data) ...@@ -682,16 +679,16 @@ static void isicom_tx(unsigned long _data)
} }
if (!(inw(base + 0x02) & (1 << port->channel))) { if (!(inw(base + 0x02) & (1 << port->channel))) {
unlock_card(&isi_card[card]); unlock_card(&isi_card[card]);
continue; continue;
} }
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: txing %d bytes, port%d.\n", printk(KERN_DEBUG "ISICOM: txing %d bytes, port%d.\n",
txcount, port->channel+1); txcount, port->channel+1);
#endif #endif
outw((port->channel << isi_card[card].shift_count) | txcount outw((port->channel << isi_card[card].shift_count) | txcount
, base); , base);
residue = NO; residue = NO;
wrd = 0; wrd = 0;
while (1) { while (1) {
cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE - port->xmit_tail)); cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE - port->xmit_tail));
if (residue == YES) { if (residue == YES) {
...@@ -702,13 +699,13 @@ static void isicom_tx(unsigned long _data) ...@@ -702,13 +699,13 @@ static void isicom_tx(unsigned long _data)
port->xmit_cnt--; port->xmit_cnt--;
txcount--; txcount--;
cnt--; cnt--;
outw(wrd, base); outw(wrd, base);
} }
else { else {
outw(wrd, base); outw(wrd, base);
break; break;
} }
} }
if (cnt <= 0) break; if (cnt <= 0) break;
word_count = cnt >> 1; word_count = cnt >> 1;
outsw(base, port->xmit_buf+port->xmit_tail, word_count); outsw(base, port->xmit_buf+port->xmit_tail, word_count);
...@@ -731,68 +728,68 @@ static void isicom_tx(unsigned long _data) ...@@ -731,68 +728,68 @@ static void isicom_tx(unsigned long _data)
if (port->xmit_cnt <= WAKEUP_CHARS) if (port->xmit_cnt <= WAKEUP_CHARS)
schedule_work(&port->bh_tqueue); schedule_work(&port->bh_tqueue);
unlock_card(&isi_card[card]); unlock_card(&isi_card[card]);
} }
/* schedule another tx for hopefully in about 10ms */ /* schedule another tx for hopefully in about 10ms */
sched_again: sched_again:
if (!re_schedule) if (!re_schedule)
return; return;
init_timer(&tx); init_timer(&tx);
tx.expires = jiffies + HZ/100; tx.expires = jiffies + HZ/100;
tx.data = 0; tx.data = 0;
tx.function = isicom_tx; tx.function = isicom_tx;
add_timer(&tx); add_timer(&tx);
return; return;
} }
/* Interrupt handlers */ /* Interrupt handlers */
static void isicom_bottomhalf(void * data) static void isicom_bottomhalf(void *data)
{ {
struct isi_port * port = (struct isi_port *) data; struct isi_port *port = (struct isi_port *) data;
struct tty_struct * tty = port->tty; struct tty_struct *tty = port->tty;
if (!tty) if (!tty)
return; return;
tty_wakeup(tty); tty_wakeup(tty);
wake_up_interruptible(&tty->write_wait); wake_up_interruptible(&tty->write_wait);
} }
/* /*
* Main interrupt handler routine * Main interrupt handler routine
*/ */
static irqreturn_t isicom_interrupt(int irq, void *dev_id, static irqreturn_t isicom_interrupt(int irq, void *dev_id,
struct pt_regs *regs) struct pt_regs *regs)
{ {
struct isi_board * card; struct isi_board *card;
struct isi_port * port; struct isi_port *port;
struct tty_struct * tty; struct tty_struct *tty;
unsigned short base, header, word_count, count; unsigned short base, header, word_count, count;
unsigned char channel; unsigned char channel;
short byte_count; short byte_count;
unsigned char *rp; unsigned char *rp;
card = (struct isi_board *) dev_id; card = (struct isi_board *) dev_id;
if (!card || !(card->status & FIRMWARE_LOADED)) if (!card || !(card->status & FIRMWARE_LOADED))
return IRQ_NONE; return IRQ_NONE;
base = card->base; base = card->base;
spin_lock(&card->card_lock); spin_lock(&card->card_lock);
if (card->isa == NO) { if (card->isa == NO) {
/* /*
* disable any interrupts from the PCI card and lower the * disable any interrupts from the PCI card and lower the
* interrupt line * interrupt line
*/ */
outw(0x8000, base+0x04); outw(0x8000, base+0x04);
ClearInterrupt(base); ClearInterrupt(base);
} }
inw(base); /* get the dummy word out */ inw(base); /* get the dummy word out */
header = inw(base); header = inw(base);
channel = (header & 0x7800) >> card->shift_count; channel = (header & 0x7800) >> card->shift_count;
...@@ -804,9 +801,9 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, ...@@ -804,9 +801,9 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id,
if (card->isa) if (card->isa)
ClearInterrupt(base); ClearInterrupt(base);
else else
outw(0x0000, base+0x04); /* enable interrupts */ outw(0x0000, base+0x04); /* enable interrupts */
spin_unlock(&card->card_lock); spin_unlock(&card->card_lock);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
port = card->ports + channel; port = card->ports + channel;
if (!(port->flags & ASYNC_INITIALIZED)) { if (!(port->flags & ASYNC_INITIALIZED)) {
...@@ -815,8 +812,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, ...@@ -815,8 +812,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id,
else else
outw(0x0000, base+0x04); /* enable interrupts */ outw(0x0000, base+0x04); /* enable interrupts */
return IRQ_HANDLED; return IRQ_HANDLED;
} }
tty = port->tty; tty = port->tty;
if (tty == NULL) { if (tty == NULL) {
word_count = byte_count >> 1; word_count = byte_count >> 1;
...@@ -833,107 +830,107 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, ...@@ -833,107 +830,107 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id,
spin_unlock(&card->card_lock); spin_unlock(&card->card_lock);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
if (header & 0x8000) { /* Status Packet */ if (header & 0x8000) { /* Status Packet */
header = inw(base); header = inw(base);
switch(header & 0xff) { switch(header & 0xff) {
case 0: /* Change in EIA signals */ case 0: /* Change in EIA signals */
if (port->flags & ASYNC_CHECK_CD) { if (port->flags & ASYNC_CHECK_CD) {
if (port->status & ISI_DCD) { if (port->status & ISI_DCD) {
if (!(header & ISI_DCD)) { if (!(header & ISI_DCD)) {
/* Carrier has been lost */ /* Carrier has been lost */
#ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: interrupt: DCD->low.\n");
#endif
port->status &= ~ISI_DCD;
schedule_work(&port->hangup_tq);
}
}
else {
if (header & ISI_DCD) {
/* Carrier has been detected */
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: interrupt: DCD->high.\n"); printk(KERN_DEBUG "ISICOM: interrupt: DCD->low.\n");
#endif #endif
port->status |= ISI_DCD; port->status &= ~ISI_DCD;
wake_up_interruptible(&port->open_wait); schedule_work(&port->hangup_tq);
}
} }
} }
else { else {
if (header & ISI_DCD) if (header & ISI_DCD) {
/* Carrier has been detected */
#ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: interrupt: DCD->high.\n");
#endif
port->status |= ISI_DCD; port->status |= ISI_DCD;
else wake_up_interruptible(&port->open_wait);
port->status &= ~ISI_DCD;
}
if (port->flags & ASYNC_CTS_FLOW) {
if (port->tty->hw_stopped) {
if (header & ISI_CTS) {
port->tty->hw_stopped = 0;
/* start tx ing */
port->status |= (ISI_TXOK | ISI_CTS);
schedule_work(&port->bh_tqueue);
}
} }
else { }
if (!(header & ISI_CTS)) { }
port->tty->hw_stopped = 1; else {
/* stop tx ing */ if (header & ISI_DCD)
port->status &= ~(ISI_TXOK | ISI_CTS); port->status |= ISI_DCD;
} else
port->status &= ~ISI_DCD;
}
if (port->flags & ASYNC_CTS_FLOW) {
if (port->tty->hw_stopped) {
if (header & ISI_CTS) {
port->tty->hw_stopped = 0;
/* start tx ing */
port->status |= (ISI_TXOK | ISI_CTS);
schedule_work(&port->bh_tqueue);
} }
} }
else { else {
if (header & ISI_CTS) if (!(header & ISI_CTS)) {
port->status |= ISI_CTS; port->tty->hw_stopped = 1;
else /* stop tx ing */
port->status &= ~ISI_CTS; port->status &= ~(ISI_TXOK | ISI_CTS);
}
} }
}
if (header & ISI_DSR) else {
port->status |= ISI_DSR; if (header & ISI_CTS)
else port->status |= ISI_CTS;
port->status &= ~ISI_DSR;
if (header & ISI_RI)
port->status |= ISI_RI;
else else
port->status &= ~ISI_RI; port->status &= ~ISI_CTS;
}
break;
if (header & ISI_DSR)
case 1: /* Received Break !!! */ port->status |= ISI_DSR;
tty_insert_flip_char(tty, 0, TTY_BREAK); else
if (port->flags & ASYNC_SAK) port->status &= ~ISI_DSR;
do_SAK(tty);
tty_flip_buffer_push(tty); if (header & ISI_RI)
break; port->status |= ISI_RI;
else
case 2: /* Statistics */ port->status &= ~ISI_RI;
printk(KERN_DEBUG "ISICOM: isicom_interrupt: stats!!!.\n");
break; break;
default: case 1: /* Received Break !!! */
printk(KERN_WARNING "ISICOM: Intr: Unknown code in status packet.\n"); tty_insert_flip_char(tty, 0, TTY_BREAK);
break; if (port->flags & ASYNC_SAK)
} do_SAK(tty);
tty_flip_buffer_push(tty);
break;
case 2: /* Statistics */
printk(KERN_DEBUG "ISICOM: isicom_interrupt: stats!!!.\n");
break;
default:
printk(KERN_WARNING "ISICOM: Intr: Unknown code in status packet.\n");
break;
}
} }
else { /* Data Packet */ else { /* Data Packet */
count = tty_prepare_flip_string(tty, &rp, byte_count & ~1); count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: Intr: Can rx %d of %d bytes.\n", printk(KERN_DEBUG "ISICOM: Intr: Can rx %d of %d bytes.\n",
count, byte_count); count, byte_count);
#endif #endif
word_count = count >> 1; word_count = count >> 1;
insw(base, rp, word_count); insw(base, rp, word_count);
byte_count -= (word_count << 1); byte_count -= (word_count << 1);
if (count & 0x0001) { if (count & 0x0001) {
tty_insert_flip_char(tty, inw(base) & 0xff, TTY_NORMAL); tty_insert_flip_char(tty, inw(base) & 0xff, TTY_NORMAL);
byte_count -= 2; byte_count -= 2;
} }
if (byte_count > 0) { if (byte_count > 0) {
printk(KERN_DEBUG "ISICOM: Intr(0x%x:%d): Flip buffer overflow! dropping bytes...\n", printk(KERN_DEBUG "ISICOM: Intr(0x%x:%d): Flip buffer overflow! dropping bytes...\n",
base, channel+1); base, channel+1);
...@@ -947,102 +944,102 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, ...@@ -947,102 +944,102 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id,
if (card->isa == YES) if (card->isa == YES)
ClearInterrupt(base); ClearInterrupt(base);
else else
outw(0x0000, base+0x04); /* enable interrupts */ outw(0x0000, base+0x04); /* enable interrupts */
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static void isicom_config_port(struct isi_port * port) static void isicom_config_port(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
struct tty_struct * tty; struct tty_struct *tty;
unsigned long baud; unsigned long baud;
unsigned short channel_setup, base = card->base; unsigned short channel_setup, base = card->base;
unsigned short channel = port->channel, shift_count = card->shift_count; unsigned short channel = port->channel, shift_count = card->shift_count;
unsigned char flow_ctrl; unsigned char flow_ctrl;
if (!(tty = port->tty) || !tty->termios) if (!(tty = port->tty) || !tty->termios)
return; return;
baud = C_BAUD(tty); baud = C_BAUD(tty);
if (baud & CBAUDEX) { if (baud & CBAUDEX) {
baud &= ~CBAUDEX; baud &= ~CBAUDEX;
/* if CBAUDEX bit is on and the baud is set to either 50 or 75 /* if CBAUDEX bit is on and the baud is set to either 50 or 75
* then the card is programmed for 57.6Kbps or 115Kbps * then the card is programmed for 57.6Kbps or 115Kbps
* respectively. * respectively.
*/ */
if (baud < 1 || baud > 2) if (baud < 1 || baud > 2)
port->tty->termios->c_cflag &= ~CBAUDEX; port->tty->termios->c_cflag &= ~CBAUDEX;
else else
baud += 15; baud += 15;
} }
if (baud == 15) { if (baud == 15) {
/* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set /* the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
* by the set_serial_info ioctl ... this is done by * by the set_serial_info ioctl ... this is done by
* the 'setserial' utility. * the 'setserial' utility.
*/ */
if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
baud++; /* 57.6 Kbps */ baud++; /* 57.6 Kbps */
if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
baud +=2; /* 115 Kbps */ baud +=2; /* 115 Kbps */
} }
if (linuxb_to_isib[baud] == -1) { if (linuxb_to_isib[baud] == -1) {
/* hang up */ /* hang up */
drop_dtr(port); drop_dtr(port);
return; return;
} }
else else
raise_dtr(port); raise_dtr(port);
if (lock_card(card)) { if (lock_card(card)) {
outw(0x8000 | (channel << shift_count) |0x03, base); outw(0x8000 | (channel << shift_count) |0x03, base);
outw(linuxb_to_isib[baud] << 8 | 0x03, base); outw(linuxb_to_isib[baud] << 8 | 0x03, base);
channel_setup = 0; channel_setup = 0;
switch(C_CSIZE(tty)) { switch(C_CSIZE(tty)) {
case CS5: case CS5:
channel_setup |= ISICOM_CS5; channel_setup |= ISICOM_CS5;
break; break;
case CS6: case CS6:
channel_setup |= ISICOM_CS6; channel_setup |= ISICOM_CS6;
break; break;
case CS7: case CS7:
channel_setup |= ISICOM_CS7; channel_setup |= ISICOM_CS7;
break; break;
case CS8: case CS8:
channel_setup |= ISICOM_CS8; channel_setup |= ISICOM_CS8;
break; break;
} }
if (C_CSTOPB(tty)) if (C_CSTOPB(tty))
channel_setup |= ISICOM_2SB; channel_setup |= ISICOM_2SB;
if (C_PARENB(tty)) { if (C_PARENB(tty)) {
channel_setup |= ISICOM_EVPAR; channel_setup |= ISICOM_EVPAR;
if (C_PARODD(tty)) if (C_PARODD(tty))
channel_setup |= ISICOM_ODPAR; channel_setup |= ISICOM_ODPAR;
} }
outw(channel_setup, base); outw(channel_setup, base);
InterruptTheCard(base); InterruptTheCard(base);
unlock_card(card); unlock_card(card);
} }
if (C_CLOCAL(tty)) if (C_CLOCAL(tty))
port->flags &= ~ASYNC_CHECK_CD; port->flags &= ~ASYNC_CHECK_CD;
else else
port->flags |= ASYNC_CHECK_CD; port->flags |= ASYNC_CHECK_CD;
/* flow control settings ...*/ /* flow control settings ...*/
flow_ctrl = 0; flow_ctrl = 0;
port->flags &= ~ASYNC_CTS_FLOW; port->flags &= ~ASYNC_CTS_FLOW;
if (C_CRTSCTS(tty)) { if (C_CRTSCTS(tty)) {
port->flags |= ASYNC_CTS_FLOW; port->flags |= ASYNC_CTS_FLOW;
flow_ctrl |= ISICOM_CTSRTS; flow_ctrl |= ISICOM_CTSRTS;
} }
if (I_IXON(tty)) if (I_IXON(tty))
flow_ctrl |= ISICOM_RESPOND_XONXOFF; flow_ctrl |= ISICOM_RESPOND_XONXOFF;
if (I_IXOFF(tty)) if (I_IXOFF(tty))
flow_ctrl |= ISICOM_INITIATE_XONXOFF; flow_ctrl |= ISICOM_INITIATE_XONXOFF;
if (lock_card(card)) { if (lock_card(card)) {
outw(0x8000 | (channel << shift_count) |0x04, base); outw(0x8000 | (channel << shift_count) |0x04, base);
outw(flow_ctrl << 8 | 0x05, base); outw(flow_ctrl << 8 | 0x05, base);
...@@ -1050,22 +1047,22 @@ static void isicom_config_port(struct isi_port * port) ...@@ -1050,22 +1047,22 @@ static void isicom_config_port(struct isi_port * port)
InterruptTheCard(base); InterruptTheCard(base);
unlock_card(card); unlock_card(card);
} }
/* rx enabled -> enable port for rx on the card */ /* rx enabled -> enable port for rx on the card */
if (C_CREAD(tty)) { if (C_CREAD(tty)) {
card->port_status |= (1 << channel); card->port_status |= (1 << channel);
outw(card->port_status, base + 0x02); outw(card->port_status, base + 0x02);
} }
} }
/* open et all */
static inline void isicom_setup_board(struct isi_board * bp) /* open et all */
static inline void isicom_setup_board(struct isi_board *bp)
{ {
int channel; int channel;
struct isi_port * port; struct isi_port *port;
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&bp->card_lock, flags); spin_lock_irqsave(&bp->card_lock, flags);
if (bp->status & BOARD_ACTIVE) { if (bp->status & BOARD_ACTIVE) {
spin_unlock_irqrestore(&bp->card_lock, flags); spin_unlock_irqrestore(&bp->card_lock, flags);
...@@ -1074,53 +1071,53 @@ static inline void isicom_setup_board(struct isi_board * bp) ...@@ -1074,53 +1071,53 @@ static inline void isicom_setup_board(struct isi_board * bp)
port = bp->ports; port = bp->ports;
bp->status |= BOARD_ACTIVE; bp->status |= BOARD_ACTIVE;
spin_unlock_irqrestore(&bp->card_lock, flags); spin_unlock_irqrestore(&bp->card_lock, flags);
for(channel = 0; channel < bp->port_count; channel++, port++) for (channel = 0; channel < bp->port_count; channel++, port++)
drop_dtr_rts(port); drop_dtr_rts(port);
return; return;
} }
static int isicom_setup_port(struct isi_port * port) static int isicom_setup_port(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned long flags; unsigned long flags;
if (port->flags & ASYNC_INITIALIZED) { if (port->flags & ASYNC_INITIALIZED) {
return 0; return 0;
} }
if (!port->xmit_buf) { if (!port->xmit_buf) {
unsigned long page; unsigned long page;
if (!(page = get_zeroed_page(GFP_KERNEL))) if (!(page = get_zeroed_page(GFP_KERNEL)))
return -ENOMEM; return -ENOMEM;
if (port->xmit_buf) { if (port->xmit_buf) {
free_page(page); free_page(page);
return -ERESTARTSYS; return -ERESTARTSYS;
} }
port->xmit_buf = (unsigned char *) page; port->xmit_buf = (unsigned char *) page;
} }
spin_lock_irqsave(&card->card_lock, flags); spin_lock_irqsave(&card->card_lock, flags);
if (port->tty) if (port->tty)
clear_bit(TTY_IO_ERROR, &port->tty->flags); clear_bit(TTY_IO_ERROR, &port->tty->flags);
if (port->count == 1) if (port->count == 1)
card->count++; card->count++;
port->xmit_cnt = port->xmit_head = port->xmit_tail = 0; port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
/* discard any residual data */ /* discard any residual data */
kill_queue(port, ISICOM_KILLTX | ISICOM_KILLRX); kill_queue(port, ISICOM_KILLTX | ISICOM_KILLRX);
isicom_config_port(port); isicom_config_port(port);
port->flags |= ASYNC_INITIALIZED; port->flags |= ASYNC_INITIALIZED;
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
return 0; return 0;
} }
static int block_til_ready(struct tty_struct * tty, struct file * filp, struct isi_port * port) static int block_til_ready(struct tty_struct *tty, struct file *filp, struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
int do_clocal = 0, retval; int do_clocal = 0, retval;
unsigned long flags; unsigned long flags;
DECLARE_WAITQUEUE(wait, current); DECLARE_WAITQUEUE(wait, current);
...@@ -1128,30 +1125,30 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i ...@@ -1128,30 +1125,30 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i
/* block if port is in the process of being closed */ /* block if port is in the process of being closed */
if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) { if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: block_til_ready: close in progress.\n"); printk(KERN_DEBUG "ISICOM: block_til_ready: close in progress.\n");
#endif #endif
interruptible_sleep_on(&port->close_wait); interruptible_sleep_on(&port->close_wait);
if (port->flags & ASYNC_HUP_NOTIFY) if (port->flags & ASYNC_HUP_NOTIFY)
return -EAGAIN; return -EAGAIN;
else else
return -ERESTARTSYS; return -ERESTARTSYS;
} }
/* if non-blocking mode is set ... */ /* if non-blocking mode is set ... */
if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) { if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: block_til_ready: non-block mode.\n"); printk(KERN_DEBUG "ISICOM: block_til_ready: non-block mode.\n");
#endif #endif
port->flags |= ASYNC_NORMAL_ACTIVE; port->flags |= ASYNC_NORMAL_ACTIVE;
return 0; return 0;
} }
if (C_CLOCAL(tty)) if (C_CLOCAL(tty))
do_clocal = 1; do_clocal = 1;
/* block waiting for DCD to be asserted, and while /* block waiting for DCD to be asserted, and while
callout dev is busy */ callout dev is busy */
retval = 0; retval = 0;
add_wait_queue(&port->open_wait, &wait); add_wait_queue(&port->open_wait, &wait);
...@@ -1161,27 +1158,27 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i ...@@ -1161,27 +1158,27 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i
port->count--; port->count--;
port->blocked_open++; port->blocked_open++;
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
while (1) { while (1) {
raise_dtr_rts(port); raise_dtr_rts(port);
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) { if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
if (port->flags & ASYNC_HUP_NOTIFY) if (port->flags & ASYNC_HUP_NOTIFY)
retval = -EAGAIN; retval = -EAGAIN;
else else
retval = -ERESTARTSYS; retval = -ERESTARTSYS;
break; break;
} }
if (!(port->flags & ASYNC_CLOSING) && if (!(port->flags & ASYNC_CLOSING) &&
(do_clocal || (port->status & ISI_DCD))) { (do_clocal || (port->status & ISI_DCD))) {
break; break;
} }
if (signal_pending(current)) { if (signal_pending(current)) {
retval = -ERESTARTSYS; retval = -ERESTARTSYS;
break; break;
} }
schedule(); schedule();
} }
set_current_state(TASK_RUNNING); set_current_state(TASK_RUNNING);
remove_wait_queue(&port->open_wait, &wait); remove_wait_queue(&port->open_wait, &wait);
...@@ -1195,11 +1192,11 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i ...@@ -1195,11 +1192,11 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i
port->flags |= ASYNC_NORMAL_ACTIVE; port->flags |= ASYNC_NORMAL_ACTIVE;
return 0; return 0;
} }
static int isicom_open(struct tty_struct * tty, struct file * filp) static int isicom_open(struct tty_struct *tty, struct file *filp)
{ {
struct isi_port * port; struct isi_port *port;
struct isi_board * card; struct isi_board *card;
unsigned int line, board; unsigned int line, board;
int error; int error;
...@@ -1208,20 +1205,20 @@ static int isicom_open(struct tty_struct * tty, struct file * filp) ...@@ -1208,20 +1205,20 @@ static int isicom_open(struct tty_struct * tty, struct file * filp)
return -ENODEV; return -ENODEV;
board = BOARD(line); board = BOARD(line);
card = &isi_card[board]; card = &isi_card[board];
if (!(card->status & FIRMWARE_LOADED)) if (!(card->status & FIRMWARE_LOADED))
return -ENODEV; return -ENODEV;
/* open on a port greater than the port count for the card !!! */ /* open on a port greater than the port count for the card !!! */
if (line > ((board * 16) + card->port_count - 1)) if (line > ((board * 16) + card->port_count - 1))
return -ENODEV; return -ENODEV;
port = &isi_ports[line]; port = &isi_ports[line];
if (isicom_paranoia_check(port, tty->name, "isicom_open")) if (isicom_paranoia_check(port, tty->name, "isicom_open"))
return -ENODEV; return -ENODEV;
isicom_setup_board(card); isicom_setup_board(card);
port->count++; port->count++;
tty->driver_data = port; tty->driver_data = port;
port->tty = tty; port->tty = tty;
...@@ -1230,12 +1227,12 @@ static int isicom_open(struct tty_struct * tty, struct file * filp) ...@@ -1230,12 +1227,12 @@ static int isicom_open(struct tty_struct * tty, struct file * filp)
if ((error = block_til_ready(tty, filp, port))!=0) if ((error = block_til_ready(tty, filp, port))!=0)
return error; return error;
return 0; return 0;
} }
/* close et all */ /* close et all */
static inline void isicom_shutdown_board(struct isi_board * bp) static inline void isicom_shutdown_board(struct isi_board *bp)
{ {
unsigned long flags; unsigned long flags;
...@@ -1246,15 +1243,15 @@ static inline void isicom_shutdown_board(struct isi_board * bp) ...@@ -1246,15 +1243,15 @@ static inline void isicom_shutdown_board(struct isi_board * bp)
spin_unlock_irqrestore(&bp->card_lock, flags); spin_unlock_irqrestore(&bp->card_lock, flags);
} }
static void isicom_shutdown_port(struct isi_port * port) static void isicom_shutdown_port(struct isi_port *port)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
struct tty_struct * tty; struct tty_struct *tty;
unsigned long flags; unsigned long flags;
tty = port->tty; tty = port->tty;
spin_lock_irqsave(&card->card_lock, flags); spin_lock_irqsave(&card->card_lock, flags);
if (!(port->flags & ASYNC_INITIALIZED)) { if (!(port->flags & ASYNC_INITIALIZED)) {
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
return; return;
...@@ -1262,60 +1259,60 @@ static void isicom_shutdown_port(struct isi_port * port) ...@@ -1262,60 +1259,60 @@ static void isicom_shutdown_port(struct isi_port * port)
if (port->xmit_buf) { if (port->xmit_buf) {
free_page((unsigned long) port->xmit_buf); free_page((unsigned long) port->xmit_buf);
port->xmit_buf = NULL; port->xmit_buf = NULL;
} }
port->flags &= ~ASYNC_INITIALIZED; port->flags &= ~ASYNC_INITIALIZED;
/* 3rd October 2000 : Vinayak P Risbud */ /* 3rd October 2000 : Vinayak P Risbud */
port->tty = NULL; port->tty = NULL;
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
/*Fix done by Anil .S on 30-04-2001 /*Fix done by Anil .S on 30-04-2001
remote login through isi port has dtr toggle problem remote login through isi port has dtr toggle problem
due to which the carrier drops before the password prompt due to which the carrier drops before the password prompt
appears on the remote end. Now we drop the dtr only if the appears on the remote end. Now we drop the dtr only if the
HUPCL(Hangup on close) flag is set for the tty*/ HUPCL(Hangup on close) flag is set for the tty*/
if (C_HUPCL(tty)) if (C_HUPCL(tty))
/* drop dtr on this port */ /* drop dtr on this port */
drop_dtr(port); drop_dtr(port);
/* any other port uninits */ /* any other port uninits */
if (tty) if (tty)
set_bit(TTY_IO_ERROR, &tty->flags); set_bit(TTY_IO_ERROR, &tty->flags);
if (--card->count < 0) { if (--card->count < 0) {
printk(KERN_DEBUG "ISICOM: isicom_shutdown_port: bad board(0x%x) count %d.\n", printk(KERN_DEBUG "ISICOM: isicom_shutdown_port: bad board(0x%x) count %d.\n",
card->base, card->count); card->base, card->count);
card->count = 0; card->count = 0;
} }
/* last port was closed , shutdown that boad too */ /* last port was closed , shutdown that boad too */
if(C_HUPCL(tty)) { if (C_HUPCL(tty)) {
if (!card->count) if (!card->count)
isicom_shutdown_board(card); isicom_shutdown_board(card);
} }
} }
static void isicom_close(struct tty_struct * tty, struct file * filp) static void isicom_close(struct tty_struct *tty, struct file *filp)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned long flags; unsigned long flags;
if (!port) if (!port)
return; return;
if (isicom_paranoia_check(port, tty->name, "isicom_close")) if (isicom_paranoia_check(port, tty->name, "isicom_close"))
return; return;
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: Close start!!!.\n"); printk(KERN_DEBUG "ISICOM: Close start!!!.\n");
#endif #endif
spin_lock_irqsave(&card->card_lock, flags); spin_lock_irqsave(&card->card_lock, flags);
if (tty_hung_up_p(filp)) { if (tty_hung_up_p(filp)) {
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
return; return;
} }
if (tty->count == 1 && port->count != 1) { if (tty->count == 1 && port->count != 1) {
printk(KERN_WARNING "ISICOM:(0x%x) isicom_close: bad port count" printk(KERN_WARNING "ISICOM:(0x%x) isicom_close: bad port count"
"tty->count = 1 port count = %d.\n", "tty->count = 1 port count = %d.\n",
...@@ -1324,31 +1321,31 @@ static void isicom_close(struct tty_struct * tty, struct file * filp) ...@@ -1324,31 +1321,31 @@ static void isicom_close(struct tty_struct * tty, struct file * filp)
} }
if (--port->count < 0) { if (--port->count < 0) {
printk(KERN_WARNING "ISICOM:(0x%x) isicom_close: bad port count for" printk(KERN_WARNING "ISICOM:(0x%x) isicom_close: bad port count for"
"channel%d = %d", card->base, port->channel, "channel%d = %d", card->base, port->channel,
port->count); port->count);
port->count = 0; port->count = 0;
} }
if (port->count) { if (port->count) {
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
return; return;
} }
port->flags |= ASYNC_CLOSING; port->flags |= ASYNC_CLOSING;
tty->closing = 1; tty->closing = 1;
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
tty_wait_until_sent(tty, port->closing_wait); tty_wait_until_sent(tty, port->closing_wait);
/* indicate to the card that no more data can be received /* indicate to the card that no more data can be received
on this port */ on this port */
spin_lock_irqsave(&card->card_lock, flags); spin_lock_irqsave(&card->card_lock, flags);
if (port->flags & ASYNC_INITIALIZED) { if (port->flags & ASYNC_INITIALIZED) {
card->port_status &= ~(1 << port->channel); card->port_status &= ~(1 << port->channel);
outw(card->port_status, card->base + 0x02); outw(card->port_status, card->base + 0x02);
} }
isicom_shutdown_port(port); isicom_shutdown_port(port);
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
if (tty->driver->flush_buffer) if (tty->driver->flush_buffer)
tty->driver->flush_buffer(tty); tty->driver->flush_buffer(tty);
tty_ldisc_flush(tty); tty_ldisc_flush(tty);
...@@ -1359,65 +1356,65 @@ static void isicom_close(struct tty_struct * tty, struct file * filp) ...@@ -1359,65 +1356,65 @@ static void isicom_close(struct tty_struct * tty, struct file * filp)
if (port->blocked_open) { if (port->blocked_open) {
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
if (port->close_delay) { if (port->close_delay) {
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: scheduling until time out.\n"); printk(KERN_DEBUG "ISICOM: scheduling until time out.\n");
#endif #endif
msleep_interruptible(jiffies_to_msecs(port->close_delay)); msleep_interruptible(jiffies_to_msecs(port->close_delay));
} }
spin_lock_irqsave(&card->card_lock, flags); spin_lock_irqsave(&card->card_lock, flags);
wake_up_interruptible(&port->open_wait); wake_up_interruptible(&port->open_wait);
} }
port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING); port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
wake_up_interruptible(&port->close_wait); wake_up_interruptible(&port->close_wait);
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
} }
/* write et all */ /* write et all */
static int isicom_write(struct tty_struct * tty, static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
const unsigned char * buf, int count) int count)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned long flags; unsigned long flags;
int cnt, total = 0; int cnt, total = 0;
if (isicom_paranoia_check(port, tty->name, "isicom_write")) if (isicom_paranoia_check(port, tty->name, "isicom_write"))
return 0; return 0;
if (!tty || !port->xmit_buf || !tmp_buf) if (!tty || !port->xmit_buf || !tmp_buf)
return 0; return 0;
spin_lock_irqsave(&card->card_lock, flags); spin_lock_irqsave(&card->card_lock, flags);
while(1) { while(1) {
cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1, cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
SERIAL_XMIT_SIZE - port->xmit_head)); SERIAL_XMIT_SIZE - port->xmit_head));
if (cnt <= 0) if (cnt <= 0)
break; break;
memcpy(port->xmit_buf + port->xmit_head, buf, cnt); memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE - 1); port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE - 1);
port->xmit_cnt += cnt; port->xmit_cnt += cnt;
buf += cnt; buf += cnt;
count -= cnt; count -= cnt;
total += cnt; total += cnt;
} }
if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped) if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
port->status |= ISI_TXOK; port->status |= ISI_TXOK;
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
return total; return total;
} }
/* put_char et all */ /* put_char et all */
static void isicom_put_char(struct tty_struct * tty, unsigned char ch) static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned long flags; unsigned long flags;
if (isicom_paranoia_check(port, tty->name, "isicom_put_char")) if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
return; return;
if (!tty || !port->xmit_buf) if (!tty || !port->xmit_buf)
return; return;
...@@ -1426,7 +1423,7 @@ static void isicom_put_char(struct tty_struct * tty, unsigned char ch) ...@@ -1426,7 +1423,7 @@ static void isicom_put_char(struct tty_struct * tty, unsigned char ch)
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
return; return;
} }
port->xmit_buf[port->xmit_head++] = ch; port->xmit_buf[port->xmit_head++] = ch;
port->xmit_head &= (SERIAL_XMIT_SIZE - 1); port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
port->xmit_cnt++; port->xmit_cnt++;
...@@ -1434,30 +1431,30 @@ static void isicom_put_char(struct tty_struct * tty, unsigned char ch) ...@@ -1434,30 +1431,30 @@ static void isicom_put_char(struct tty_struct * tty, unsigned char ch)
} }
/* flush_chars et all */ /* flush_chars et all */
static void isicom_flush_chars(struct tty_struct * tty) static void isicom_flush_chars(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars")) if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
return; return;
if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped || !port->xmit_buf) if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped || !port->xmit_buf)
return; return;
/* this tells the transmitter to consider this port for /* this tells the transmitter to consider this port for
data output to the card ... that's the best we can do. */ data output to the card ... that's the best we can do. */
port->status |= ISI_TXOK; port->status |= ISI_TXOK;
} }
/* write_room et all */ /* write_room et all */
static int isicom_write_room(struct tty_struct * tty) static int isicom_write_room(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
int free; int free;
if (isicom_paranoia_check(port, tty->name, "isicom_write_room")) if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
return 0; return 0;
free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1; free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
if (free < 0) if (free < 0)
free = 0; free = 0;
...@@ -1465,23 +1462,23 @@ static int isicom_write_room(struct tty_struct * tty) ...@@ -1465,23 +1462,23 @@ static int isicom_write_room(struct tty_struct * tty)
} }
/* chars_in_buffer et all */ /* chars_in_buffer et all */
static int isicom_chars_in_buffer(struct tty_struct * tty) static int isicom_chars_in_buffer(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer")) if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
return 0; return 0;
return port->xmit_cnt; return port->xmit_cnt;
} }
/* ioctl et all */ /* ioctl et all */
static inline void isicom_send_break(struct isi_port * port, unsigned long length) static inline void isicom_send_break(struct isi_port *port, unsigned long length)
{ {
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned short base = card->base; unsigned short base = card->base;
if(!lock_card(card)) if (!lock_card(card))
return; return;
outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base); outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
outw((length & 0xff) << 8 | 0x00, base); outw((length & 0xff) << 8 | 0x00, base);
outw((length & 0xff00), base); outw((length & 0xff00), base);
...@@ -1492,13 +1489,13 @@ static inline void isicom_send_break(struct isi_port * port, unsigned long lengt ...@@ -1492,13 +1489,13 @@ static inline void isicom_send_break(struct isi_port * port, unsigned long lengt
static int isicom_tiocmget(struct tty_struct *tty, struct file *file) static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
/* just send the port status */ /* just send the port status */
unsigned short status = port->status; unsigned short status = port->status;
if (isicom_paranoia_check(port, tty->name, "isicom_ioctl")) if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
return -ENODEV; return -ENODEV;
return ((status & ISI_RTS) ? TIOCM_RTS : 0) | return ((status & ISI_RTS) ? TIOCM_RTS : 0) |
((status & ISI_DTR) ? TIOCM_DTR : 0) | ((status & ISI_DTR) ? TIOCM_DTR : 0) |
((status & ISI_DCD) ? TIOCM_CAR : 0) | ((status & ISI_DCD) ? TIOCM_CAR : 0) |
...@@ -1508,13 +1505,13 @@ static int isicom_tiocmget(struct tty_struct *tty, struct file *file) ...@@ -1508,13 +1505,13 @@ static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
} }
static int isicom_tiocmset(struct tty_struct *tty, struct file *file, static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear) unsigned int set, unsigned int clear)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
if (isicom_paranoia_check(port, tty->name, "isicom_ioctl")) if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
return -ENODEV; return -ENODEV;
if (set & TIOCM_RTS) if (set & TIOCM_RTS)
raise_rts(port); raise_rts(port);
if (set & TIOCM_DTR) if (set & TIOCM_DTR)
...@@ -1526,46 +1523,46 @@ static int isicom_tiocmset(struct tty_struct *tty, struct file *file, ...@@ -1526,46 +1523,46 @@ static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
drop_dtr(port); drop_dtr(port);
return 0; return 0;
} }
static int isicom_set_serial_info(struct isi_port * port, static int isicom_set_serial_info(struct isi_port *port,
struct serial_struct __user *info) struct serial_struct __user *info)
{ {
struct serial_struct newinfo; struct serial_struct newinfo;
int reconfig_port; int reconfig_port;
if(copy_from_user(&newinfo, info, sizeof(newinfo))) if (copy_from_user(&newinfo, info, sizeof(newinfo)))
return -EFAULT; return -EFAULT;
reconfig_port = ((port->flags & ASYNC_SPD_MASK) != reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
(newinfo.flags & ASYNC_SPD_MASK)); (newinfo.flags & ASYNC_SPD_MASK));
if (!capable(CAP_SYS_ADMIN)) { if (!capable(CAP_SYS_ADMIN)) {
if ((newinfo.close_delay != port->close_delay) || if ((newinfo.close_delay != port->close_delay) ||
(newinfo.closing_wait != port->closing_wait) || (newinfo.closing_wait != port->closing_wait) ||
((newinfo.flags & ~ASYNC_USR_MASK) != ((newinfo.flags & ~ASYNC_USR_MASK) !=
(port->flags & ~ASYNC_USR_MASK))) (port->flags & ~ASYNC_USR_MASK)))
return -EPERM; return -EPERM;
port->flags = ((port->flags & ~ ASYNC_USR_MASK) | port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
(newinfo.flags & ASYNC_USR_MASK)); (newinfo.flags & ASYNC_USR_MASK));
} }
else { else {
port->close_delay = newinfo.close_delay; port->close_delay = newinfo.close_delay;
port->closing_wait = newinfo.closing_wait; port->closing_wait = newinfo.closing_wait;
port->flags = ((port->flags & ~ASYNC_FLAGS) | port->flags = ((port->flags & ~ASYNC_FLAGS) |
(newinfo.flags & ASYNC_FLAGS)); (newinfo.flags & ASYNC_FLAGS));
} }
if (reconfig_port) { if (reconfig_port) {
isicom_config_port(port); isicom_config_port(port);
} }
return 0; return 0;
} }
static int isicom_get_serial_info(struct isi_port * port, static int isicom_get_serial_info(struct isi_port *port,
struct serial_struct __user *info) struct serial_struct __user *info)
{ {
struct serial_struct out_info; struct serial_struct out_info;
memset(&out_info, 0, sizeof(out_info)); memset(&out_info, 0, sizeof(out_info));
/* out_info.type = ? */ /* out_info.type = ? */
out_info.line = port - isi_ports; out_info.line = port - isi_ports;
...@@ -1575,15 +1572,15 @@ static int isicom_get_serial_info(struct isi_port * port, ...@@ -1575,15 +1572,15 @@ static int isicom_get_serial_info(struct isi_port * port,
/* out_info.baud_base = ? */ /* out_info.baud_base = ? */
out_info.close_delay = port->close_delay; out_info.close_delay = port->close_delay;
out_info.closing_wait = port->closing_wait; out_info.closing_wait = port->closing_wait;
if(copy_to_user(info, &out_info, sizeof(out_info))) if (copy_to_user(info, &out_info, sizeof(out_info)))
return -EFAULT; return -EFAULT;
return 0; return 0;
} }
static int isicom_ioctl(struct tty_struct * tty, struct file * filp, static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
int retval; int retval;
...@@ -1591,139 +1588,140 @@ static int isicom_ioctl(struct tty_struct * tty, struct file * filp, ...@@ -1591,139 +1588,140 @@ static int isicom_ioctl(struct tty_struct * tty, struct file * filp,
return -ENODEV; return -ENODEV;
switch(cmd) { switch(cmd) {
case TCSBRK: case TCSBRK:
retval = tty_check_change(tty); retval = tty_check_change(tty);
if (retval) if (retval)
return retval; return retval;
tty_wait_until_sent(tty, 0); tty_wait_until_sent(tty, 0);
if (!arg) if (!arg)
isicom_send_break(port, HZ/4); isicom_send_break(port, HZ/4);
return 0; return 0;
case TCSBRKP: case TCSBRKP:
retval = tty_check_change(tty); retval = tty_check_change(tty);
if (retval) if (retval)
return retval; return retval;
tty_wait_until_sent(tty, 0); tty_wait_until_sent(tty, 0);
isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4); isicom_send_break(port, arg ? arg * (HZ/10) : HZ/4);
return 0; return 0;
case TIOCGSOFTCAR: case TIOCGSOFTCAR:
return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp); return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
case TIOCSSOFTCAR: case TIOCSSOFTCAR:
if(get_user(arg, (unsigned long __user *) argp)) if (get_user(arg, (unsigned long __user *) argp))
return -EFAULT; return -EFAULT;
tty->termios->c_cflag = tty->termios->c_cflag =
((tty->termios->c_cflag & ~CLOCAL) | ((tty->termios->c_cflag & ~CLOCAL) |
(arg ? CLOCAL : 0)); (arg ? CLOCAL : 0));
return 0; return 0;
case TIOCGSERIAL: case TIOCGSERIAL:
return isicom_get_serial_info(port, argp); return isicom_get_serial_info(port, argp);
case TIOCSSERIAL: case TIOCSSERIAL:
return isicom_set_serial_info(port, argp); return isicom_set_serial_info(port, argp);
default: default:
return -ENOIOCTLCMD; return -ENOIOCTLCMD;
} }
return 0; return 0;
} }
/* set_termios et all */ /* set_termios et all */
static void isicom_set_termios(struct tty_struct * tty, struct termios * old_termios) static void isicom_set_termios(struct tty_struct *tty,
struct termios *old_termios)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
if (isicom_paranoia_check(port, tty->name, "isicom_set_termios")) if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
return; return;
if (tty->termios->c_cflag == old_termios->c_cflag && if (tty->termios->c_cflag == old_termios->c_cflag &&
tty->termios->c_iflag == old_termios->c_iflag) tty->termios->c_iflag == old_termios->c_iflag)
return; return;
isicom_config_port(port); isicom_config_port(port);
if ((old_termios->c_cflag & CRTSCTS) && if ((old_termios->c_cflag & CRTSCTS) &&
!(tty->termios->c_cflag & CRTSCTS)) { !(tty->termios->c_cflag & CRTSCTS)) {
tty->hw_stopped = 0; tty->hw_stopped = 0;
isicom_start(tty); isicom_start(tty);
} }
} }
/* throttle et all */ /* throttle et all */
static void isicom_throttle(struct tty_struct * tty) static void isicom_throttle(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
struct isi_board * card = port->card; struct isi_board *card = port->card;
if (isicom_paranoia_check(port, tty->name, "isicom_throttle")) if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
return; return;
/* tell the card that this port cannot handle any more data for now */ /* tell the card that this port cannot handle any more data for now */
card->port_status &= ~(1 << port->channel); card->port_status &= ~(1 << port->channel);
outw(card->port_status, card->base + 0x02); outw(card->port_status, card->base + 0x02);
} }
/* unthrottle et all */ /* unthrottle et all */
static void isicom_unthrottle(struct tty_struct * tty) static void isicom_unthrottle(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
struct isi_board * card = port->card; struct isi_board *card = port->card;
if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle")) if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
return; return;
/* tell the card that this port is ready to accept more data */ /* tell the card that this port is ready to accept more data */
card->port_status |= (1 << port->channel); card->port_status |= (1 << port->channel);
outw(card->port_status, card->base + 0x02); outw(card->port_status, card->base + 0x02);
} }
/* stop et all */ /* stop et all */
static void isicom_stop(struct tty_struct * tty) static void isicom_stop(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
if (isicom_paranoia_check(port, tty->name, "isicom_stop")) if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
return; return;
/* this tells the transmitter not to consider this port for /* this tells the transmitter not to consider this port for
data output to the card. */ data output to the card. */
port->status &= ~ISI_TXOK; port->status &= ~ISI_TXOK;
} }
/* start et all */ /* start et all */
static void isicom_start(struct tty_struct * tty) static void isicom_start(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
if (isicom_paranoia_check(port, tty->name, "isicom_start")) if (isicom_paranoia_check(port, tty->name, "isicom_start"))
return; return;
/* this tells the transmitter to consider this port for /* this tells the transmitter to consider this port for
data output to the card. */ data output to the card. */
port->status |= ISI_TXOK; port->status |= ISI_TXOK;
} }
/* hangup et all */ /* hangup et all */
static void do_isicom_hangup(void * data) static void do_isicom_hangup(void *data)
{ {
struct isi_port * port = (struct isi_port *) data; struct isi_port *port = (struct isi_port *) data;
struct tty_struct * tty; struct tty_struct *tty;
tty = port->tty; tty = port->tty;
if (tty) if (tty)
tty_hangup(tty); tty_hangup(tty);
} }
static void isicom_hangup(struct tty_struct * tty) static void isicom_hangup(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
if (isicom_paranoia_check(port, tty->name, "isicom_hangup")) if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
return; return;
isicom_shutdown_port(port); isicom_shutdown_port(port);
port->count = 0; port->count = 0;
port->flags &= ~ASYNC_NORMAL_ACTIVE; port->flags &= ~ASYNC_NORMAL_ACTIVE;
...@@ -1732,19 +1730,19 @@ static void isicom_hangup(struct tty_struct * tty) ...@@ -1732,19 +1730,19 @@ static void isicom_hangup(struct tty_struct * tty)
} }
/* flush_buffer et all */ /* flush_buffer et all */
static void isicom_flush_buffer(struct tty_struct * tty) static void isicom_flush_buffer(struct tty_struct *tty)
{ {
struct isi_port * port = (struct isi_port *) tty->driver_data; struct isi_port *port = (struct isi_port *) tty->driver_data;
struct isi_board * card = port->card; struct isi_board *card = port->card;
unsigned long flags; unsigned long flags;
if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer")) if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
return; return;
spin_lock_irqsave(&card->card_lock, flags); spin_lock_irqsave(&card->card_lock, flags);
port->xmit_cnt = port->xmit_head = port->xmit_tail = 0; port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
spin_unlock_irqrestore(&card->card_lock, flags); spin_unlock_irqrestore(&card->card_lock, flags);
wake_up_interruptible(&tty->write_wait); wake_up_interruptible(&tty->write_wait);
tty_wakeup(tty); tty_wakeup(tty);
} }
...@@ -1768,33 +1766,33 @@ static int __devinit register_ioregion(void) ...@@ -1768,33 +1766,33 @@ static int __devinit register_ioregion(void)
static void unregister_ioregion(void) static void unregister_ioregion(void)
{ {
int count; int count;
for (count=0; count < BOARD_COUNT; count++ ) for (count=0; count < BOARD_COUNT; count++ )
if (isi_card[count].base) { if (isi_card[count].base) {
release_region(isi_card[count].base,16); release_region(isi_card[count].base,16);
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: I/O Region 0x%x-0x%x released for Card%d.\n",isi_card[count].base,isi_card[count].base+15,count+1); printk(KERN_DEBUG "ISICOM: I/O Region 0x%x-0x%x released for Card%d.\n",isi_card[count].base,isi_card[count].base+15,count+1);
#endif #endif
} }
} }
static struct tty_operations isicom_ops = { static struct tty_operations isicom_ops = {
.open = isicom_open, .open = isicom_open,
.close = isicom_close, .close = isicom_close,
.write = isicom_write, .write = isicom_write,
.put_char = isicom_put_char, .put_char = isicom_put_char,
.flush_chars = isicom_flush_chars, .flush_chars = isicom_flush_chars,
.write_room = isicom_write_room, .write_room = isicom_write_room,
.chars_in_buffer = isicom_chars_in_buffer, .chars_in_buffer = isicom_chars_in_buffer,
.ioctl = isicom_ioctl, .ioctl = isicom_ioctl,
.set_termios = isicom_set_termios, .set_termios = isicom_set_termios,
.throttle = isicom_throttle, .throttle = isicom_throttle,
.unthrottle = isicom_unthrottle, .unthrottle = isicom_unthrottle,
.stop = isicom_stop, .stop = isicom_stop,
.start = isicom_start, .start = isicom_start,
.hangup = isicom_hangup, .hangup = isicom_hangup,
.flush_buffer = isicom_flush_buffer, .flush_buffer = isicom_flush_buffer,
.tiocmget = isicom_tiocmget, .tiocmget = isicom_tiocmget,
.tiocmset = isicom_tiocmset, .tiocmset = isicom_tiocmset,
}; };
static int __devinit register_drivers(void) static int __devinit register_drivers(void)
...@@ -1814,11 +1812,11 @@ static int __devinit register_drivers(void) ...@@ -1814,11 +1812,11 @@ static int __devinit register_drivers(void)
isicom_normal->type = TTY_DRIVER_TYPE_SERIAL; isicom_normal->type = TTY_DRIVER_TYPE_SERIAL;
isicom_normal->subtype = SERIAL_TYPE_NORMAL; isicom_normal->subtype = SERIAL_TYPE_NORMAL;
isicom_normal->init_termios = tty_std_termios; isicom_normal->init_termios = tty_std_termios;
isicom_normal->init_termios.c_cflag = isicom_normal->init_termios.c_cflag =
B9600 | CS8 | CREAD | HUPCL |CLOCAL; B9600 | CS8 | CREAD | HUPCL |CLOCAL;
isicom_normal->flags = TTY_DRIVER_REAL_RAW; isicom_normal->flags = TTY_DRIVER_REAL_RAW;
tty_set_operations(isicom_normal, &isicom_ops); tty_set_operations(isicom_normal, &isicom_ops);
if ((error=tty_register_driver(isicom_normal))!=0) { if ((error=tty_register_driver(isicom_normal))!=0) {
printk(KERN_DEBUG "ISICOM: Couldn't register the dialin driver, error=%d\n", printk(KERN_DEBUG "ISICOM: Couldn't register the dialin driver, error=%d\n",
error); error);
...@@ -1843,13 +1841,13 @@ static int __devinit register_isr(void) ...@@ -1843,13 +1841,13 @@ static int __devinit register_isr(void)
for (count=0; count < BOARD_COUNT; count++ ) { for (count=0; count < BOARD_COUNT; count++ ) {
if (isi_card[count].base) { if (isi_card[count].base) {
irqflags = (isi_card[count].isa == YES) ? irqflags = (isi_card[count].isa == YES) ?
SA_INTERRUPT : SA_INTERRUPT :
(SA_INTERRUPT | SA_SHIRQ); (SA_INTERRUPT | SA_SHIRQ);
if (request_irq(isi_card[count].irq, if (request_irq(isi_card[count].irq,
isicom_interrupt, isicom_interrupt,
irqflags, irqflags,
ISICOM_NAME, &isi_card[count])) { ISICOM_NAME, &isi_card[count])) {
printk(KERN_WARNING "ISICOM: Could not" printk(KERN_WARNING "ISICOM: Could not"
...@@ -1862,7 +1860,7 @@ static int __devinit register_isr(void) ...@@ -1862,7 +1860,7 @@ static int __devinit register_isr(void)
} }
else else
done++; done++;
} }
} }
return done; return done;
} }
...@@ -1880,42 +1878,42 @@ static void __exit unregister_isr(void) ...@@ -1880,42 +1878,42 @@ static void __exit unregister_isr(void)
static int __devinit isicom_init(void) static int __devinit isicom_init(void)
{ {
int card, channel, base; int card, channel, base;
struct isi_port * port; struct isi_port *port;
unsigned long page; unsigned long page;
if (!tmp_buf) { if (!tmp_buf) {
page = get_zeroed_page(GFP_KERNEL); page = get_zeroed_page(GFP_KERNEL);
if (!page) { if (!page) {
#ifdef ISICOM_DEBUG #ifdef ISICOM_DEBUG
printk(KERN_DEBUG "ISICOM: Couldn't allocate page for tmp_buf.\n"); printk(KERN_DEBUG "ISICOM: Couldn't allocate page for tmp_buf.\n");
#else #else
printk(KERN_ERR "ISICOM: Not enough memory...\n"); printk(KERN_ERR "ISICOM: Not enough memory...\n");
#endif #endif
return 0; return 0;
} }
tmp_buf = (unsigned char *) page; tmp_buf = (unsigned char *) page;
} }
if (!register_ioregion()) if (!register_ioregion())
{ {
printk(KERN_ERR "ISICOM: All required I/O space found busy.\n"); printk(KERN_ERR "ISICOM: All required I/O space found busy.\n");
free_page((unsigned long)tmp_buf); free_page((unsigned long)tmp_buf);
return 0; return 0;
} }
if (register_drivers()) if (register_drivers())
{ {
unregister_ioregion(); unregister_ioregion();
free_page((unsigned long)tmp_buf); free_page((unsigned long)tmp_buf);
return 0; return 0;
} }
if (!register_isr()) if (!register_isr())
{ {
unregister_drivers(); unregister_drivers();
/* ioports already uregistered in register_isr */ /* ioports already uregistered in register_isr */
free_page((unsigned long)tmp_buf); free_page((unsigned long)tmp_buf);
return 0; return 0;
} }
memset(isi_ports, 0, sizeof(isi_ports)); memset(isi_ports, 0, sizeof(isi_ports));
for (card = 0; card < BOARD_COUNT; card++) { for (card = 0; card < BOARD_COUNT; card++) {
port = &isi_ports[card * 16]; port = &isi_ports[card * 16];
...@@ -1926,24 +1924,24 @@ static int __devinit isicom_init(void) ...@@ -1926,24 +1924,24 @@ static int __devinit isicom_init(void)
port->magic = ISICOM_MAGIC; port->magic = ISICOM_MAGIC;
port->card = &isi_card[card]; port->card = &isi_card[card];
port->channel = channel; port->channel = channel;
port->close_delay = 50 * HZ/100; port->close_delay = 50 * HZ/100;
port->closing_wait = 3000 * HZ/100; port->closing_wait = 3000 * HZ/100;
INIT_WORK(&port->hangup_tq, do_isicom_hangup, port); INIT_WORK(&port->hangup_tq, do_isicom_hangup, port);
INIT_WORK(&port->bh_tqueue, isicom_bottomhalf, port); INIT_WORK(&port->bh_tqueue, isicom_bottomhalf, port);
port->status = 0; port->status = 0;
init_waitqueue_head(&port->open_wait); init_waitqueue_head(&port->open_wait);
init_waitqueue_head(&port->close_wait); init_waitqueue_head(&port->close_wait);
/* . . . */ /* . . . */
} }
} }
return 1; return 1;
} }
/* /*
* Insmod can set static symbols so keep these static * Insmod can set static symbols so keep these static
*/ */
static int io[4]; static int io[4];
static int irq[4]; static int irq[4];
...@@ -1961,9 +1959,9 @@ static int __devinit isicom_setup(void) ...@@ -1961,9 +1959,9 @@ static int __devinit isicom_setup(void)
int retval, card, idx, count; int retval, card, idx, count;
unsigned char pciirq; unsigned char pciirq;
unsigned int ioaddr; unsigned int ioaddr;
card = 0; card = 0;
for(idx=0; idx < BOARD_COUNT; idx++) { for (idx=0; idx < BOARD_COUNT; idx++) {
if (io[idx]) { if (io[idx]) {
isi_card[idx].base=io[idx]; isi_card[idx].base=io[idx];
isi_card[idx].irq=irq[idx]; isi_card[idx].irq=irq[idx];
...@@ -1975,23 +1973,23 @@ static int __devinit isicom_setup(void) ...@@ -1975,23 +1973,23 @@ static int __devinit isicom_setup(void)
isi_card[idx].irq = 0; isi_card[idx].irq = 0;
} }
} }
for (idx=0 ;idx < card; idx++) { for (idx=0 ;idx < card; idx++) {
if (!((isi_card[idx].irq==2)||(isi_card[idx].irq==3)|| if (!((isi_card[idx].irq==2)||(isi_card[idx].irq==3)||
(isi_card[idx].irq==4)||(isi_card[idx].irq==5)|| (isi_card[idx].irq==4)||(isi_card[idx].irq==5)||
(isi_card[idx].irq==7)||(isi_card[idx].irq==10)|| (isi_card[idx].irq==7)||(isi_card[idx].irq==10)||
(isi_card[idx].irq==11)||(isi_card[idx].irq==12)|| (isi_card[idx].irq==11)||(isi_card[idx].irq==12)||
(isi_card[idx].irq==15))) { (isi_card[idx].irq==15))) {
if (isi_card[idx].base) { if (isi_card[idx].base) {
printk(KERN_ERR "ISICOM: Irq %d unsupported. Disabling Card%d...\n", printk(KERN_ERR "ISICOM: Irq %d unsupported. Disabling Card%d...\n",
isi_card[idx].irq, idx+1); isi_card[idx].irq, idx+1);
isi_card[idx].base=0; isi_card[idx].base=0;
card--; card--;
} }
} }
} }
if (card < BOARD_COUNT) { if (card < BOARD_COUNT) {
for (idx=0; idx < DEVID_COUNT; idx++) { for (idx=0; idx < DEVID_COUNT; idx++) {
dev = NULL; dev = NULL;
...@@ -2000,21 +1998,22 @@ static int __devinit isicom_setup(void) ...@@ -2000,21 +1998,22 @@ static int __devinit isicom_setup(void)
break; break;
if (card >= BOARD_COUNT) if (card >= BOARD_COUNT)
break; break;
if (pci_enable_device(dev)) if (pci_enable_device(dev))
break; break;
/* found a PCI ISI card! */ /* found a PCI ISI card! */
ioaddr = pci_resource_start (dev, 3); /* i.e at offset 0x1c in the ioaddr = pci_resource_start (dev, 3);
* PCI configuration register /* i.e at offset 0x1c in the
* space. * PCI configuration register
*/ * space.
*/
pciirq = dev->irq; pciirq = dev->irq;
printk(KERN_INFO "ISI PCI Card(Device ID 0x%x)\n", isicom_pci_tbl[idx].device); printk(KERN_INFO "ISI PCI Card(Device ID 0x%x)\n", isicom_pci_tbl[idx].device);
/* /*
* allot the first empty slot in the array * allot the first empty slot in the array
*/ */
for (count=0; count < BOARD_COUNT; count++) { for (count=0; count < BOARD_COUNT; count++) {
if (isi_card[count].base == 0) { if (isi_card[count].base == 0) {
isi_card[count].base = ioaddr; isi_card[count].base = ioaddr;
isi_card[count].irq = pciirq; isi_card[count].irq = pciirq;
...@@ -2023,35 +2022,35 @@ static int __devinit isicom_setup(void) ...@@ -2023,35 +2022,35 @@ static int __devinit isicom_setup(void)
break; break;
} }
} }
} }
if (card >= BOARD_COUNT) break; if (card >= BOARD_COUNT) break;
} }
} }
if (!(isi_card[0].base || isi_card[1].base || isi_card[2].base || isi_card[3].base)) { if (!(isi_card[0].base || isi_card[1].base || isi_card[2].base || isi_card[3].base)) {
printk(KERN_ERR "ISICOM: No valid card configuration. Driver cannot be initialized...\n"); printk(KERN_ERR "ISICOM: No valid card configuration. Driver cannot be initialized...\n");
return -EIO; return -EIO;
} }
retval = misc_register(&isiloader_device); retval = misc_register(&isiloader_device);
if (retval < 0) { if (retval < 0) {
printk(KERN_ERR "ISICOM: Unable to register firmware loader driver.\n"); printk(KERN_ERR "ISICOM: Unable to register firmware loader driver.\n");
return retval; return retval;
} }
if (!isicom_init()) { if (!isicom_init()) {
if (misc_deregister(&isiloader_device)) if (misc_deregister(&isiloader_device))
printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n"); printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n");
return -EIO; return -EIO;
} }
init_timer(&tx); init_timer(&tx);
tx.expires = jiffies + 1; tx.expires = jiffies + 1;
tx.data = 0; tx.data = 0;
tx.function = isicom_tx; tx.function = isicom_tx;
re_schedule = 1; re_schedule = 1;
add_timer(&tx); add_timer(&tx);
return 0; return 0;
} }
...@@ -2062,8 +2061,8 @@ static void __exit isicom_exit(void) ...@@ -2062,8 +2061,8 @@ static void __exit isicom_exit(void)
msleep(1000); msleep(1000);
unregister_isr(); unregister_isr();
unregister_drivers(); unregister_drivers();
unregister_ioregion(); unregister_ioregion();
if(tmp_buf) if (tmp_buf)
free_page((unsigned long)tmp_buf); free_page((unsigned long)tmp_buf);
if (misc_deregister(&isiloader_device)) if (misc_deregister(&isiloader_device))
printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n"); printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n");
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment