lkml.org 
[lkml]   [2002]   [Jan]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH] wavelan_cs update (Pcmcia backport)
    wow thanks... it's imminently useful to me.

    joelja

    On Fri, 11 Jan 2002, Jean Tourrilhes wrote:

    > Hi,
    >
    > I was playing with wavelan_cs in the kernel (converting it to
    > the new Wireless Extensions), and I realised that it doesn't work at
    > all. I had a look at the code and it is so antique that it is scary.
    > So, I did a backport of the version of the driver in the
    > Pcmcia package, which is one year old and which works. The main
    > changes are in the log below (many spinlock changes), many other
    > changes are because the Pcmcia version is doing the same things
    > differently (I made sure no change was lost). Patch is large by having
    > both drivers in sync is a bonus.
    > As a driver that works is better than a driver that doesn't
    > work, I would like this patch to be included in the various kernels.
    >
    > Regards,
    >
    > Jean
    >
    > --------------------------------------------------------------
    >
    > diff -u -p -r linux/drivers/net/pcmcia-buggy/wavelan.h linux/drivers/net/pcmcia/wavelan.h
    > --- linux/drivers/net/pcmcia-buggy/wavelan.h Fri Mar 2 11:02:15 2001
    > +++ linux/drivers/net/pcmcia/wavelan.h Fri Jan 11 14:25:31 2002
    > @@ -88,6 +88,7 @@ const short channel_bands[] = { 0x30, 0x
    > */
    > const int fixed_bands[] = { 915e6, 2.425e8, 2.46e8, 2.484e8, 2.4305e8 };
    >
    > +
    > /*************************** PC INTERFACE ****************************/
    >
    > /* WaveLAN host interface definitions */
    > @@ -316,6 +317,7 @@ struct mmw_t
    > /* Calculate offset of a field in the above structure */
    > #define mmwoff(p,f) (unsigned short)((void *)(&((mmw_t *)((void *)0 + (p)))->f) - (void *)0)
    >
    > +
    > /*
    > * Modem Management Controller (MMC) read structure.
    > */
    > @@ -372,6 +374,7 @@ struct mmr_t
    >
    > /* Calculate offset of a field in the above structure */
    > #define mmroff(p,f) (unsigned short)((void *)(&((mmr_t *)((void *)0 + (p)))->f) - (void *)0)
    > +
    >
    > /* Make the two above structures one */
    > typedef union mm_t
    > diff -u -p -r linux/drivers/net/pcmcia-buggy/wavelan_cs.c linux/drivers/net/pcmcia/wavelan_cs.c
    > --- linux/drivers/net/pcmcia-buggy/wavelan_cs.c Fri Nov 9 15:22:54 2001
    > +++ linux/drivers/net/pcmcia/wavelan_cs.c Fri Jan 11 14:57:51 2002
    > @@ -22,7 +22,7 @@
    > #ifdef WAVELAN_ROAMING
    > * Roaming support added 07/22/98 by Justin Seger (jseger@media.mit.edu)
    > * based on patch by Joe Finney from Lancaster University.
    > -#endif :-)
    > +#endif
    > *
    > * Lucent (formerly AT&T GIS, formerly NCR) WaveLAN PCMCIA card: An
    > * Ethernet-like radio transceiver controlled by an Intel 82593 coprocessor.
    > @@ -37,12 +37,6 @@
    > * Apr 2 '98 made changes to bring the i82593 control/int handling in line
    > * with offical specs...
    > *
    > - * Changes:
    > - * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 08/08/2000
    > - * - reorganize kmallocs in wavelan_attach, checking all for failure
    > - * and releasing the previous allocations if one fails
    > - *
    > - *
    > ****************************************************************************
    > * Copyright 1995
    > * Anthony D. Joseph
    > @@ -72,6 +66,34 @@
    >
    > /*------------------------------------------------------------------*/
    > /*
    > + * Wrapper for disabling interrupts.
    > + * (note : inline, so optimised away)
    > + */
    > +static inline void
    > +wv_splhi(net_local * lp,
    > + unsigned long * pflags)
    > +{
    > + spin_lock_irqsave(&lp->spinlock, *pflags);
    > + /* Note : above does the cli(); itself */
    > +}
    > +
    > +/*------------------------------------------------------------------*/
    > +/*
    > + * Wrapper for re-enabling interrupts.
    > + */
    > +static inline void
    > +wv_splx(net_local * lp,
    > + unsigned long * pflags)
    > +{
    > + spin_unlock_irqrestore(&lp->spinlock, *pflags);
    > +
    > + /* Note : enabling interrupts on the hardware is done in wv_ru_start()
    > + * via : outb(OP1_INT_ENABLE, LCCR(base));
    > + */
    > +}
    > +
    > +/*------------------------------------------------------------------*/
    > +/*
    > * Wrapper for reporting error to cardservices
    > */
    > static void cs_error(client_handle_t handle, int func, int ret)
    > @@ -103,7 +125,7 @@ wv_structuct_check(void)
    >
    > /******************* MODEM MANAGEMENT SUBROUTINES *******************/
    > /*
    > - * Usefull subroutines to manage the modem of the wavelan
    > + * Useful subroutines to manage the modem of the wavelan
    > */
    >
    > /*------------------------------------------------------------------*/
    > @@ -138,7 +160,7 @@ hacr_write_slow(u_long base,
    > {
    > hacr_write(base, hacr);
    > /* delay might only be needed sometimes */
    > - mdelay(1L);
    > + mdelay(1);
    > } /* hacr_write_slow */
    >
    > /*------------------------------------------------------------------*/
    > @@ -529,7 +551,7 @@ void wv_roam_init(struct net_device *dev
    > lp->curr_point=NULL; /* No default WavePoint */
    > lp->cell_search=0;
    >
    > - lp->cell_timer.data=(int)lp; /* Start cell expiry timer */
    > + lp->cell_timer.data=(long)lp; /* Start cell expiry timer */
    > lp->cell_timer.function=wl_cell_expiry;
    > lp->cell_timer.expires=jiffies+CELL_TIMEOUT;
    > add_timer(&lp->cell_timer);
    > @@ -569,18 +591,18 @@ void wv_nwid_filter(unsigned char mode,
    > #endif
    >
    > /* Disable interrupts & save flags */
    > - spin_lock_irqsave (&lp->lock, flags);
    > + wv_splhi(lp, &flags);
    >
    > m.w.mmw_loopt_sel = (mode==NWID_PROMISC) ? MMW_LOOPT_SEL_DIS_NWID : 0x00;
    > mmc_write(lp->dev->base_addr, (char *)&m.w.mmw_loopt_sel - (char *)&m, (unsigned char *)&m.w.mmw_loopt_sel, 1);
    >
    > - /* ReEnable interrupts & restore flags */
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > -
    > if(mode==NWID_PROMISC)
    > lp->cell_search=1;
    > else
    > - lp->cell_search=0;
    > + lp->cell_search=0;
    > +
    > + /* ReEnable interrupts & restore flags */
    > + wv_splx(lp, &flags);
    > }
    >
    > /* Find a record in the WavePoint table matching a given NWID */
    > @@ -737,7 +759,7 @@ void wv_roam_handover(wavepoint_history
    > ioaddr_t base = lp->dev->base_addr;
    > mm_t m;
    > unsigned long flags;
    > -
    > +
    > if(wavepoint==lp->curr_point) /* Sanity check... */
    > {
    > wv_nwid_filter(!NWID_PROMISC,lp);
    > @@ -749,16 +771,16 @@ void wv_roam_handover(wavepoint_history
    > #endif
    >
    > /* Disable interrupts & save flags */
    > - spin_lock_irqsave(&lp->lock, flags);
    > -
    > + wv_splhi(lp, &flags);
    > +
    > m.w.mmw_netw_id_l = wavepoint->nwid & 0xFF;
    > m.w.mmw_netw_id_h = (wavepoint->nwid & 0xFF00) >> 8;
    >
    > mmc_write(base, (char *)&m.w.mmw_netw_id_l - (char *)&m, (unsigned char *)&m.w.mmw_netw_id_l, 2);
    >
    > /* ReEnable interrupts & restore flags */
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > -
    > + wv_splx(lp, &flags);
    > +
    > wv_nwid_filter(!NWID_PROMISC,lp);
    > lp->curr_point=wavepoint;
    > }
    > @@ -775,6 +797,11 @@ static inline void wl_roam_gather(device
    > wavepoint_history *wavepoint=NULL; /* WavePoint table entry */
    > net_local *lp=(net_local *)dev->priv; /* Device info */
    >
    > +#if 0
    > + /* Some people don't need this, some other may need it */
    > + nwid=nwid^ntohs(beacon->domain_id);
    > +#endif
    > +
    > #if WAVELAN_ROAMING_DEBUG > 1
    > printk(KERN_DEBUG "WaveLAN: beacon, dev %s:\n",dev->name);
    > printk(KERN_DEBUG "Domain: %.4X NWID: %.4X SigQual=%d\n",ntohs(beacon->domain_id),nwid,sigqual);
    > @@ -832,7 +859,9 @@ static inline int WAVELAN_BEACON(unsigne
    > /*------------------------------------------------------------------*/
    > /*
    > * Routine to synchronously send a command to the i82593 chip.
    > - * Should be called with interrupts enabled.
    > + * Should be called with interrupts disabled.
    > + * (called by wv_packet_write(), wv_ru_stop(), wv_ru_start(),
    > + * wv_82593_config() & wv_diag())
    > */
    > static int
    > wv_82593_cmd(device * dev,
    > @@ -841,74 +870,98 @@ wv_82593_cmd(device * dev,
    > int result)
    > {
    > ioaddr_t base = dev->base_addr;
    > - net_local * lp = (net_local *)dev->priv;
    > int status;
    > + int wait_completed;
    > long spin;
    > - u_long flags;
    >
    > /* Spin until the chip finishes executing its current command (if any) */
    > + spin = 1000;
    > do
    > {
    > - spin_lock_irqsave (&lp->lock, flags);
    > + /* Time calibration of the loop */
    > + udelay(10);
    > +
    > + /* Read the interrupt register */
    > outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
    > status = inb(LCSR(base));
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > }
    > - while((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE);
    > + while(((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE) && (spin-- > 0));
    >
    > - /* We are waiting for command completion */
    > - wv_wait_completed = TRUE;
    > + /* If the interrupt hasn't be posted */
    > + if(spin <= 0)
    > + {
    > +#ifdef DEBUG_INTERRUPT_ERROR
    > + printk(KERN_INFO "wv_82593_cmd: %s timeout (previous command), status 0x%02x\n",
    > + str, status);
    > +#endif
    > + return(FALSE);
    > + }
    >
    > /* Issue the command to the controller */
    > outb(cmd, LCCR(base));
    >
    > - /* If we don't have to check the result of the command */
    > + /* If we don't have to check the result of the command
    > + * Note : this mean that the irq handler will deal with that */
    > if(result == SR0_NO_RESULT)
    > - {
    > - wv_wait_completed = FALSE;
    > - return(TRUE);
    > - }
    > + return(TRUE);
    >
    > - /* Busy wait while the LAN controller executes the command.
    > - * Note : wv_wait_completed should be volatile */
    > - spin = 0;
    > - while(wv_wait_completed && (spin++ < 1000))
    > - udelay(10);
    > + /* We are waiting for command completion */
    > + wait_completed = TRUE;
    >
    > - /* If the interrupt handler hasn't be called */
    > - if(wv_wait_completed)
    > + /* Busy wait while the LAN controller executes the command. */
    > + spin = 1000;
    > + do
    > {
    > - outb(OP0_NOP, LCCR(base));
    > + /* Time calibration of the loop */
    > + udelay(10);
    > +
    > + /* Read the interrupt register */
    > + outb(CR0_STATUS_0 | OP0_NOP, LCCR(base));
    > status = inb(LCSR(base));
    > - if(status & SR0_INTERRUPT)
    > +
    > + /* Check if there was an interrupt posted */
    > + if((status & SR0_INTERRUPT))
    > {
    > - /* There was an interrupt : call the interrupt handler */
    > -#ifdef DEBUG_INTERRUPT_ERROR
    > - printk(KERN_WARNING "wv_82593_cmd: interrupt handler not installed or interrupt disabled\n");
    > -#endif
    > + /* Acknowledge the interrupt */
    > + outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
    >
    > - wavelan_interrupt(dev->irq, (void *) dev,
    > - (struct pt_regs *) NULL);
    > + /* Check if interrupt is a command completion */
    > + if(((status & SR0_BOTH_RX_TX) != SR0_BOTH_RX_TX) &&
    > + ((status & SR0_BOTH_RX_TX) != 0x0) &&
    > + !(status & SR0_RECEPTION))
    > + {
    > + /* Signal command completion */
    > + wait_completed = FALSE;
    > + }
    > + else
    > + {
    > + /* Note : Rx interrupts will be handled later, because we can
    > + * handle multiple Rx packets at once */
    > +#ifdef DEBUG_INTERRUPT_INFO
    > + printk(KERN_INFO "wv_82593_cmd: not our interrupt\n");
    > +#endif
    > + }
    > }
    > - else
    > - {
    > - wv_wait_completed = 0; /* XXX */
    > + }
    > + while(wait_completed && (spin-- > 0));
    > +
    > + /* If the interrupt hasn't be posted */
    > + if(wait_completed)
    > + {
    > #ifdef DEBUG_INTERRUPT_ERROR
    > - printk(KERN_INFO "wv_82593_cmd: %s timeout, status0 0x%02x\n",
    > - str, status);
    > + printk(KERN_INFO "wv_82593_cmd: %s timeout, status 0x%02x\n",
    > + str, status);
    > #endif
    > - /* We probably should reset the controller here */
    > - return(FALSE);
    > - }
    > + return(FALSE);
    > }
    >
    > - /* Check the return code provided by the interrupt handler against
    > + /* Check the return code returned by the card (see above) against
    > * the expected return code provided by the caller */
    > - if((lp->status & SR0_EVENT_MASK) != result)
    > + if((status & SR0_EVENT_MASK) != result)
    > {
    > #ifdef DEBUG_INTERRUPT_ERROR
    > - printk(KERN_INFO "wv_82593_cmd: %s failed, status0 = 0x%x\n",
    > - str, lp->status);
    > + printk(KERN_INFO "wv_82593_cmd: %s failed, status = 0x%x\n",
    > + str, status);
    > #endif
    > return(FALSE);
    > }
    > @@ -924,14 +977,16 @@ wv_82593_cmd(device * dev,
    > static inline int
    > wv_diag(device * dev)
    > {
    > + int ret = FALSE;
    > +
    > if(wv_82593_cmd(dev, "wv_diag(): diagnose",
    > OP0_DIAGNOSE, SR0_DIAGNOSE_PASSED))
    > - return(TRUE);
    > + ret = TRUE;
    >
    > #ifdef DEBUG_CONFIG_ERROR
    > printk(KERN_INFO "wavelan_cs: i82593 Self Test failed!\n");
    > #endif
    > - return(FALSE);
    > + return(ret);
    > } /* wv_diag */
    >
    > /*------------------------------------------------------------------*/
    > @@ -951,15 +1006,6 @@ read_ringbuf(device * dev,
    > int chunk_len;
    > char * buf_ptr = buf;
    >
    > -#ifdef OLDIES
    > - /* After having check skb_put (net/core/skbuff.c) in the kernel, it seem
    > - * quite safe to remove this... */
    > -
    > - /* If buf is NULL, just increment the ring buffer pointer */
    > - if(buf == NULL)
    > - return((ring_ptr - RX_BASE + len) % RX_SIZE + RX_BASE);
    > -#endif
    > -
    > /* Get all the buffer */
    > while(len > 0)
    > {
    > @@ -990,70 +1036,32 @@ read_ringbuf(device * dev,
    > * wavelan_interrupt is not an option...), so you may experience
    > * some delay sometime...
    > */
    > -static inline void wv_82593_reconfig (device * dev)
    > +static inline void
    > +wv_82593_reconfig(device * dev)
    > {
    > - net_local *lp = (net_local *) dev->priv;
    > - dev_link_t *link = ((net_local *) dev->priv)->link;
    > + net_local * lp = (net_local *)dev->priv;
    > + dev_link_t * link = ((net_local *) dev->priv)->link;
    > + unsigned long flags;
    > +
    > + /* Arm the flag, will be cleard in wv_82593_config() */
    > + lp->reconfig_82593 = TRUE;
    >
    > - /* Check if we can do it now ! */
    > - if (!(link->open)) {
    > - lp->reconfig_82593 = TRUE;
    > + /* Check if we can do it now ! */
    > + if((link->open) && (netif_running(dev)) && !(netif_queue_stopped(dev)))
    > + {
    > + wv_splhi(lp, &flags); /* Disable interrupts */
    > + wv_82593_config(dev);
    > + wv_splx(lp, &flags); /* Re-enable interrupts */
    > + }
    > + else
    > + {
    > #ifdef DEBUG_IOCTL_INFO
    > - printk (KERN_DEBUG "%s: wv_82593_reconfig(): delayed (link = %d)\n",
    > - dev->name, link->open);
    > + printk(KERN_DEBUG
    > + "%s: wv_82593_reconfig(): delayed (state = %lX, link = %d)\n",
    > + dev->name, dev->state, link->open);
    > #endif
    > - } else {
    > - netif_stop_queue (dev);
    > -
    > - lp->reconfig_82593 = FALSE;
    > - wv_82593_config (dev);
    > - netif_wake_queue (dev);
    > - }
    > -}
    > -
    > -#ifdef OLDIES
    > -/*------------------------------------------------------------------*/
    > -/*
    > - * Dumps the current i82593 receive buffer to the console.
    > - */
    > -static void wavelan_dump(device *dev)
    > -{
    > - ioaddr_t base = dev->base_addr;
    > - int i, c;
    > -
    > - /* disable receiver so we can use channel 1 */
    > - outb(OP0_RCV_DISABLE, LCCR(base));
    > -
    > - /* reset receive DMA pointer */
    > - hacr_write_slow(base, HACR_PWR_STAT | HACR_RX_DMA_RESET);
    > - hacr_write(base, HACR_DEFAULT);
    > -
    > - /* dump into receive buffer */
    > - wv_82593_cmd(dev, "wavelan_dump(): dump", CR0_CHNL|OP0_DUMP, SR0_DUMP_DONE);
    > -
    > - /* set read pointer to start of receive buffer */
    > - outb(0, PIORL(base));
    > - outb(0, PIORH(base));
    > -
    > - printk(KERN_DEBUG "wavelan_cs: dump:\n");
    > - printk(KERN_DEBUG " 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F");
    > - for(i = 0; i < 73; i++){
    > - if((i % 16) == 0) {
    > - printk("\n0x%02x:", i);
    > - if (!i) {
    > - printk(" ");
    > - continue;
    > - }
    > }
    > - c = inb(PIOP(base));
    > - printk("%02x ", c);
    > - }
    > - printk("\n");
    > -
    > - /* enable the receiver again */
    > - wv_ru_start(dev);
    > }
    > -#endif
    >
    > /********************* DEBUG & INFO SUBROUTINES *********************/
    > /*
    > @@ -1171,6 +1179,8 @@ wv_mmc_show(device * dev)
    > return;
    > }
    >
    > + wv_splhi(lp, &flags);
    > +
    > /* Read the mmc */
    > mmc_out(base, mmwoff(0, mmw_freeze), 1);
    > mmc_read(base, 0, (u_char *)&m, sizeof(m));
    > @@ -1181,6 +1191,8 @@ wv_mmc_show(device * dev)
    > lp->wstats.discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
    > #endif /* WIRELESS_EXT */
    >
    > + wv_splx(lp, &flags);
    > +
    > printk(KERN_DEBUG "##### wavelan modem status registers: #####\n");
    > #ifdef DEBUG_SHOW_UNUSED
    > printk(KERN_DEBUG "mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
    > @@ -1265,6 +1277,7 @@ static void
    > wv_dev_show(device * dev)
    > {
    > printk(KERN_DEBUG "dev:");
    > + printk(" state=%lX,", dev->state);
    > printk(" trans_start=%ld,", dev->trans_start);
    > printk(" flags=0x%x,", dev->flags);
    > printk("\n");
    > @@ -1404,7 +1417,7 @@ wv_init_info(device * dev)
    > printk("2430.5");
    > break;
    > default:
    > - printk("unknown");
    > + printk("???");
    > }
    > }
    >
    > @@ -1719,7 +1732,7 @@ wv_set_frequency(u_long base, /* i/o po
    > memcmp(dac, dac_verify, 2 * 2))
    > {
    > #ifdef DEBUG_IOCTL_ERROR
    > - printk(KERN_INFO "Wavelan: wv_set_frequency : unable to write new frequency to EEprom (?)\n");
    > + printk(KERN_INFO "Wavelan: wv_set_frequency : unable to write new frequency to EEprom (??)\n");
    > #endif
    > return -EOPNOTSUPP;
    > }
    > @@ -1892,7 +1905,7 @@ wavelan_ioctl(struct net_device * dev, /
    > #endif
    >
    > /* Disable interrupts & save flags */
    > - spin_lock_irqsave (&lp->lock, flags);
    > + wv_splhi(lp, &flags);
    >
    > /* Look what is the request */
    > switch(cmd)
    > @@ -1968,7 +1981,7 @@ wavelan_ioctl(struct net_device * dev, /
    >
    > case SIOCGIWFREQ:
    > /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
    > - * (does it work for everybody XXX - especially old cards...) */
    > + * (does it work for everybody ??? - especially old cards...) */
    > if(!(mmc_in(base, mmroff(0, mmr_fee_status)) &
    > (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
    > {
    > @@ -2239,15 +2252,17 @@ wavelan_ioctl(struct net_device * dev, /
    > {
    > struct iw_range range;
    >
    > - /* Set the length (very important for backward compatibility) */
    > - wrq->u.data.length = sizeof(struct iw_range);
    > + /* Set the length (very important for backward compatibility) */
    > + wrq->u.data.length = sizeof(struct iw_range);
    >
    > - /* Set all the info we don't care or don't know about to zero */
    > - memset(&range, 0, sizeof(range));
    > + /* Set all the info we don't care or don't know about to zero */
    > + memset(&range, 0, sizeof(range));
    >
    > - /* Set the Wireless Extension versions */
    > - range.we_version_compiled = WIRELESS_EXT;
    > - range.we_version_source = 9; /* Nothing for us in v10 and v11 */
    > +#if WIRELESS_EXT > 10
    > + /* Set the Wireless Extension versions */
    > + range.we_version_compiled = WIRELESS_EXT;
    > + range.we_version_source = 9; /* Nothing for us in v10 and v11 */
    > +#endif /* WIRELESS_EXT > 10 */
    >
    > /* Set information in the range struct */
    > range.throughput = 1.4 * 1000 * 1000; /* don't argue on this ! */
    > @@ -2517,7 +2532,7 @@ wavelan_ioctl(struct net_device * dev, /
    > }
    >
    > /* ReEnable interrupts & restore flags */
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > + wv_splx(lp, &flags);
    >
    > #ifdef DEBUG_IOCTL_TRACE
    > printk(KERN_DEBUG "%s: <-wavelan_ioctl()\n", dev->name);
    > @@ -2543,11 +2558,8 @@ wavelan_get_wireless_stats(device * dev)
    > printk(KERN_DEBUG "%s: ->wavelan_get_wireless_stats()\n", dev->name);
    > #endif
    >
    > - if (lp == NULL) /* XXX will this ever occur? */
    > - return NULL;
    > -
    > /* Disable interrupts & save flags */
    > - spin_lock_irqsave (&lp->lock, flags);
    > + wv_splhi(lp, &flags);
    >
    > wstats = &lp->wstats;
    >
    > @@ -2573,7 +2585,7 @@ wavelan_get_wireless_stats(device * dev)
    > wstats->discard.misc = 0L;
    >
    > /* ReEnable interrupts & restore flags */
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > + wv_splx(lp, &flags);
    >
    > #ifdef DEBUG_IOCTL_TRACE
    > printk(KERN_DEBUG "%s: <-wavelan_get_wireless_stats()\n", dev->name);
    > @@ -2692,12 +2704,6 @@ wv_packet_read(device * dev,
    > skb->protocol = eth_type_trans(skb, dev);
    >
    > #ifdef DEBUG_RX_INFO
    > - /* Another glitch : Due to the way the GET_PACKET macro is written,
    > - * we are not sure to have the same thing in skb->data. On the other
    > - * hand, skb->mac.raw is not defined everywhere...
    > - * For versions between 1.2.13 and those where skb->mac.raw appear,
    > - * I don't have a clue...
    > - */
    > wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read");
    > #endif /* DEBUG_RX_INFO */
    >
    > @@ -2731,9 +2737,7 @@ wv_packet_read(device * dev,
    > wl_roam_gather(dev, skb->data, stats);
    > #endif /* WAVELAN_ROAMING */
    >
    > - /* Spying stuff */
    > #ifdef WIRELESS_SPY
    > - /* Same as above */
    > wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE, stats);
    > #endif /* WIRELESS_SPY */
    > #ifdef HISTOGRAM
    > @@ -2766,6 +2770,7 @@ wv_packet_read(device * dev,
    > * called to do the actual transfer of the card's data including the
    > * ethernet header into a packet consisting of an sk_buff chain.
    > * (called by wavelan_interrupt())
    > + * Note : the spinlock is already grabbed for us and irq are disabled.
    > */
    > static inline void
    > wv_packet_rcv(device * dev)
    > @@ -2916,7 +2921,7 @@ wv_packet_write(device * dev,
    > printk(KERN_DEBUG "%s: ->wv_packet_write(%d)\n", dev->name, length);
    > #endif
    >
    > - spin_lock_irqsave (&lp->lock, flags);
    > + wv_splhi(lp, &flags);
    >
    > /* Check if we need some padding */
    > if(clen < ETH_ZLEN)
    > @@ -2946,15 +2951,7 @@ wv_packet_write(device * dev,
    > /* Keep stats up to date */
    > lp->stats.tx_bytes += length;
    >
    > - /* If watchdog not already active, activate it... */
    > - if (!timer_pending(&lp->watchdog))
    > - {
    > - /* set timer to expire in WATCHDOG_JIFFIES */
    > - lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES;
    > - add_timer(&lp->watchdog);
    > - }
    > -
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > + wv_splx(lp, &flags);
    >
    > #ifdef DEBUG_TX_INFO
    > wv_packet_info((u_char *) buf, length, dev->name, "wv_packet_write");
    > @@ -2963,56 +2960,57 @@ wv_packet_write(device * dev,
    > #ifdef DEBUG_TX_TRACE
    > printk(KERN_DEBUG "%s: <-wv_packet_write()\n", dev->name);
    > #endif
    > -
    > - netif_start_queue (dev);
    > }
    >
    > /*------------------------------------------------------------------*/
    > /*
    > * This routine is called when we want to send a packet (NET3 callback)
    > - * In this routine, we check if the hardware is ready to accept
    > + * In this routine, we check if the harware is ready to accept
    > * the packet. We also prevent reentrance. Then, we call the function
    > * to send the packet...
    > */
    > -static int wavelan_packet_xmit (struct sk_buff *skb,
    > - device * dev)
    > +static int
    > +wavelan_packet_xmit(struct sk_buff * skb,
    > + device * dev)
    > {
    > - net_local *lp = (net_local *) dev->priv;
    > + net_local * lp = (net_local *)dev->priv;
    > + unsigned long flags;
    >
    > #ifdef DEBUG_TX_TRACE
    > - printk (KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name,
    > - (unsigned) skb);
    > + printk(KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name,
    > + (unsigned) skb);
    > #endif
    >
    > - /*
    > - * For ethernet, fill in the header.
    > - */
    > + /*
    > + * Block a timer-based transmit from overlapping a previous transmit.
    > + * In other words, prevent reentering this routine.
    > + */
    > + netif_stop_queue(dev);
    >
    > - netif_stop_queue (dev);
    > + /* If somebody has asked to reconfigure the controller,
    > + * we can do it now */
    > + if(lp->reconfig_82593)
    > + {
    > + wv_splhi(lp, &flags); /* Disable interrupts */
    > + wv_82593_config(dev);
    > + wv_splx(lp, &flags); /* Re-enable interrupts */
    > + /* Note : the configure procedure was totally synchronous,
    > + * so the Tx buffer is now free */
    > + }
    >
    > - /*
    > - * Block a timer-based transmit from overlapping a previous transmit.
    > - * In other words, prevent reentering this routine.
    > - */
    > - if (1) {
    > - /* If somebody has asked to reconfigure the controller, we can do it now */
    > - if (lp->reconfig_82593) {
    > - lp->reconfig_82593 = FALSE;
    > - wv_82593_config (dev);
    > - }
    > #ifdef DEBUG_TX_ERROR
    > - if (skb->next)
    > - printk (KERN_INFO "skb has next\n");
    > + if (skb->next)
    > + printk(KERN_INFO "skb has next\n");
    > #endif
    >
    > - wv_packet_write (dev, skb->data, skb->len);
    > - }
    > - dev_kfree_skb (skb);
    > + wv_packet_write(dev, skb->data, skb->len);
    > +
    > + dev_kfree_skb(skb);
    >
    > #ifdef DEBUG_TX_TRACE
    > - printk (KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name);
    > + printk(KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name);
    > #endif
    > - return (0);
    > + return(0);
    > }
    >
    > /********************** HARDWARE CONFIGURATION **********************/
    > @@ -3165,7 +3163,7 @@ wv_mmc_init(device * dev)
    > */
    >
    > /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
    > - * (does it work for everybody XXX - especially old cards...) */
    > + * (does it work for everybody ??? - especially old cards...) */
    > /* Note : WFREQSEL verify that it is able to read from EEprom
    > * a sensible frequency (address 0x00) + that MMR_FEE_STATUS_ID
    > * is 0xA (Xilinx version) or 0xB (Ariadne version).
    > @@ -3223,7 +3221,7 @@ static int
    > wv_ru_stop(device * dev)
    > {
    > ioaddr_t base = dev->base_addr;
    > - net_local *lp = (net_local *) dev->priv;
    > + net_local * lp = (net_local *) dev->priv;
    > unsigned long flags;
    > int status;
    > int spin;
    > @@ -3232,35 +3230,35 @@ wv_ru_stop(device * dev)
    > printk(KERN_DEBUG "%s: ->wv_ru_stop()\n", dev->name);
    > #endif
    >
    > + wv_splhi(lp, &flags);
    > +
    > /* First, send the LAN controller a stop receive command */
    > wv_82593_cmd(dev, "wv_graceful_shutdown(): stop-rcv",
    > OP0_STOP_RCV, SR0_NO_RESULT);
    >
    > /* Then, spin until the receive unit goes idle */
    > - spin = 0;
    > + spin = 300;
    > do
    > {
    > udelay(10);
    > - spin_lock_irqsave (&lp->lock, flags);
    > outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
    > status = inb(LCSR(base));
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > }
    > - while(((status & SR3_RCV_STATE_MASK) != SR3_RCV_IDLE) && (spin++ < 300));
    > + while(((status & SR3_RCV_STATE_MASK) != SR3_RCV_IDLE) && (spin-- > 0));
    >
    > /* Now, spin until the chip finishes executing its current command */
    > do
    > {
    > udelay(10);
    > - spin_lock_irqsave (&lp->lock, flags);
    > outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
    > status = inb(LCSR(base));
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > }
    > - while(((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE) && (spin++ < 300));
    > + while(((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE) && (spin-- > 0));
    > +
    > + wv_splx(lp, &flags);
    >
    > /* If there was a problem */
    > - if(spin > 300)
    > + if(spin <= 0)
    > {
    > #ifdef DEBUG_CONFIG_ERROR
    > printk(KERN_INFO "%s: wv_ru_stop(): The chip doesn't want to stop...\n",
    > @@ -3287,6 +3285,7 @@ wv_ru_start(device * dev)
    > {
    > ioaddr_t base = dev->base_addr;
    > net_local * lp = (net_local *) dev->priv;
    > + unsigned long flags;
    >
    > #ifdef DEBUG_CONFIG_TRACE
    > printk(KERN_DEBUG "%s: ->wv_ru_start()\n", dev->name);
    > @@ -3300,6 +3299,8 @@ wv_ru_start(device * dev)
    > if(!wv_ru_stop(dev))
    > return FALSE;
    >
    > + wv_splhi(lp, &flags);
    > +
    > /* Now we know that no command is being executed. */
    >
    > /* Set the receive frame pointer and stop pointer */
    > @@ -3309,8 +3310,17 @@ wv_ru_start(device * dev)
    > /* Reset ring management. This sets the receive frame pointer to 1 */
    > outb(OP1_RESET_RING_MNGMT, LCCR(base));
    >
    > +#if 0
    > + /* XXX the i82593 manual page 6-4 seems to indicate that the stop register
    > + should be set as below */
    > + /* outb(CR1_STOP_REG_UPDATE|((RX_SIZE - 0x40)>> RX_SIZE_SHIFT),LCCR(base));*/
    > +#elif 0
    > + /* but I set it 0 instead */
    > + lp->stop = 0;
    > +#else
    > /* but I set it to 3 bytes per packet less than 8K */
    > lp->stop = (0 + RX_SIZE - ((RX_SIZE / 64) * 3)) % RX_SIZE;
    > +#endif
    > outb(CR1_STOP_REG_UPDATE | (lp->stop >> RX_SIZE_SHIFT), LCCR(base));
    > outb(OP1_INT_ENABLE, LCCR(base));
    > outb(OP1_SWIT_TO_PORT_0, LCCR(base));
    > @@ -3326,17 +3336,15 @@ wv_ru_start(device * dev)
    > #ifdef DEBUG_I82593_SHOW
    > {
    > int status;
    > - unsigned long flags;
    > - int i = 0;
    > + int opri;
    > + int spin = 10000;
    >
    > /* spin until the chip starts receiving */
    > do
    > {
    > - spin_lock_irqsave (&lp->lock, flags);
    > outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
    > status = inb(LCSR(base));
    > - spin_unlock_irqrestore (&lp->lock, flags);
    > - if(i++ > 10000)
    > + if(spin-- <= 0)
    > break;
    > }
    > while(((status & SR3_RCV_STATE_MASK) != SR3_RCV_ACTIVE) &&
    > @@ -3345,6 +3353,9 @@ wv_ru_start(device * dev)
    > (status & SR3_RCV_STATE_MASK), i);
    > }
    > #endif
    > +
    > + wv_splx(lp, &flags);
    > +
    > #ifdef DEBUG_CONFIG_TRACE
    > printk(KERN_DEBUG "%s: <-wv_ru_start()\n", dev->name);
    > #endif
    > @@ -3363,6 +3374,7 @@ wv_82593_config(device * dev)
    > ioaddr_t base = dev->base_addr;
    > net_local * lp = (net_local *) dev->priv;
    > struct i82593_conf_block cfblk;
    > + int ret = TRUE;
    >
    > #ifdef DEBUG_CONFIG_TRACE
    > printk(KERN_DEBUG "%s: ->wv_82593_config()\n", dev->name);
    > @@ -3457,7 +3469,7 @@ wv_82593_config(device * dev)
    > hacr_write(base, HACR_DEFAULT);
    > if(!wv_82593_cmd(dev, "wv_82593_config(): configure",
    > OP0_CONFIGURE, SR0_CONFIGURE_DONE))
    > - return(FALSE);
    > + ret = FALSE;
    >
    > /* Initialize adapter's ethernet MAC address */
    > outb(TX_BASE & 0xff, PIORL(base));
    > @@ -3471,7 +3483,7 @@ wv_82593_config(device * dev)
    > hacr_write(base, HACR_DEFAULT);
    > if(!wv_82593_cmd(dev, "wv_82593_config(): ia-setup",
    > OP0_IA_SETUP, SR0_IA_SETUP_DONE))
    > - return(FALSE);
    > + ret = FALSE;
    >
    > #ifdef WAVELAN_ROAMING
    > /* If roaming is enabled, join the "Beacon Request" multicast group... */
    > @@ -3508,14 +3520,17 @@ wv_82593_config(device * dev)
    > hacr_write(base, HACR_DEFAULT);
    > if(!wv_82593_cmd(dev, "wv_82593_config(): mc-setup",
    > OP0_MC_SETUP, SR0_MC_SETUP_DONE))
    > - return(FALSE);
    > + ret = FALSE;
    > lp->mc_count = dev->mc_count; /* remember to avoid repeated reset */
    > }
    >
    > + /* Job done, clear the flag */
    > + lp->reconfig_82593 = FALSE;
    > +
    > #ifdef DEBUG_CONFIG_TRACE
    > printk(KERN_DEBUG "%s: <-wv_82593_config()\n", dev->name);
    > #endif
    > - return(TRUE);
    > + return(ret);
    > }
    >
    > /*------------------------------------------------------------------*/
    > @@ -3594,6 +3609,8 @@ wv_hw_config(device * dev)
    > {
    > net_local * lp = (net_local *) dev->priv;
    > ioaddr_t base = dev->base_addr;
    > + unsigned long flags;
    > + int ret = FALSE;
    >
    > #ifdef DEBUG_CONFIG_TRACE
    > printk(KERN_DEBUG "%s: ->wv_hw_config()\n", dev->name);
    > @@ -3612,50 +3629,78 @@ wv_hw_config(device * dev)
    > if(wv_pcmcia_reset(dev) == FALSE)
    > return FALSE;
    >
    > - /* Power UP the module + reset the modem + reset host adapter
    > - * (in fact, reset DMA channels) */
    > - hacr_write_slow(base, HACR_RESET);
    > - hacr_write(base, HACR_DEFAULT);
    > + /* Disable interrupts */
    > + wv_splhi(lp, &flags);
    >
    > - /* Check if the module has been powered up... */
    > - if(hasr_read(base) & HASR_NO_CLK)
    > + /* Disguised goto ;-) */
    > + do
    > {
    > + /* Power UP the module + reset the modem + reset host adapter
    > + * (in fact, reset DMA channels) */
    > + hacr_write_slow(base, HACR_RESET);
    > + hacr_write(base, HACR_DEFAULT);
    > +
    > + /* Check if the module has been powered up... */
    > + if(hasr_read(base) & HASR_NO_CLK)
    > + {
    > #ifdef DEBUG_CONFIG_ERRORS
    > - printk(KERN_WARNING "%s: wv_hw_config(): modem not connected or not a wavelan card\n",
    > - dev->name);
    > + printk(KERN_WARNING "%s: wv_hw_config(): modem not connected or not a wavelan card\n",
    > + dev->name);
    > #endif
    > - return FALSE;
    > - }
    > + break;
    > + }
    >
    > - /* initialize the modem */
    > - if(wv_mmc_init(dev) == FALSE)
    > - return FALSE;
    > + /* initialize the modem */
    > + if(wv_mmc_init(dev) == FALSE)
    > + {
    > +#ifdef DEBUG_CONFIG_ERRORS
    > + printk(KERN_WARNING "%s: wv_hw_config(): Can't configure the modem\n",
    > + dev->name);
    > +#endif
    > + break;
    > + }
    >
    > - /* reset the LAN controller (i82593) */
    > - outb(OP0_RESET, LCCR(base));
    > - mdelay(1); /* A bit crude ! */
    > -
    > - /* Initialize the LAN controller */
    > - if((wv_82593_config(dev) == FALSE) ||
    > - (wv_diag(dev) == FALSE))
    > - {
    > + /* reset the LAN controller (i82593) */
    > + outb(OP0_RESET, LCCR(base));
    > + mdelay(1); /* A bit crude ! */
    > +
    > + /* Initialize the LAN controller */
    > + if(wv_82593_config(dev) == FALSE)
    > + {
    > #ifdef DEBUG_CONFIG_ERRORS
    > - printk(KERN_INFO "%s: wv_hw_config(): i82593 init failed\n", dev->name);
    > + printk(KERN_INFO "%s: wv_hw_config(): i82593 init failed\n",
    > + dev->name);
    > #endif
    > - return FALSE;
    > - }
    > + break;
    > + }
    >
    > - /*
    > - * insert code for loopback test here
    > - */
    > + /* Diagnostic */
    > + if(wv_diag(dev) == FALSE)
    > + {
    > +#ifdef DEBUG_CONFIG_ERRORS
    > + printk(KERN_INFO "%s: wv_hw_config(): i82593 diagnostic failed\n",
    > + dev->name);
    > +#endif
    > + break;
    > + }
    >
    > - /* The device is now configured */
    > - lp->configured = 1;
    > + /*
    > + * insert code for loopback test here
    > + */
    > +
    > + /* The device is now configured */
    > + lp->configured = 1;
    > + ret = TRUE;
    > + }
    > + while(0);
    > +
    > + /* Re-enable interrupts */
    > + wv_splx(lp, &flags);
    >
    > #ifdef DEBUG_CONFIG_TRACE
    > printk(KERN_DEBUG "%s: <-wv_hw_config()\n", dev->name);
    > #endif
    > - return TRUE;
    > + return(ret);
    > }
    >
    > /*------------------------------------------------------------------*/
    > @@ -3675,10 +3720,6 @@ wv_hw_reset(device * dev)
    > printk(KERN_DEBUG "%s: ->wv_hw_reset()\n", dev->name);
    > #endif
    >
    > - /* If watchdog was activated, kill it ! */
    > - if (timer_pending(&lp->watchdog))
    > - del_timer(&lp->watchdog);
    > -
    > lp->nresets++;
    > lp->configured = 0;
    >
    > @@ -3786,13 +3827,13 @@ wv_pcmcia_config(dev_link_t * link)
    > }
    >
    > /*
    > - * Allocate a 4K memory window. Note that the dev_link_t
    > + * Allocate a small memory window. Note that the dev_link_t
    > * structure provides space for one window handle -- if your
    > * device needs several windows, you'll need to keep track of
    > * the handles in your private data structure, link->priv.
    > */
    > req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
    > - req.Base = 0; req.Size = 0x1000;
    > + req.Base = req.Size = 0;
    > req.AccessSpeed = mem_speed;
    > link->win = (window_handle_t)link->handle;
    > i = CardServices(RequestWindow, &link->win, &req);
    > @@ -3803,7 +3844,7 @@ wv_pcmcia_config(dev_link_t * link)
    > }
    >
    > dev->rmem_start = dev->mem_start =
    > - (u_long)ioremap(req.Base, 0x1000);
    > + (u_long)ioremap(req.Base, req.Size);
    > dev->rmem_end = dev->mem_end = dev->mem_start + req.Size;
    >
    > mem.CardOffset = 0; mem.Page = 0;
    > @@ -3817,7 +3858,7 @@ wv_pcmcia_config(dev_link_t * link)
    > /* Feed device with this info... */
    > dev->irq = link->irq.AssignedIRQ;
    > dev->base_addr = link->io.BasePort1;
    > - netif_start_queue (dev);
    > + netif_start_queue(dev);
    >
    > #ifdef DEBUG_CONFIG_INFO
    > printk(KERN_DEBUG "wv_pcmcia_config: MEMSTART 0x%x IRQ %d IOPORT 0x%x\n",
    > @@ -3843,7 +3884,7 @@ wv_pcmcia_config(dev_link_t * link)
    > return FALSE;
    > }
    >
    > - /* XXX Could you explain me this, Dave ? */
    > + strcpy(((net_local *) dev->priv)->node.dev_name, dev->name);
    > link->dev = &((net_local *) dev->priv)->node;
    >
    > #ifdef DEBUG_CONFIG_TRACE
    > @@ -3887,7 +3928,7 @@ wv_pcmcia_release(u_long arg) /* Address
    > CardServices(ReleaseIO, link->handle, &link->io);
    > CardServices(ReleaseIRQ, link->handle, &link->irq);
    >
    > - link->state &= ~(DEV_CONFIG | DEV_RELEASE_PENDING | DEV_STALE_CONFIG);
    > + link->state &= ~(DEV_CONFIG | DEV_STALE_CONFIG);
    >
    > #ifdef DEBUG_CONFIG_TRACE
    > printk(KERN_DEBUG "%s: <- wv_pcmcia_release()\n", dev->name);
    > @@ -3896,7 +3937,7 @@ wv_pcmcia_release(u_long arg) /* Address
    >
    > /*------------------------------------------------------------------*/
    > /*
    > - * Sometimes, netwave_detach can't be performed following a call from
    > + * Sometimes, wavelan_detach can't be performed following a call from
    > * cardmgr (device still open, pcmcia_release not done) and the device
    > * is put in a STALE_LINK state and remains in memory.
    > *
    > @@ -3970,7 +4011,19 @@ wavelan_interrupt(int irq,
    > lp = (net_local *) dev->priv;
    > base = dev->base_addr;
    >
    > - spin_lock (&lp->lock);
    > +#ifdef DEBUG_INTERRUPT_INFO
    > + /* Check state of our spinlock (it should be cleared) */
    > + if(spin_is_locked(&lp->spinlock))
    > + printk(KERN_DEBUG
    > + "%s: wavelan_interrupt(): spinlock is already locked !!!\n",
    > + dev->name);
    > +#endif
    > +
    > + /* Prevent reentrancy. We need to do that because we may have
    > + * multiple interrupt handler running concurently.
    > + * It is safe because wv_splhi() disable interrupts before aquiring
    > + * the spinlock. */
    > + spin_lock(&lp->spinlock);
    >
    > /* Treat all pending interrupts */
    > while(1)
    > @@ -4015,8 +4068,6 @@ wavelan_interrupt(int irq,
    > break;
    > }
    >
    > - lp->status = status0; /* Save current status (for commands) */
    > -
    > /* ----------------- RECEIVING PACKET ----------------- */
    > /*
    > * When the wavelan signal the reception of a new packet,
    > @@ -4054,22 +4105,6 @@ wavelan_interrupt(int irq,
    > * Most likely : transmission done
    > */
    >
    > - /* If we are already waiting elsewhere for the command to complete */
    > - if(wv_wait_completed)
    > - {
    > -#ifdef DEBUG_INTERRUPT_INFO
    > - printk(KERN_DEBUG "%s: wv_interrupt(): command completed\n",
    > - dev->name);
    > -#endif
    > -
    > - /* Signal command completion */
    > - wv_wait_completed = 0;
    > -
    > - /* Acknowledge the interrupt */
    > - outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
    > - continue;
    > - }
    > -
    > /* If a transmission has been done */
    > if((status0 & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
    > (status0 & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
    > @@ -4081,10 +4116,6 @@ wavelan_interrupt(int irq,
    > dev->name);
    > #endif
    >
    > - /* If watchdog was activated, kill it ! */
    > - if(timer_pending(&lp->watchdog))
    > - del_timer(&lp->watchdog);
    > -
    > /* Get transmission status */
    > tx_status = inb(LCSR(base));
    > tx_status |= (inb(LCSR(base)) << 8);
    > @@ -4174,7 +4205,7 @@ wavelan_interrupt(int irq,
    > lp->stats.collisions += (tx_status & TX_NCOL_MASK);
    > lp->stats.tx_packets++;
    >
    > - netif_wake_queue (dev);
    > + netif_wake_queue(dev);
    > outb(CR0_INT_ACK | OP0_NOP, LCCR(base)); /* Acknowledge the interrupt */
    > }
    > else /* if interrupt = transmit done or retransmit done */
    > @@ -4185,9 +4216,9 @@ wavelan_interrupt(int irq,
    > #endif
    > outb(CR0_INT_ACK | OP0_NOP, LCCR(base)); /* Acknowledge the interrupt */
    > }
    > - }
    > + } /* while(1) */
    >
    > - spin_unlock_irq (&lp->lock);
    > + spin_unlock(&lp->spinlock);
    >
    > #ifdef DEBUG_INTERRUPT_TRACE
    > printk(KERN_DEBUG "%s: <-wavelan_interrupt()\n", dev->name);
    > @@ -4196,30 +4227,23 @@ wavelan_interrupt(int irq,
    >
    > /*------------------------------------------------------------------*/
    > /*
    > - * Watchdog : when we start a transmission, we set a timer in the
    > - * kernel. If the transmission complete, this timer is disabled. If
    > - * it expire, it try to unlock the hardware.
    > + * Watchdog: when we start a transmission, a timer is set for us in the
    > + * kernel. If the transmission completes, this timer is disabled. If
    > + * the timer expires, we are called and we try to unlock the hardware.
    > *
    > - * Note : this watchdog doesn't work on the same principle as the
    > - * watchdog in the ISA driver. I make it this way because the overhead
    > - * of add_timer() and del_timer() is nothing and that it avoid calling
    > - * the watchdog, saving some CPU... If you want to apply the same
    > - * watchdog to the ISA driver, you should be a bit carefull, because
    > - * of the many transmit buffers...
    > - * This watchdog is also move clever, it try to abort the current
    > - * command before reseting everything...
    > + * Note : This watchdog is move clever than the one in the ISA driver,
    > + * because it try to abort the current command before reseting
    > + * everything...
    > + * On the other hand, it's a bit simpler, because we don't have to
    > + * deal with the multiple Tx buffers...
    > */
    > static void
    > -wavelan_watchdog(u_long a)
    > +wavelan_watchdog(device * dev)
    > {
    > - device * dev;
    > - net_local * lp;
    > - ioaddr_t base;
    > - int spin;
    > -
    > - dev = (device *) a;
    > - base = dev->base_addr;
    > - lp = (net_local *) dev->priv;
    > + net_local * lp = (net_local *) dev->priv;
    > + ioaddr_t base = dev->base_addr;
    > + unsigned long flags;
    > + int aborted = FALSE;
    >
    > #ifdef DEBUG_INTERRUPT_TRACE
    > printk(KERN_DEBUG "%s: ->wavelan_watchdog()\n", dev->name);
    > @@ -4230,21 +4254,21 @@ wavelan_watchdog(u_long a)
    > dev->name);
    > #endif
    >
    > - /* We are waiting for command completion */
    > - wv_wait_completed = TRUE;
    > + wv_splhi(lp, &flags);
    >
    > /* Ask to abort the current command */
    > outb(OP0_ABORT, LCCR(base));
    >
    > - /* Busy wait while the LAN controller executes the command.
    > - * Note : wv_wait_completed should be volatile */
    > - spin = 0;
    > - while(wv_wait_completed && (spin++ < 250))
    > - udelay(10);
    > -
    > - /* If the interrupt handler hasn't be called or invalid status */
    > - if((wv_wait_completed) ||
    > - ((lp->status & SR0_EVENT_MASK) != SR0_EXECUTION_ABORTED))
    > + /* Wait for the end of the command (a bit hackish) */
    > + if(wv_82593_cmd(dev, "wavelan_watchdog(): abort",
    > + OP0_NOP | CR0_STATUS_3, SR0_EXECUTION_ABORTED))
    > + aborted = TRUE;
    > +
    > + /* Release spinlock here so that wv_hw_reset() can grab it */
    > + wv_splx(lp, &flags);
    > +
    > + /* Check if we were successful in aborting it */
    > + if(!aborted)
    > {
    > /* It seem that it wasn't enough */
    > #ifdef DEBUG_INTERRUPT_ERROR
    > @@ -4269,7 +4293,7 @@ wavelan_watchdog(u_long a)
    > #endif
    >
    > /* We are no more waiting for something... */
    > - netif_start_queue (dev);
    > + netif_wake_queue(dev);
    >
    > #ifdef DEBUG_INTERRUPT_TRACE
    > printk(KERN_DEBUG "%s: <-wavelan_watchdog()\n", dev->name);
    > @@ -4322,7 +4346,7 @@ wavelan_open(device * dev)
    > return FALSE;
    > if(!wv_ru_start(dev))
    > wv_hw_reset(dev); /* If problem : reset */
    > - netif_start_queue (dev);
    > + netif_start_queue(dev);
    >
    > /* Mark the device as used */
    > link->open++;
    > @@ -4348,7 +4372,6 @@ static int
    > wavelan_close(device * dev)
    > {
    > dev_link_t * link = ((net_local *) dev->priv)->link;
    > - net_local * lp = (net_local *)dev->priv;
    > ioaddr_t base = dev->base_addr;
    >
    > #ifdef DEBUG_CALLBACK_TRACE
    > @@ -4356,8 +4379,6 @@ wavelan_close(device * dev)
    > (unsigned int) dev);
    > #endif
    >
    > - netif_stop_queue (dev);
    > -
    > /* If the device isn't open, then nothing to do */
    > if(!link->open)
    > {
    > @@ -4373,17 +4394,13 @@ wavelan_close(device * dev)
    > wv_roam_cleanup(dev);
    > #endif /* WAVELAN_ROAMING */
    >
    > - /* If watchdog was activated, kill it ! */
    > - if(timer_pending(&lp->watchdog))
    > - del_timer(&lp->watchdog);
    > -
    > link->open--;
    > MOD_DEC_USE_COUNT;
    >
    > /* If the card is still present */
    > - if (netif_device_present(dev))
    > + if(netif_running(dev))
    > {
    > - netif_stop_queue (dev);
    > + netif_stop_queue(dev);
    >
    > /* Stop receiving new messages and wait end of transmission */
    > wv_ru_stop(dev);
    > @@ -4404,21 +4421,6 @@ wavelan_close(device * dev)
    >
    > /*------------------------------------------------------------------*/
    > /*
    > - * We never need to do anything when a wavelan device is "initialized"
    > - * by the net software, because we only register already-found cards.
    > - */
    > -static int
    > -wavelan_init(device * dev)
    > -{
    > -#ifdef DEBUG_CALLBACK_TRACE
    > - printk(KERN_DEBUG "<>wavelan_init()\n");
    > -#endif
    > -
    > - return(0);
    > -}
    > -
    > -/*------------------------------------------------------------------*/
    > -/*
    > * wavelan_attach() creates an "instance" of the driver, allocating
    > * local data structures for one device (one interface). The device
    > * is registered with Card Services.
    > @@ -4445,24 +4447,8 @@ wavelan_attach(void)
    >
    > /* Initialize the dev_link_t structure */
    > link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL);
    > - if (!link)
    > - return NULL;
    > -
    > - /* Allocate the generic data structure */
    > - dev = kmalloc(sizeof(struct net_device), GFP_KERNEL);
    > - if (!dev)
    > - goto fail_alloc_dev;
    > -
    > - /* Allocate the wavelan-specific data structure. */
    > - lp = (net_local *) kmalloc(sizeof(net_local), GFP_KERNEL);
    > - if (!lp)
    > - goto fail_alloc_dev_priv;
    > -
    > - memset(lp, 0, sizeof(net_local));
    > + if (!link) return NULL;
    > memset(link, 0, sizeof(struct dev_link_t));
    > - memset(dev, 0, sizeof(struct net_device));
    > -
    > - dev->priv = lp;
    >
    > /* Unused for the Wavelan */
    > link->release.function = &wv_pcmcia_release;
    > @@ -4492,18 +4478,35 @@ wavelan_attach(void)
    > link->next = dev_list;
    > dev_list = link;
    >
    > + /* Allocate the generic data structure */
    > + dev = kmalloc(sizeof(struct net_device), GFP_KERNEL);
    > + if (!dev) {
    > + kfree(link);
    > + return NULL;
    > + }
    > + memset(dev, 0x00, sizeof(struct net_device));
    > link->priv = link->irq.Instance = dev;
    >
    > + /* Allocate the wavelan-specific data structure. */
    > + dev->priv = lp = (net_local *) kmalloc(sizeof(net_local), GFP_KERNEL);
    > + if (!lp) {
    > + kfree(link);
    > + kfree(dev);
    > + return NULL;
    > + }
    > + memset(lp, 0x00, sizeof(net_local));
    > +
    > /* Init specific data */
    > - wv_wait_completed = 0;
    > - lp->status = FALSE;
    > lp->configured = 0;
    > lp->reconfig_82593 = FALSE;
    > lp->nresets = 0;
    > + /* Multicast stuff */
    > + lp->promiscuous = 0;
    > + lp->allmulticast = 0;
    > + lp->mc_count = 0;
    >
    > - /* Set the watchdog timer */
    > - lp->watchdog.function = wavelan_watchdog;
    > - lp->watchdog.data = (unsigned long) dev;
    > + /* Init spinlock */
    > + spin_lock_init(&lp->spinlock);
    >
    > /* back links */
    > lp->link = link;
    > @@ -4513,7 +4516,6 @@ wavelan_attach(void)
    > ether_setup(dev);
    >
    > /* wavelan NET3 callbacks */
    > - dev->init = &wavelan_init;
    > dev->open = &wavelan_open;
    > dev->stop = &wavelan_close;
    > dev->hard_start_xmit = &wavelan_packet_xmit;
    > @@ -4523,14 +4525,16 @@ wavelan_attach(void)
    > dev->set_mac_address = &wavelan_set_mac_address;
    > #endif /* SET_MAC_ADDRESS */
    >
    > + /* Set the watchdog timer */
    > + dev->tx_timeout = &wavelan_watchdog;
    > + dev->watchdog_timeo = WATCHDOG_JIFFIES;
    > +
    > #ifdef WIRELESS_EXT /* If wireless extension exist in the kernel */
    > dev->do_ioctl = wavelan_ioctl; /* wireless extensions */
    > dev->get_wireless_stats = wavelan_get_wireless_stats;
    > #endif
    >
    > /* Other specific data */
    > - strcpy(dev->name, ((net_local *)dev->priv)->node.dev_name);
    > - netif_start_queue (dev);
    > dev->mtu = WAVELAN_MTU;
    >
    > /* Register with Card Services */
    > @@ -4562,12 +4566,6 @@ wavelan_attach(void)
    > #endif
    >
    > return link;
    > -
    > -fail_alloc_dev_priv:
    > - kfree(dev);
    > -fail_alloc_dev:
    > - kfree(link);
    > - return NULL;
    > }
    >
    > /*------------------------------------------------------------------*/
    > @@ -4698,7 +4696,7 @@ wavelan_event(event_t event, /* The ev
    > if(link->state & DEV_CONFIG)
    > {
    > /* Accept no more transmissions */
    > - netif_device_detach(dev);
    > + netif_device_detach(dev);
    >
    > /* Release the card */
    > wv_pcmcia_release((u_long) link);
    > @@ -4720,7 +4718,7 @@ wavelan_event(event_t event, /* The ev
    > * obliged to close nicely the wavelan here. David, could you
    > * close the device before suspending them ? And, by the way,
    > * could you, on resume, add a "route add -net ..." after the
    > - * ifconfig up XXX Thanks... */
    > + * ifconfig up ??? Thanks... */
    >
    > /* Stop receiving new messages and wait end of transmission */
    > wv_ru_stop(dev);
    > @@ -4735,8 +4733,7 @@ wavelan_event(event_t event, /* The ev
    > if(link->state & DEV_CONFIG)
    > {
    > if(link->open)
    > - netif_device_detach(dev);
    > -
    > + netif_device_detach(dev);
    > CardServices(ReleaseConfiguration, link->handle);
    > }
    > break;
    > @@ -4748,7 +4745,7 @@ wavelan_event(event_t event, /* The ev
    > if(link->state & DEV_CONFIG)
    > {
    > CardServices(RequestConfiguration, link->handle, &link->conf);
    > - if(link->open) /* If RESET -> True, If RESUME -> False XXX */
    > + if(link->open) /* If RESET -> True, If RESUME -> False ??? */
    > {
    > wv_hw_reset(dev);
    > netif_device_attach(dev);
    > @@ -4838,4 +4835,3 @@ exit_wavelan_cs(void)
    >
    > module_init(init_wavelan_cs);
    > module_exit(exit_wavelan_cs);
    > -MODULE_LICENSE("Dual BSD/GPL");
    > diff -u -p -r linux/drivers/net/pcmcia-buggy/wavelan_cs.h linux/drivers/net/pcmcia/wavelan_cs.h
    > --- linux/drivers/net/pcmcia-buggy/wavelan_cs.h Tue Jan 8 17:27:48 2002
    > +++ linux/drivers/net/pcmcia/wavelan_cs.h Fri Jan 11 14:58:25 2002
    > @@ -34,6 +34,25 @@
    > * I try to maintain a web page with the Wireless LAN Howto at :
    > * http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/Wavelan.html
    > *
    > + * SMP
    > + * ---
    > + * We now are SMP compliant (I eventually fixed the remaining bugs).
    > + * The driver has been tested on a dual P6-150 and survived my usual
    > + * set of torture tests.
    > + * Anyway, I spent enough time chasing interrupt re-entrancy during
    > + * errors or reconfigure, and I designed the locked/unlocked sections
    > + * of the driver with great care, and with the recent addition of
    > + * the spinlock (thanks to the new API), we should be quite close to
    > + * the truth.
    > + * The SMP/IRQ locking is quite coarse and conservative (i.e. not fast),
    > + * but better safe than sorry (especially at 2 Mb/s ;-).
    > + *
    > + * I have also looked into disabling only our interrupt on the card
    > + * (via HACR) instead of all interrupts in the processor (via cli),
    > + * so that other driver are not impacted, and it look like it's
    > + * possible, but it's very tricky to do right (full of races). As
    > + * the gain would be mostly for SMP systems, it can wait...
    > + *
    > * Debugging and options
    > * ---------------------
    > * You will find below a set of '#define" allowing a very fine control
    > @@ -122,7 +141,7 @@
    > * Yunzhou Li <yunzhou@strat.iol.unh.edu> finished is work.
    > * Joe Finney <joe@comp.lancs.ac.uk> patched the driver to start
    > * correctly 2.00 cards (2.4 GHz with frequency selection).
    > - * David Hinds <dhinds@pcmcia.sourceforge.org> integrated the whole in his
    > + * David Hinds <dahinds@users.sourceforge.net> integrated the whole in his
    > * Pcmcia package (+ bug corrections).
    > *
    > * I (Jean Tourrilhes - jt@hplb.hpl.hp.com) then started to make some
    > @@ -158,8 +177,8 @@
    > *
    > * This software was originally developed under Linux 1.2.3
    > * (Slackware 2.0 distribution).
    > - * And then under Linux 2.0.x (Debian 1.1 - pcmcia 2.8.18-23) with
    > - * HP OmniBook 4000 & 5500.
    > + * And then under Linux 2.0.x (Debian 1.1 -> 2.2 - pcmcia 2.8.18+)
    > + * with an HP OmniBook 4000 and then a 5500.
    > *
    > * It is based on other device drivers and information either written
    > * or supplied by:
    > @@ -174,7 +193,7 @@
    > * Matthew Geier (matthew@cs.su.oz.au),
    > * Remo di Giovanni (remo@cs.su.oz.au),
    > * Mark Hagan (mhagan@wtcpost.daytonoh.NCR.COM),
    > - * David Hinds <dhinds@pcmcia.sourceforge.org>,
    > + * David Hinds <dahinds@users.sourceforge.net>,
    > * Jan Hoogendoorn (c/o marteijn@lucent.com),
    > * Bruce Janson <bruce@cs.usyd.edu.au>,
    > * Anthony D. Joseph <adj@lcs.mit.edu>,
    > @@ -349,6 +368,32 @@
    > * - Fix check for root permission (break instead of exit)
    > * - New nwid & encoding setting (Wireless Extension 9)
    > *
    > + * Changes made for release in 3.1.12 :
    > + * ----------------------------------
    > + * - reworked wv_82593_cmd to avoid using the IRQ handler and doing
    > + * ugly things with interrupts.
    > + * - Add IRQ protection in 82593_config/ru_start/ru_stop/watchdog
    > + * - Update to new network API (softnet - 2.3.43) :
    > + * o replace dev->tbusy (David + me)
    > + * o replace dev->tstart (David + me)
    > + * o remove dev->interrupt (David)
    > + * o add SMP locking via spinlock in splxx (me)
    > + * o add spinlock in interrupt handler (me)
    > + * o use kernel watchdog instead of ours (me)
    > + * o verify that all the changes make sense and work (me)
    > + * - Re-sync kernel/pcmcia versions (not much actually)
    > + * - A few other cleanups (David & me)...
    > + *
    > + * Changes made for release in 3.1.22 :
    > + * ----------------------------------
    > + * - Check that SMP works, remove annoying log message
    > + *
    > + * Changes made for release in 3.1.24 :
    > + * ----------------------------------
    > + * - Fix unfrequent card lockup when watchdog was reseting the hardware :
    > + * o control first busy loop in wv_82593_cmd()
    > + * o Extend spinlock protection in wv_hw_config()
    > + *
    > * Wishes & dreams:
    > * ----------------
    > * - Cleanup and integrate the roaming code
    > @@ -368,6 +413,7 @@
    > #include <linux/string.h>
    > #include <linux/timer.h>
    > #include <linux/interrupt.h>
    > +#include <linux/spinlock.h>
    > #include <linux/in.h>
    > #include <linux/delay.h>
    > #include <asm/uaccess.h>
    > @@ -384,7 +430,7 @@
    >
    > #ifdef CONFIG_NET_PCMCIA_RADIO
    > #include <linux/wireless.h> /* Wireless extensions */
    > -#endif /* CONFIG_NET_PCMCIA_RADIO */
    > +#endif
    >
    > /* Pcmcia headers that we need */
    > #include <pcmcia/cs_types.h>
    > @@ -437,7 +483,7 @@
    > #undef DEBUG_RX_INFO /* Header of the transmitted packet */
    > #undef DEBUG_RX_FAIL /* Normal failure conditions */
    > #define DEBUG_RX_ERROR /* Unexpected conditions */
    > -#undef DEBUG_PACKET_DUMP /* Dump packet on the screen */
    > +#undef DEBUG_PACKET_DUMP 32 /* Dump packet on the screen */
    > #undef DEBUG_IOCTL_TRACE /* Misc call by Linux */
    > #undef DEBUG_IOCTL_INFO /* Various debug info */
    > #define DEBUG_IOCTL_ERROR /* What's going wrong */
    > @@ -452,7 +498,7 @@
    > /************************ CONSTANTS & MACROS ************************/
    >
    > #ifdef DEBUG_VERSION_SHOW
    > -static const char *version = "wavelan_cs.c : v21 (wireless extensions) 18/10/99\n";
    > +static const char *version = "wavelan_cs.c : v23 (SMP + wireless extensions) 20/12/00\n";
    > #endif
    >
    > /* Watchdog temporisation */
    > @@ -557,9 +603,9 @@ typedef u_char mac_addr[WAVELAN_ADDR_SI
    > */
    > struct net_local
    > {
    > - spinlock_t lock;
    > dev_node_t node; /* ???? What is this stuff ???? */
    > device * dev; /* Reverse link... */
    > + spinlock_t spinlock; /* Serialize access to the hardware (SMP) */
    > dev_link_t * link; /* pcmcia structure */
    > en_stats stats; /* Ethernet interface statistics */
    > int nresets; /* Number of hw resets */
    > @@ -568,9 +614,7 @@ struct net_local
    > u_char promiscuous; /* Promiscuous mode */
    > u_char allmulticast; /* All Multicast mode */
    > int mc_count; /* Number of multicast addresses */
    > - timer_list watchdog; /* To avoid blocking state */
    >
    > - u_char status; /* Current i82593 status */
    > int stop; /* Current i82593 Stop Hit Register */
    > int rfp; /* Last DMA machine receive pointer */
    > int overrunning; /* Receiver overrun flag */
    > @@ -617,8 +661,14 @@ void wv_roam_cleanup(struct net_device *
    > #endif /* WAVELAN_ROAMING */
    >
    > /* ----------------------- MISC SUBROUTINES ------------------------ */
    > +static inline void
    > + wv_splhi(net_local *, /* Disable interrupts */
    > + unsigned long *); /* flags */
    > +static inline void
    > + wv_splx(net_local *, /* ReEnable interrupts */
    > + unsigned long *); /* flags */
    > static void
    > - cs_error(client_handle_t, /* Report error to cardmgr */
    > + cs_error(client_handle_t, /* Report error to cardmgr */
    > int,
    > int);
    > /* ----------------- MODEM MANAGEMENT SUBROUTINES ----------------- */
    > @@ -722,16 +772,15 @@ static void
    > wv_flush_stale_links(void); /* "detach" all possible devices */
    > /* ---------------------- INTERRUPT HANDLING ---------------------- */
    > static void
    > -wavelan_interrupt(int, /* Interrupt handler */
    > - void *,
    > - struct pt_regs *);
    > + wavelan_interrupt(int, /* Interrupt handler */
    > + void *,
    > + struct pt_regs *);
    > static void
    > - wavelan_watchdog(u_long); /* Transmission watchdog */
    > + wavelan_watchdog(device *); /* Transmission watchdog */
    > /* ------------------- CONFIGURATION CALLBACKS ------------------- */
    > static int
    > wavelan_open(device *), /* Open the device */
    > - wavelan_close(device *), /* Close the device */
    > - wavelan_init(device *); /* Do nothing */
    > + wavelan_close(device *); /* Close the device */
    > static dev_link_t *
    > wavelan_attach(void); /* Create a new device */
    > static void
    > @@ -744,11 +793,7 @@ static int
    > /**************************** VARIABLES ****************************/
    >
    > static dev_info_t dev_info = "wavelan_cs";
    > -static dev_link_t *dev_list; /* Linked list of devices */
    > -
    > -/* WARNING : the following variable MUST be volatile
    > - * It is used by wv_82593_cmd to syncronise with wavelan_interrupt */
    > -static volatile int wv_wait_completed;
    > +static dev_link_t *dev_list = NULL; /* Linked list of devices */
    >
    > /*
    > * Parameters that can be set with 'insmod'
    > @@ -761,7 +806,7 @@ static int irq_mask = 0xdeb8;
    > static int irq_list[4] = { -1 };
    >
    > /* Shared memory speed, in ns */
    > -static int mem_speed;
    > +static int mem_speed = 0;
    >
    > /* New module interface */
    > MODULE_PARM(irq_mask, "i");
    > @@ -770,9 +815,11 @@ MODULE_PARM(mem_speed, "i");
    >
    > #ifdef WAVELAN_ROAMING /* Conditional compile, see above in options */
    > /* Enable roaming mode ? No ! Please keep this to 0 */
    > -static int do_roaming;
    > +static int do_roaming = 0;
    > MODULE_PARM(do_roaming, "i");
    > #endif /* WAVELAN_ROAMING */
    > +
    > +MODULE_LICENSE("GPL");
    >
    > #endif /* WAVELAN_CS_H */
    >
    > -
    > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    > the body of a message to majordomo@vger.kernel.org
    > More majordomo info at http://vger.kernel.org/majordomo-info.html
    > Please read the FAQ at http://www.tux.org/lkml/
    >

    --
    --------------------------------------------------------------------------
    Joel Jaeggli Academic User Services joelja@darkwing.uoregon.edu
    -- PGP Key Fingerprint: 1DE9 8FCA 51FB 4195 B42A 9C32 A30D 121E --
    The accumulation of all powers, legislative, executive, and judiciary, in
    the same hands, whether of one, a few, or many, and whether hereditary,
    selfappointed, or elective, may justly be pronounced the very definition of
    tyranny. - James Madison, Federalist Papers 47 - Feb 1, 1788


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-03-22 13:15    [W:0.180 / U:59.020 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site