Commit 02f1175c authored by Jiri Slaby's avatar Jiri Slaby Committed by Linus Torvalds

[PATCH] Char: cyclades, Lindent the code

make the code indented by tabs.
Signed-off-by: default avatarJiri Slaby <jirislaby@gmail.com>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent e941027f
#undef BLOCKMOVE
#define Z_WAKE
#undef Z_EXT_CHARS_IN_BUFFER
static char rcsid[] =
"$Revision: 2.3.2.20 $$Date: 2004/02/25 18:14:16 $";
static char rcsid[] = "$Revision: 2.3.2.20 $$Date: 2004/02/25 18:14:16 $";
/*
* linux/drivers/char/cyclades.c
......@@ -676,8 +675,8 @@ static char rcsid[] =
#include <linux/stat.h>
#include <linux/proc_fs.h>
static void cy_throttle (struct tty_struct *tty);
static void cy_send_xchar (struct tty_struct *tty, char ch);
static void cy_throttle(struct tty_struct *tty);
static void cy_send_xchar(struct tty_struct *tty, char ch);
#define IS_CYC_Z(card) ((card).num_chips == -1)
......@@ -721,8 +720,9 @@ static unsigned int cy_isa_addresses[] = {
0xDA000,
0xDC000,
0xDE000,
0,0,0,0,0,0,0,0
0, 0, 0, 0, 0, 0, 0, 0
};
#define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
#ifdef MODULE
......@@ -758,35 +758,41 @@ static int cy_next_channel; /* next minor available */
*/
static int baud_table[] = {
0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800,115200,150000,
230400, 0};
1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
230400, 0
};
static char baud_co_25[] = { /* 25 MHz clock option table */
/* value => 00 01 02 03 04 */
/* divide by 8 32 128 512 2048 */
0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static char baud_bpr_25[] = { /* 25 MHz baud rate period table */
0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15};
0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
};
static char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
/* value => 00 01 02 03 04 */
/* divide by 8 32 128 512 2048 */
0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00};
0x00
};
static char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */
0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
0x21};
0x21
};
static char baud_cor3[] = { /* receive threshold */
0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
0x07};
0x07
};
/*
* The Cyclades driver implements HW flow control as any serial driver.
......@@ -802,13 +808,13 @@ static char baud_cor3[] = { /* receive threshold */
static char rflow_thr[] = { /* rflow threshold */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
0x0a};
0x0a
};
/* The Cyclom-Ye has placed the sequential chips in non-sequential
* address order. This look-up table overcomes that problem.
*/
static int cy_chip_offset [] =
{ 0x0000,
static int cy_chip_offset[] = { 0x0000,
0x0400,
0x0800,
0x0C00,
......@@ -816,7 +822,7 @@ static int cy_chip_offset [] =
0x0600,
0x0A00,
0x0E00
};
};
/* PCI related definitions */
......@@ -834,7 +840,7 @@ static unsigned short cy_pci_dev_id[] = {
PCI_DEVICE_ID_CYCLOM_Z_Lo, /* Z PCI < 1Mb */
PCI_DEVICE_ID_CYCLOM_Z_Hi, /* Z PCI > 1Mb */
0 /* end of table */
};
};
#endif
static void cy_start(struct tty_struct *);
......@@ -844,7 +850,7 @@ static int cyz_issue_cmd(struct cyclades_card *, uclong, ucchar, uclong);
static unsigned detect_isa_irq(void __iomem *);
#endif /* CONFIG_ISA */
static int cyclades_get_proc_info(char *, char **, off_t , int , int *, void *);
static int cyclades_get_proc_info(char *, char **, off_t, int, int *, void *);
#ifndef CONFIG_CYZ_INTR
static void cyz_poll(unsigned long);
......@@ -860,8 +866,7 @@ static void cyz_rx_restart(unsigned long);
static struct timer_list cyz_rx_full_timer[NR_PORTS];
#endif /* CONFIG_CYZ_INTR */
static inline int
serial_paranoia_check(struct cyclades_port *info,
static inline int serial_paranoia_check(struct cyclades_port *info,
char *name, const char *routine)
{
#ifdef SERIAL_PARANOIA_CHECK
......@@ -877,8 +882,8 @@ serial_paranoia_check(struct cyclades_port *info,
return 1;
}
if( (long)info < (long)(&cy_port[0])
|| (long)(&cy_port[NR_PORTS]) < (long)info ){
if ((long)info < (long)(&cy_port[0]) ||
(long)(&cy_port[NR_PORTS]) < (long)info) {
printk(badrange, name, routine);
return 1;
}
......@@ -897,14 +902,12 @@ serial_paranoia_check(struct cyclades_port *info,
* (also known as the "bottom half"). This can be called any
* number of times for any channel without harm.
*/
static inline void
cy_sched_event(struct cyclades_port *info, int event)
static inline void cy_sched_event(struct cyclades_port *info, int event)
{
info->event |= 1 << event; /* remember what kind of event and who */
schedule_work(&info->tqueue);
} /* cy_sched_event */
/*
* This routine is used to handle the "bottom half" processing for the
* serial driver, known also the "software interrupt" processing.
......@@ -941,30 +944,25 @@ do_softint(struct work_struct *work)
wake_up_interruptible(&info->open_wait);
info->flags &= ~ASYNC_NORMAL_ACTIVE;
}
if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event)) {
if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event))
wake_up_interruptible(&info->open_wait);
}
#ifdef CONFIG_CYZ_INTR
if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
if (cyz_rx_full_timer[info->line].function == NULL) {
cyz_rx_full_timer[info->line].expires = jiffies + 1;
cyz_rx_full_timer[info->line].function = cyz_rx_restart;
cyz_rx_full_timer[info->line].data = (unsigned long)info;
cyz_rx_full_timer[info->line].data =
(unsigned long)info;
add_timer(&cyz_rx_full_timer[info->line]);
}
}
#endif
if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event)) {
if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event))
wake_up_interruptible(&info->delta_msr_wait);
}
if (test_and_clear_bit(Cy_EVENT_WRITE_WAKEUP, &info->event)) {
tty_wakeup(tty);
wake_up_interruptible(&tty->write_wait);
}
#ifdef Z_WAKE
if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event)) {
if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event))
wake_up_interruptible(&info->shutdown_wait);
}
#endif
} /* do_softint */
......@@ -979,32 +977,31 @@ do_softint(struct work_struct *work)
This function is only called from inside spinlock-protected code.
*/
static int
cyy_issue_cmd(void __iomem *base_addr, u_char cmd, int index)
static int cyy_issue_cmd(void __iomem * base_addr, u_char cmd, int index)
{
volatile int i;
/* Check to see that the previous command has completed */
for(i = 0 ; i < 100 ; i++){
if (cy_readb(base_addr+(CyCCR<<index)) == 0){
for (i = 0; i < 100; i++) {
if (cy_readb(base_addr + (CyCCR << index)) == 0) {
break;
}
udelay(10L);
}
/* if the CCR never cleared, the previous command
didn't finish within the "reasonable time" */
if (i == 100) return (-1);
if (i == 100)
return (-1);
/* Issue the new command */
cy_writeb(base_addr+(CyCCR<<index), cmd);
cy_writeb(base_addr + (CyCCR << index), cmd);
return(0);
return (0);
} /* cyy_issue_cmd */
#ifdef CONFIG_ISA
/* ISA interrupt detection code */
static unsigned
detect_isa_irq(void __iomem *address)
static unsigned detect_isa_irq(void __iomem * address)
{
int irq;
unsigned long irqs, flags;
......@@ -1015,7 +1012,7 @@ detect_isa_irq(void __iomem *address)
irq = probe_irq_off(probe_irq_on());
/* Clear interrupts on the board first */
cy_writeb(address + (Cy_ClrIntr<<index), 0);
cy_writeb(address + (Cy_ClrIntr << index), 0);
/* Cy_ClrIntr is 0x1800 */
irqs = probe_irq_on();
......@@ -1024,12 +1021,12 @@ detect_isa_irq(void __iomem *address)
/* Enable the Tx interrupts on the CD1400 */
local_irq_save(flags);
cy_writeb(address + (CyCAR<<index), 0);
cyy_issue_cmd(address, CyCHAN_CTL|CyENB_XMTR, index);
cy_writeb(address + (CyCAR << index), 0);
cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
cy_writeb(address + (CyCAR<<index), 0);
cy_writeb(address + (CySRER<<index),
cy_readb(address + (CySRER<<index)) | CyTxRdy);
cy_writeb(address + (CyCAR << index), 0);
cy_writeb(address + (CySRER << index),
cy_readb(address + (CySRER << index)) | CyTxRdy);
local_irq_restore(flags);
/* Wait ... */
......@@ -1039,22 +1036,22 @@ detect_isa_irq(void __iomem *address)
irq = probe_irq_off(irqs);
/* Clean up */
save_xir = (u_char) cy_readb(address + (CyTIR<<index));
save_car = cy_readb(address + (CyCAR<<index));
cy_writeb(address + (CyCAR<<index), (save_xir & 0x3));
cy_writeb(address + (CySRER<<index),
cy_readb(address + (CySRER<<index)) & ~CyTxRdy);
cy_writeb(address + (CyTIR<<index), (save_xir & 0x3f));
cy_writeb(address + (CyCAR<<index), (save_car));
cy_writeb(address + (Cy_ClrIntr<<index), 0);
save_xir = (u_char) cy_readb(address + (CyTIR << index));
save_car = cy_readb(address + (CyCAR << index));
cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
cy_writeb(address + (CySRER << index),
cy_readb(address + (CySRER << index)) & ~CyTxRdy);
cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
cy_writeb(address + (CyCAR << index), (save_car));
cy_writeb(address + (Cy_ClrIntr << index), 0);
/* Cy_ClrIntr is 0x1800 */
return (irq > 0)? irq : 0;
return (irq > 0) ? irq : 0;
}
#endif /* CONFIG_ISA */
static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
void __iomem *base_addr, int status, int index)
void __iomem * base_addr, int status, int index)
{
struct cyclades_port *info;
struct tty_struct *tty;
......@@ -1069,85 +1066,122 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
#endif
/* determine the channel & change to that context */
spin_lock(&cinfo->card_lock);
save_xir = (u_char) cy_readb(base_addr+(CyRIR<<index));
channel = (u_short ) (save_xir & CyIRChannel);
save_xir = (u_char) cy_readb(base_addr + (CyRIR << index));
channel = (u_short) (save_xir & CyIRChannel);
i = channel + chip * 4 + cinfo->first_line;
info = &cy_port[i];
info->last_active = jiffies;
save_car = cy_readb(base_addr+(CyCAR<<index));
cy_writeb(base_addr+(CyCAR<<index), save_xir);
save_car = cy_readb(base_addr + (CyCAR << index));
cy_writeb(base_addr + (CyCAR << index), save_xir);
/* if there is nowhere to put the data, discard it */
if(info->tty == 0){
j = (cy_readb(base_addr+(CyRIVR<<index)) & CyIVRMask);
if ( j == CyIVRRxEx ) { /* exception */
data = cy_readb(base_addr+(CyRDSR<<index));
if (info->tty == 0) {
j = (cy_readb(base_addr + (CyRIVR << index)) &
CyIVRMask);
if (j == CyIVRRxEx) { /* exception */
data = cy_readb(base_addr + (CyRDSR << index));
} else { /* normal character reception */
char_count = cy_readb(base_addr+(CyRDCR<<index));
while(char_count--){
data = cy_readb(base_addr+(CyRDSR<<index));
char_count = cy_readb(base_addr +
(CyRDCR << index));
while (char_count--) {
data = cy_readb(base_addr +
(CyRDSR << index));
}
}
}else{ /* there is an open port for this data */
} else { /* there is an open port for this data */
tty = info->tty;
j = (cy_readb(base_addr+(CyRIVR<<index)) & CyIVRMask);
if ( j == CyIVRRxEx ) { /* exception */
data = cy_readb(base_addr+(CyRDSR<<index));
j = (cy_readb(base_addr + (CyRIVR << index)) &
CyIVRMask);
if (j == CyIVRRxEx) { /* exception */
data = cy_readb(base_addr + (CyRDSR << index));
/* For statistics only */
if (data & CyBREAK)
info->icount.brk++;
else if(data & CyFRAME)
else if (data & CyFRAME)
info->icount.frame++;
else if(data & CyPARITY)
else if (data & CyPARITY)
info->icount.parity++;
else if(data & CyOVERRUN)
else if (data & CyOVERRUN)
info->icount.overrun++;
if(data & info->ignore_status_mask){
if (data & info->ignore_status_mask) {
info->icount.rx++;
return;
}
if (tty_buffer_request_room(tty, 1)) {
if (data & info->read_status_mask){
if(data & CyBREAK){
tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_BREAK);
if (data & info->read_status_mask) {
if (data & CyBREAK) {
tty_insert_flip_char(
tty,
cy_readb(
base_addr +
(CyRDSR <<
index)),
TTY_BREAK);
info->icount.rx++;
if (info->flags & ASYNC_SAK){
if (info->flags &
ASYNC_SAK) {
do_SAK(tty);
}
}else if(data & CyFRAME){
tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
} else if (data & CyFRAME) {
tty_insert_flip_char(
tty,
cy_readb(
base_addr +
(CyRDSR <<
index)),
TTY_FRAME);
info->icount.rx++;
info->idle_stats.frame_errs++;
}else if(data & CyPARITY){
info->idle_stats.
frame_errs++;
} else if (data & CyPARITY) {
/* Pieces of seven... */
tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_PARITY);
tty_insert_flip_char(
tty,
cy_readb(
base_addr +
(CyRDSR <<
index)),
TTY_PARITY);
info->icount.rx++;
info->idle_stats.parity_errs++;
}else if(data & CyOVERRUN){
tty_insert_flip_char(tty, 0, TTY_OVERRUN);
info->idle_stats.
parity_errs++;
} else if (data & CyOVERRUN) {
tty_insert_flip_char(
tty, 0,
TTY_OVERRUN);
info->icount.rx++;
/* If the flip buffer itself is
overflowing, we still lose
the next incoming character.
*/
tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
tty_insert_flip_char(
tty,
cy_readb(
base_addr +
(CyRDSR <<
index)),
TTY_FRAME);
info->icount.rx++;
info->idle_stats.overruns++;
info->idle_stats.
overruns++;
/* These two conditions may imply */
/* a normal read should be done. */
/* }else if(data & CyTIMEOUT){ */
/* }else if(data & CySPECHAR){ */
}else {
tty_insert_flip_char(tty, 0, TTY_NORMAL);
} else {
tty_insert_flip_char(
tty, 0,
TTY_NORMAL);
info->icount.rx++;
}
}else{
tty_insert_flip_char(tty, 0, TTY_NORMAL);
} else {
tty_insert_flip_char(tty, 0,
TTY_NORMAL);
info->icount.rx++;
}
}else{
} else {
/* there was a software buffer
overrun and nothing could be
done about it!!! */
......@@ -1156,7 +1190,8 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
}
} else { /* normal character reception */
/* load # chars available from the chip */
char_count = cy_readb(base_addr+(CyRDCR<<index));
char_count = cy_readb(base_addr +
(CyRDCR << index));
#ifdef CY_ENABLE_MONITORING
++info->mon.int_count;
......@@ -1166,9 +1201,11 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
info->mon.char_last = char_count;
#endif
len = tty_buffer_request_room(tty, char_count);
while(len--){
data = cy_readb(base_addr+(CyRDSR<<index));
tty_insert_flip_char(tty, data, TTY_NORMAL);
while (len--) {
data = cy_readb(base_addr +
(CyRDSR << index));
tty_insert_flip_char(tty, data,
TTY_NORMAL);
info->idle_stats.recv_bytes++;
info->icount.rx++;
#ifdef CY_16Y_HACK
......@@ -1180,12 +1217,11 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
tty_schedule_flip(tty);
}
/* end of service */
cy_writeb(base_addr+(CyRIR<<index), (save_xir & 0x3f));
cy_writeb(base_addr+(CyCAR<<index), (save_car));
cy_writeb(base_addr + (CyRIR << index), (save_xir & 0x3f));
cy_writeb(base_addr + (CyCAR << index), (save_car));
spin_unlock(&cinfo->card_lock);
}
if (status & CySRTransmit) { /* transmission interrupt */
/* Since we only get here when the transmit buffer
is empty, we know we can always stuff a dozen
......@@ -1196,32 +1232,34 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
/* determine the channel & change to that context */
spin_lock(&cinfo->card_lock);
save_xir = (u_char) cy_readb(base_addr+(CyTIR<<index));
channel = (u_short ) (save_xir & CyIRChannel);
save_xir = (u_char) cy_readb(base_addr + (CyTIR << index));
channel = (u_short) (save_xir & CyIRChannel);
i = channel + chip * 4 + cinfo->first_line;
save_car = cy_readb(base_addr+(CyCAR<<index));
cy_writeb(base_addr+(CyCAR<<index), save_xir);
save_car = cy_readb(base_addr + (CyCAR << index));
cy_writeb(base_addr + (CyCAR << index), save_xir);
/* validate the port# (as configured and open) */
if( (i < 0) || (NR_PORTS <= i) ){
cy_writeb(base_addr+(CySRER<<index),
cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
if ((i < 0) || (NR_PORTS <= i)) {
cy_writeb(base_addr + (CySRER << index),
cy_readb(base_addr + (CySRER << index)) &
~CyTxRdy);
goto txend;
}
info = &cy_port[i];
info->last_active = jiffies;
if(info->tty == 0){
cy_writeb(base_addr+(CySRER<<index),
cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
if (info->tty == 0) {
cy_writeb(base_addr + (CySRER << index),
cy_readb(base_addr + (CySRER << index)) &
~CyTxRdy);
goto txdone;
}
/* load the on-chip space for outbound data */
char_count = info->xmit_fifo_size;
if(info->x_char) { /* send special char */
if (info->x_char) { /* send special char */
outch = info->x_char;
cy_writeb(base_addr+(CyTDR<<index), outch);
cy_writeb(base_addr + (CyTDR << index), outch);
char_count--;
info->icount.tx++;
info->x_char = 0;
......@@ -1229,42 +1267,44 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
if (info->breakon || info->breakoff) {
if (info->breakon) {
cy_writeb(base_addr + (CyTDR<<index), 0);
cy_writeb(base_addr + (CyTDR<<index), 0x81);
cy_writeb(base_addr + (CyTDR << index), 0);
cy_writeb(base_addr + (CyTDR << index), 0x81);
info->breakon = 0;
char_count -= 2;
}
if (info->breakoff) {
cy_writeb(base_addr + (CyTDR<<index), 0);
cy_writeb(base_addr + (CyTDR<<index), 0x83);
cy_writeb(base_addr + (CyTDR << index), 0);
cy_writeb(base_addr + (CyTDR << index), 0x83);
info->breakoff = 0;
char_count -= 2;
}
}
while (char_count-- > 0){
if (!info->xmit_cnt){
if (cy_readb(base_addr+(CySRER<<index))&CyTxMpty) {
cy_writeb(base_addr+(CySRER<<index),
cy_readb(base_addr+(CySRER<<index)) &
while (char_count-- > 0) {
if (!info->xmit_cnt) {
if (cy_readb(base_addr + (CySRER << index)) &
CyTxMpty) {
cy_writeb(base_addr + (CySRER << index),
cy_readb(base_addr +
(CySRER << index)) &
~CyTxMpty);
} else {
cy_writeb(base_addr+(CySRER<<index),
((cy_readb(base_addr+(CySRER<<index))
& ~CyTxRdy)
| CyTxMpty));
cy_writeb(base_addr + (CySRER << index),
(cy_readb(base_addr +
(CySRER << index)) &
~CyTxRdy) | CyTxMpty);
}
goto txdone;
}
if (info->xmit_buf == 0){
cy_writeb(base_addr+(CySRER<<index),
cy_readb(base_addr+(CySRER<<index)) &
if (info->xmit_buf == 0) {
cy_writeb(base_addr + (CySRER << index),
cy_readb(base_addr + (CySRER << index))&
~CyTxRdy);
goto txdone;
}
if (info->tty->stopped || info->tty->hw_stopped){
cy_writeb(base_addr+(CySRER<<index),
cy_readb(base_addr+(CySRER<<index)) &
if (info->tty->stopped || info->tty->hw_stopped) {
cy_writeb(base_addr + (CySRER << index),
cy_readb(base_addr + (CySRER << index))&
~CyTxRdy);
goto txdone;
}
......@@ -1280,23 +1320,24 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
room for the two chars needed to send a NULL.)
*/
outch = info->xmit_buf[info->xmit_tail];
if( outch ){
if (outch) {