pcnet_cs: add cis of PreMax PE-200 ethernet pcmcia card
[linux-2.6.git] / drivers / net / 3c527.c
index 157eda5..6021e6d 100644 (file)
@@ -1,7 +1,7 @@
 /* 3c527.c: 3Com Etherlink/MC32 driver for Linux 2.4 and 2.6.
  *
  *     (c) Copyright 1998 Red Hat Software Inc
- *     Written by Alan Cox. 
+ *     Written by Alan Cox.
  *     Further debugging by Carl Drougge.
  *      Initial SMP support by Felipe W Damasio <felipewd@terra.com.br>
  *      Heavily modified by Richard Procter <rnp@paradise.net.nz>
@@ -30,12 +30,12 @@ DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.
  *     The diagram (Figure 1-1) and the POS summary disagree with the
  *     "Interrupt Level" section in the manual.
  *
- *     The manual contradicts itself when describing the minimum number 
- *     buffers in the 'configure lists' command. 
- *     My card accepts a buffer config of 4/4. 
+ *     The manual contradicts itself when describing the minimum number
+ *     buffers in the 'configure lists' command.
+ *     My card accepts a buffer config of 4/4.
  *
  *     Setting the SAV BP bit does not save bad packets, but
- *     only enables RX on-card stats collection. 
+ *     only enables RX on-card stats collection.
  *
  *     The documentation in places seems to miss things. In actual fact
  *     I've always eventually found everything is documented, it just
@@ -64,16 +64,16 @@ DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.
  *     received frames exceeding a configurable length are passed
  *     directly to the higher networking layers without incuring a copy,
  *     in what amounts to a time/space trade-off.
- *      
+ *
  *     The card also keeps a large amount of statistical information
  *     on-board. In a perfect world, these could be used safely at no
  *     cost. However, lacking information to the contrary, processing
  *     them without races would involve so much extra complexity as to
  *     make it unworthwhile to do so. In the end, a hybrid SW/HW
- *     implementation was made necessary --- see mc32_update_stats().  
+ *     implementation was made necessary --- see mc32_update_stats().
  *
  * DOC: Notes
- *     
+ *
  *     It should be possible to use two or more cards, but at this stage
  *     only by loading two copies of the same module.
  *
@@ -103,8 +103,8 @@ DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.
 #include <linux/ethtool.h>
 #include <linux/completion.h>
 #include <linux/bitops.h>
+#include <linux/semaphore.h>
 
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/io.h>
@@ -125,47 +125,44 @@ static const char* cardname = DRV_NAME;
 #define NET_DEBUG 2
 #endif
 
-#undef DEBUG_IRQ
-
 static unsigned int mc32_debug = NET_DEBUG;
 
 /* The number of low I/O ports used by the ethercard. */
 #define MC32_IO_EXTENT 8
 
-/* As implemented, values must be a power-of-2 -- 4/8/16/32 */ 
+/* As implemented, values must be a power-of-2 -- 4/8/16/32 */
 #define TX_RING_LEN     32       /* Typically the card supports 37  */
 #define RX_RING_LEN     8        /*     "       "        "          */
 
-/* Copy break point, see above for details. 
- * Setting to > 1512 effectively disables this feature.        */          
+/* Copy break point, see above for details.
+ * Setting to > 1512 effectively disables this feature.        */
 #define RX_COPYBREAK    200      /* Value from 3c59x.c */
 
 /* Issue the 82586 workaround command - this is for "busy lans", but
- * basically means for all lans now days - has a performance (latency) 
- * cost, but best set. */ 
+ * basically means for all lans now days - has a performance (latency)
+ * cost, but best set. */
 static const int WORKAROUND_82586=1;
 
 /* Pointers to buffers and their on-card records */
-struct mc32_ring_desc 
+struct mc32_ring_desc
 {
-       volatile struct skb_header *p;                    
-       struct sk_buff *skb;          
+       volatile struct skb_header *p;
+       struct sk_buff *skb;
 };
 
 /* Information that needs to be kept for each board. */
-struct mc32_local 
+struct mc32_local
 {
        int slot;
 
        u32 base;
-       struct net_device_stats net_stats;
        volatile struct mc32_mailbox *rx_box;
        volatile struct mc32_mailbox *tx_box;
        volatile struct mc32_mailbox *exec_box;
         volatile struct mc32_stats *stats;    /* Start of on-card statistics */
         u16 tx_chain;           /* Transmit list start offset */
        u16 rx_chain;           /* Receive list start offset */
-        u16 tx_len;             /* Transmit list count */ 
+        u16 tx_len;             /* Transmit list count */
         u16 rx_len;             /* Receive list count */
 
        u16 xceiver_desired_state; /* HALTED or RUNNING */
@@ -180,7 +177,7 @@ struct mc32_local
        atomic_t tx_ring_head;  /* index to tx en-queue end */
        u16 tx_ring_tail;       /* index to tx de-queue end */
 
-       u16 rx_ring_tail;       /* index to rx de-queue end */ 
+       u16 rx_ring_tail;       /* index to rx de-queue end */
 
        struct semaphore cmd_mutex;    /* Serialises issuing of execute commands */
         struct completion execution_cmd; /* Card has completed an execute command */
@@ -204,7 +201,7 @@ static const struct mca_adapters_t mc32_adapters[] = {
 };
 
 
-/* Macros for ring index manipulations */ 
+/* Macros for ring index manipulations */
 static inline u16 next_rx(u16 rx) { return (rx+1)&(RX_RING_LEN-1); };
 static inline u16 prev_rx(u16 rx) { return (rx-1)&(RX_RING_LEN-1); };
 
@@ -216,13 +213,14 @@ static int        mc32_probe1(struct net_device *dev, int ioaddr);
 static int      mc32_command(struct net_device *dev, u16 cmd, void *data, int len);
 static int     mc32_open(struct net_device *dev);
 static void    mc32_timeout(struct net_device *dev);
-static int     mc32_send_packet(struct sk_buff *skb, struct net_device *dev);
-static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static netdev_tx_t mc32_send_packet(struct sk_buff *skb,
+                                   struct net_device *dev);
+static irqreturn_t mc32_interrupt(int irq, void *dev_id);
 static int     mc32_close(struct net_device *dev);
 static struct  net_device_stats *mc32_get_stats(struct net_device *dev);
 static void    mc32_set_multicast_list(struct net_device *dev);
 static void    mc32_reset_multicast_list(struct net_device *dev);
-static struct ethtool_ops netdev_ethtool_ops;
+static const struct ethtool_ops netdev_ethtool_ops;
 
 static void cleanup_card(struct net_device *dev)
 {
@@ -257,23 +255,21 @@ struct net_device *__init mc32_probe(int unit)
        if (unit >= 0)
                sprintf(dev->name, "eth%d", unit);
 
-       SET_MODULE_OWNER(dev);
-
-       /* Do not check any supplied i/o locations. 
+       /* Do not check any supplied i/o locations.
           POS registers usually don't fail :) */
 
-       /* MCA cards have POS registers.  
-          Autodetecting MCA cards is extremely simple. 
+       /* MCA cards have POS registers.
+          Autodetecting MCA cards is extremely simple.
           Just search for the card. */
 
        for(i = 0; (mc32_adapters[i].name != NULL); i++) {
-               current_mca_slot = 
+               current_mca_slot =
                        mca_find_unused_adapter(mc32_adapters[i].id, 0);
 
                if(current_mca_slot != MCA_NOTFOUND) {
                        if(!mc32_probe1(dev, current_mca_slot))
                        {
-                               mca_set_adapter_name(current_mca_slot, 
+                               mca_set_adapter_name(current_mca_slot,
                                                mc32_adapters[i].name);
                                mca_mark_as_used(current_mca_slot);
                                err = register_netdev(dev);
@@ -284,13 +280,25 @@ struct net_device *__init mc32_probe(int unit)
                                }
                                return dev;
                        }
-                       
+
                }
        }
        free_netdev(dev);
        return ERR_PTR(-ENODEV);
 }
 
+static const struct net_device_ops netdev_ops = {
+       .ndo_open               = mc32_open,
+       .ndo_stop               = mc32_close,
+       .ndo_start_xmit         = mc32_send_packet,
+       .ndo_get_stats          = mc32_get_stats,
+       .ndo_set_multicast_list = mc32_set_multicast_list,
+       .ndo_tx_timeout         = mc32_timeout,
+       .ndo_change_mtu         = eth_change_mtu,
+       .ndo_set_mac_address    = eth_mac_addr,
+       .ndo_validate_addr      = eth_validate_addr,
+};
+
 /**
  * mc32_probe1 -       Check a given slot for a board and test the card
  * @dev:  Device structure to fill in
@@ -298,7 +306,7 @@ struct net_device *__init mc32_probe(int unit)
  *
  * Decode the slot data and configure the card structures. Having done this we
  * can reset the card and configure it. The card does a full self test cycle
- * in firmware so we have to wait for it to return and post us either a 
+ * in firmware so we have to wait for it to return and post us either a
  * failure case or some addresses we use to find the board internals.
  */
 
@@ -342,83 +350,83 @@ static int __init mc32_probe1(struct net_device *dev, int slot)
        /* Time to play MCA games */
 
        if (mc32_debug  &&  version_printed++ == 0)
-               printk(KERN_DEBUG "%s", version);
+               pr_debug("%s", version);
 
-       printk(KERN_INFO "%s: %s found in slot %d:", dev->name, cardname, slot);
+       pr_info("%s: %s found in slot %d: ", dev->name, cardname, slot);
 
        POS = mca_read_stored_pos(slot, 2);
-       
+
        if(!(POS&1))
        {
-               printk(" disabled.\n");
+               pr_cont("disabled.\n");
                return -ENODEV;
        }
 
        /* Fill in the 'dev' fields. */
        dev->base_addr = mca_io_bases[(POS>>1)&7];
        dev->mem_start = mca_mem_bases[(POS>>4)&7];
-       
+
        POS = mca_read_stored_pos(slot, 4);
        if(!(POS&1))
        {
-               printk("memory window disabled.\n");
+               pr_cont("memory window disabled.\n");
                return -ENODEV;
        }
 
        POS = mca_read_stored_pos(slot, 5);
-       
+
        i=(POS>>4)&3;
        if(i==3)
        {
-               printk("invalid memory window.\n");
+               pr_cont("invalid memory window.\n");
                return -ENODEV;
        }
-       
+
        i*=16384;
        i+=16384;
-       
+
        dev->mem_end=dev->mem_start + i;
-       
+
        dev->irq = ((POS>>2)&3)+9;
-       
+
        if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname))
        {
-               printk("io 0x%3lX, which is busy.\n", dev->base_addr);
+               pr_cont("io 0x%3lX, which is busy.\n", dev->base_addr);
                return -EBUSY;
        }
 
-       printk("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
+       pr_cont("io 0x%3lX irq %d mem 0x%lX (%dK)\n",
                dev->base_addr, dev->irq, dev->mem_start, i/1024);
-       
-       
+
+
        /* We ought to set the cache line size here.. */
-       
-       
+
+
        /*
         *      Go PROM browsing
         */
-        
-       printk("%s: Address ", dev->name);
-        
+
        /* Retrieve and print the ethernet address. */
        for (i = 0; i < 6; i++)
        {
                mca_write_pos(slot, 6, i+12);
                mca_write_pos(slot, 7, 0);
-       
-               printk(" %2.2x", dev->dev_addr[i] = mca_read_pos(slot,3));
+
+               dev->dev_addr[i] = mca_read_pos(slot,3);
        }
 
+       pr_info("%s: Address %pM ", dev->name, dev->dev_addr);
+
        mca_write_pos(slot, 6, 0);
        mca_write_pos(slot, 7, 0);
 
        POS = mca_read_stored_pos(slot, 4);
-       
+
        if(POS&2)
-               printk(" : BNC port selected.\n");
-       else 
-               printk(" : AUI port selected.\n");
-               
+               pr_cont(": BNC port selected.\n");
+       else
+               pr_cont(": AUI port selected.\n");
+
        POS=inb(dev->base_addr+HOST_CTRL);
        POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET;
        POS&=~HOST_CTRL_INTE;
@@ -428,17 +436,17 @@ static int __init mc32_probe1(struct net_device *dev, int slot)
        /* Reset off */
        POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET);
        outb(POS, dev->base_addr+HOST_CTRL);
-       
+
        udelay(300);
-       
+
        /*
         *      Grab the IRQ
         */
 
-       err = request_irq(dev->irq, &mc32_interrupt, SA_SHIRQ | SA_SAMPLE_RANDOM, DRV_NAME, dev);
+       err = request_irq(dev->irq, &mc32_interrupt, IRQF_SHARED | IRQF_SAMPLE_RANDOM, DRV_NAME, dev);
        if (err) {
                release_region(dev->base_addr, MC32_IO_EXTENT);
-               printk(KERN_ERR "%s: unable to get IRQ %d.\n", DRV_NAME, dev->irq);
+               pr_err("%s: unable to get IRQ %d.\n", DRV_NAME, dev->irq);
                goto err_exit_ports;
        }
 
@@ -448,14 +456,14 @@ static int __init mc32_probe1(struct net_device *dev, int slot)
        i=0;
 
        base = inb(dev->base_addr);
-       
+
        while(base == 0xFF)
        {
                i++;
                if(i == 1000)
                {
-                       printk(KERN_ERR "%s: failed to boot adapter.\n", dev->name);
-                       err = -ENODEV; 
+                       pr_err("%s: failed to boot adapter.\n", dev->name);
+                       err = -ENODEV;
                        goto err_exit_irq;
                }
                udelay(1000);
@@ -466,26 +474,26 @@ static int __init mc32_probe1(struct net_device *dev, int slot)
        if(base>0)
        {
                if(base < 0x0C)
-                       printk(KERN_ERR "%s: %s%s.\n", dev->name, failures[base-1],
+                       pr_err("%s: %s%s.\n", dev->name, failures[base-1],
                                base<0x0A?" test failure":"");
                else
-                       printk(KERN_ERR "%s: unknown failure %d.\n", dev->name, base);
-               err = -ENODEV; 
+                       pr_err("%s: unknown failure %d.\n", dev->name, base);
+               err = -ENODEV;
                goto err_exit_irq;
        }
-       
+
        base=0;
        for(i=0;i<4;i++)
        {
                int n=0;
-       
+
                while(!(inb(dev->base_addr+2)&(1<<5)))
                {
                        n++;
                        udelay(50);
                        if(n>100)
                        {
-                               printk(KERN_ERR "%s: mailbox read fail (%d).\n", dev->name, i);
+                               pr_err("%s: mailbox read fail (%d).\n", dev->name, i);
                                err = -ENODEV;
                                goto err_exit_irq;
                        }
@@ -493,40 +501,35 @@ static int __init mc32_probe1(struct net_device *dev, int slot)
 
                base|=(inb(dev->base_addr)<<(8*i));
        }
-       
+
        lp->exec_box=isa_bus_to_virt(dev->mem_start+base);
-       
-       base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];  
-       
+
+       base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];
+
        lp->base = dev->mem_start+base;
-       
-       lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]); 
+
+       lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]);
        lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]);
-       
+
        lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]);
 
        /*
         *      Descriptor chains (card relative)
         */
-        
+
        lp->tx_chain            = lp->exec_box->data[8];   /* Transmit list start offset */
        lp->rx_chain            = lp->exec_box->data[10];  /* Receive list start offset */
-       lp->tx_len              = lp->exec_box->data[9];   /* Transmit list count */ 
+       lp->tx_len              = lp->exec_box->data[9];   /* Transmit list count */
        lp->rx_len              = lp->exec_box->data[11];  /* Receive list count */
 
        init_MUTEX_LOCKED(&lp->cmd_mutex);
        init_completion(&lp->execution_cmd);
        init_completion(&lp->xceiver_cmd);
-       
-       printk("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
+
+       pr_info("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n",
                dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base);
 
-       dev->open               = mc32_open;
-       dev->stop               = mc32_close;
-       dev->hard_start_xmit    = mc32_send_packet;
-       dev->get_stats          = mc32_get_stats;
-       dev->set_multicast_list = mc32_set_multicast_list;
-       dev->tx_timeout         = mc32_timeout;
+       dev->netdev_ops         = &netdev_ops;
        dev->watchdog_timeo     = HZ*5; /* Board does all the work */
        dev->ethtool_ops        = &netdev_ethtool_ops;
 
@@ -543,12 +546,12 @@ err_exit_ports:
 /**
  *     mc32_ready_poll         -       wait until we can feed it a command
  *     @dev:   The device to wait for
- *     
+ *
  *     Wait until the card becomes ready to accept a command via the
  *     command register. This tells us nothing about the completion
  *     status of any pending commands and takes very little time at all.
  */
+
 static inline void mc32_ready_poll(struct net_device *dev)
 {
        int ioaddr = dev->base_addr;
@@ -608,22 +611,22 @@ static int mc32_command_nowait(struct net_device *dev, u16 cmd, void *data, int
  *
  *     Sends exec commands in a user context. This permits us to wait around
  *     for the replies and also to wait for the command buffer to complete
- *     from a previous command before we execute our command. After our 
+ *     from a previous command before we execute our command. After our
  *     command completes we will attempt any pending multicast reload
  *     we blocked off by hogging the exec buffer.
  *
- *     You feed the card a command, you wait, it interrupts you get a 
+ *     You feed the card a command, you wait, it interrupts you get a
  *     reply. All well and good. The complication arises because you use
  *     commands for filter list changes which come in at bh level from things
  *     like IPV6 group stuff.
  */
-  
+
 static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
 {
        struct mc32_local *lp = netdev_priv(dev);
        int ioaddr = dev->base_addr;
        int ret = 0;
-       
+
        down(&lp->cmd_mutex);
 
        /*
@@ -640,7 +643,7 @@ static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
        outb(1<<6, ioaddr+HOST_CMD);
 
        wait_for_completion(&lp->execution_cmd);
-       
+
        if(lp->exec_box->mbox&(1<<13))
                ret = -1;
 
@@ -664,8 +667,8 @@ static int mc32_command(struct net_device *dev, u16 cmd, void *data, int len)
  *     @dev: The 3c527 card to issue the command to
  *
  *     This may be called from the interrupt state, where it is used
- *     to restart the rx ring if the card runs out of rx buffers. 
- *     
+ *     to restart the rx ring if the card runs out of rx buffers.
+ *
  *     We must first check if it's ok to (re)start the transceiver. See
  *      mc32_close for details.
  */
@@ -675,21 +678,21 @@ static void mc32_start_transceiver(struct net_device *dev) {
        struct mc32_local *lp = netdev_priv(dev);
        int ioaddr = dev->base_addr;
 
-       /* Ignore RX overflow on device closure */ 
+       /* Ignore RX overflow on device closure */
        if (lp->xceiver_desired_state==HALTED)
-               return; 
+               return;
 
        /* Give the card the offset to the post-EOL-bit RX descriptor */
-       mc32_ready_poll(dev); 
+       mc32_ready_poll(dev);
        lp->rx_box->mbox=0;
-       lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next; 
-       outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);      
+       lp->rx_box->data[0]=lp->rx_ring[prev_rx(lp->rx_ring_tail)].p->next;
+       outb(HOST_CMD_START_RX, ioaddr+HOST_CMD);
 
-       mc32_ready_poll(dev); 
+       mc32_ready_poll(dev);
        lp->tx_box->mbox=0;
-       outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD);   /* card ignores this on RX restart */ 
-       
-       /* We are not interrupted on start completion */ 
+       outb(HOST_CMD_RESTRT_TX, ioaddr+HOST_CMD);   /* card ignores this on RX restart */
+
+       /* We are not interrupted on start completion */
 }
 
 
@@ -703,21 +706,21 @@ static void mc32_start_transceiver(struct net_device *dev) {
  *
  *     We then sleep until the card has notified us that both rx and
  *     tx have been suspended.
- */ 
+ */
 
-static void mc32_halt_transceiver(struct net_device *dev) 
+static void mc32_halt_transceiver(struct net_device *dev)
 {
        struct mc32_local *lp = netdev_priv(dev);
        int ioaddr = dev->base_addr;
 
-       mc32_ready_poll(dev);   
+       mc32_ready_poll(dev);
        lp->rx_box->mbox=0;
-       outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);                      
+       outb(HOST_CMD_SUSPND_RX, ioaddr+HOST_CMD);
        wait_for_completion(&lp->xceiver_cmd);
 
-       mc32_ready_poll(dev); 
+       mc32_ready_poll(dev);
        lp->tx_box->mbox=0;
-       outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);      
+       outb(HOST_CMD_SUSPND_TX, ioaddr+HOST_CMD);
        wait_for_completion(&lp->xceiver_cmd);
 }
 
@@ -741,14 +744,14 @@ static void mc32_halt_transceiver(struct net_device *dev)
  *     We then set the end-of-list bit for the last entry so that the
  *     card will know when it has run out of buffers.
  */
-        
+
 static int mc32_load_rx_ring(struct net_device *dev)
 {
        struct mc32_local *lp = netdev_priv(dev);
        int i;
        u16 rx_base;
        volatile struct skb_header *p;
-       
+
        rx_base=lp->rx_chain;
 
        for(i=0; i<RX_RING_LEN; i++) {
@@ -761,14 +764,14 @@ static int mc32_load_rx_ring(struct net_device *dev)
                skb_reserve(lp->rx_ring[i].skb, 18);
 
                p=isa_bus_to_virt(lp->base+rx_base);
-                               
+
                p->control=0;
                p->data=isa_virt_to_bus(lp->rx_ring[i].skb->data);
                p->status=0;
                p->length=1532;
-       
-               lp->rx_ring[i].p=p; 
-               rx_base=p->next; 
+
+               lp->rx_ring[i].p=p;
+               rx_base=p->next;
        }
 
        lp->rx_ring[i-1].p->control |= CONTROL_EOL;
@@ -776,14 +779,14 @@ static int mc32_load_rx_ring(struct net_device *dev)
        lp->rx_ring_tail=0;
 
        return 0;
-}      
+}
 
 
 /**
  *     mc32_flush_rx_ring      -       free the ring of receive buffers
  *     @lp: Local data of 3c527 to flush the rx ring of
  *
- *     Free the buffer for each ring slot. This may be called 
+ *     Free the buffer for each ring slot. This may be called
  *      before mc32_load_rx_ring(), eg. on error in mc32_open().
  *      Requires rx skb pointers to point to a valid skb, or NULL.
  */
@@ -791,16 +794,16 @@ static int mc32_load_rx_ring(struct net_device *dev)
 static void mc32_flush_rx_ring(struct net_device *dev)
 {
        struct mc32_local *lp = netdev_priv(dev);
-       int i; 
+       int i;
 
-       for(i=0; i < RX_RING_LEN; i++) 
-       { 
+       for(i=0; i < RX_RING_LEN; i++)
+       {
                if (lp->rx_ring[i].skb) {
                        dev_kfree_skb(lp->rx_ring[i].skb);
                        lp->rx_ring[i].skb = NULL;
                }
-               lp->rx_ring[i].p=NULL; 
-       } 
+               lp->rx_ring[i].p=NULL;
+       }
 }
 
 
@@ -808,31 +811,31 @@ static void mc32_flush_rx_ring(struct net_device *dev)
  *     mc32_load_tx_ring       -       load transmit ring
  *     @dev: The 3c527 card to issue the command to
  *
- *     This sets up the host transmit data-structures. 
+ *     This sets up the host transmit data-structures.
  *
  *     First, we obtain from the card it's current postion in the tx
  *     ring, so that we will know where to begin transmitting
  *     packets.
- *     
+ *
  *     Then, we read the 'next' pointers from the on-card tx ring into
  *     our tx_ring array to reduce slow shared-mem reads. Finally, we
  *     intitalise the tx house keeping variables.
- * 
- */ 
+ *
+ */
 
 static void mc32_load_tx_ring(struct net_device *dev)
-{ 
+{
        struct mc32_local *lp = netdev_priv(dev);
        volatile struct skb_header *p;
-       int i; 
+       int i;
        u16 tx_base;
 
-       tx_base=lp->tx_box->data[0]; 
+       tx_base=lp->tx_box->data[0];
 
        for(i=0 ; i<TX_RING_LEN ; i++)
        {
                p=isa_bus_to_virt(lp->base+tx_base);
-               lp->tx_ring[i].p=p; 
+               lp->tx_ring[i].p=p;
                lp->tx_ring[i].skb=NULL;
 
                tx_base=p->next;
@@ -841,10 +844,10 @@ static void mc32_load_tx_ring(struct net_device *dev)
        /* -1 so that tx_ring_head cannot "lap" tx_ring_tail */
        /* see mc32_tx_ring */
 
-       atomic_set(&lp->tx_count, TX_RING_LEN-1); 
-       atomic_set(&lp->tx_ring_head, 0); 
-       lp->tx_ring_tail=0; 
-} 
+       atomic_set(&lp->tx_count, TX_RING_LEN-1);
+       atomic_set(&lp->tx_ring_head, 0);
+       lp->tx_ring_tail=0;
+}
 
 
 /**
@@ -871,11 +874,11 @@ static void mc32_flush_tx_ring(struct net_device *dev)
                }
        }
 
-       atomic_set(&lp->tx_count, 0); 
-       atomic_set(&lp->tx_ring_head, 0); 
+       atomic_set(&lp->tx_count, 0);
+       atomic_set(&lp->tx_ring_head, 0);
        lp->tx_ring_tail=0;
 }
-       
+
 
 /**
  *     mc32_open       -       handle 'up' of card
@@ -909,7 +912,7 @@ static int mc32_open(struct net_device *dev)
        regs=inb(ioaddr+HOST_CTRL);
        regs|=HOST_CTRL_INTE;
        outb(regs, ioaddr+HOST_CTRL);
-       
+
        /*
         *      Allow ourselves to issue commands
         */
@@ -924,52 +927,52 @@ static int mc32_open(struct net_device *dev)
        mc32_command(dev, 4, &one, 2);
 
        /*
-        *      Poke it to make sure it's really dead. 
+        *      Poke it to make sure it's really dead.
         */
 
-       mc32_halt_transceiver(dev); 
-       mc32_flush_tx_ring(dev); 
+       mc32_halt_transceiver(dev);
+       mc32_flush_tx_ring(dev);
 
-       /* 
-        *      Ask card to set up on-card descriptors to our spec 
-        */ 
+       /*
+        *      Ask card to set up on-card descriptors to our spec
+        */
 
-       if(mc32_command(dev, 8, descnumbuffs, 4)) { 
-               printk("%s: %s rejected our buffer configuration!\n",
+       if(mc32_command(dev, 8, descnumbuffs, 4)) {
+               pr_info("%s: %s rejected our buffer configuration!\n",
                       dev->name, cardname);
-               mc32_close(dev); 
-               return -ENOBUFS; 
+               mc32_close(dev);
+               return -ENOBUFS;
        }
-       
-       /* Report new configuration */ 
-       mc32_command(dev, 6, NULL, 0); 
+
+       /* Report new configuration */
+       mc32_command(dev, 6, NULL, 0);
 
        lp->tx_chain            = lp->exec_box->data[8];   /* Transmit list start offset */
        lp->rx_chain            = lp->exec_box->data[10];  /* Receive list start offset */
-       lp->tx_len              = lp->exec_box->data[9];   /* Transmit list count */ 
+       lp->tx_len              = lp->exec_box->data[9];   /* Transmit list count */
        lp->rx_len              = lp->exec_box->data[11];  /* Receive list count */
+
        /* Set Network Address */
        mc32_command(dev, 1, dev->dev_addr, 6);
-       
+
        /* Set the filters */
        mc32_set_multicast_list(dev);
-                  
-       if (WORKAROUND_82586) { 
+
+       if (WORKAROUND_82586) {
                u16 zero_word=0;
                mc32_command(dev, 0x0D, &zero_word, 2);   /* 82586 bug workaround on  */
        }
 
        mc32_load_tx_ring(dev);
-       
-       if(mc32_load_rx_ring(dev)) 
+
+       if(mc32_load_rx_ring(dev))
        {
                mc32_close(dev);
                return -ENOBUFS;
        }
 
        lp->xceiver_desired_state = RUNNING;
-       
+
        /* And finally, set the ball rolling... */
        mc32_start_transceiver(dev);
 
@@ -991,7 +994,7 @@ static int mc32_open(struct net_device *dev)
 
 static void mc32_timeout(struct net_device *dev)
 {
-       printk(KERN_WARNING "%s: transmit timed out?\n", dev->name);
+       pr_warning("%s: transmit timed out?\n", dev->name);
        /* Try to restart the adaptor. */
        netif_wake_queue(dev);
 }
@@ -1015,56 +1018,57 @@ static void mc32_timeout(struct net_device *dev)
  *      after we've established a valid packet on the tx ring (and
  *      before we let the card "see" it, to prevent it racing with the
  *      irq handler).
- * 
+ *
  */
 
-static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t mc32_send_packet(struct sk_buff *skb,
+                                   struct net_device *dev)
 {
        struct mc32_local *lp = netdev_priv(dev);
        u32 head = atomic_read(&lp->tx_ring_head);
-       
+
        volatile struct skb_header *p, *np;
 
        netif_stop_queue(dev);
 
        if(atomic_read(&lp->tx_count)==0) {
-               return 1;
+               return NETDEV_TX_BUSY;
        }
 
        if (skb_padto(skb, ETH_ZLEN)) {
                netif_wake_queue(dev);
-               return 0;
+               return NETDEV_TX_OK;
        }
 
-       atomic_dec(&lp->tx_count); 
+       atomic_dec(&lp->tx_count);
 
        /* P is the last sending/sent buffer as a pointer */
        p=lp->tx_ring[head].p;
-               
+
        head = next_tx(head);
 
        /* NP is the buffer we will be loading */
-       np=lp->tx_ring[head].p; 
-       
+       np=lp->tx_ring[head].p;
+
        /* We will need this to flush the buffer out */
        lp->tx_ring[head].skb=skb;
 
-       np->length      = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;                  
+       np->length      = unlikely(skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
        np->data        = isa_virt_to_bus(skb->data);
        np->status      = 0;
-       np->control     = CONTROL_EOP | CONTROL_EOL;     
+       np->control     = CONTROL_EOP | CONTROL_EOL;
        wmb();
-               
+
        /*
         * The new frame has been setup; we can now
         * let the interrupt handler and card "see" it
         */
 
-       atomic_set(&lp->tx_ring_head, head); 
+       atomic_set(&lp->tx_ring_head, head);
        p->control     &= ~CONTROL_EOL;
 
        netif_wake_queue(dev);
-       return 0;
+       return NETDEV_TX_OK;
 }
 
 
@@ -1072,13 +1076,13 @@ static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
  *     mc32_update_stats       -       pull off the on board statistics
  *     @dev: 3c527 to service
  *
- * 
+ *
  *     Query and reset the on-card stats. There's the small possibility
  *     of a race here, which would result in an underestimation of
  *     actual errors. As such, we'd prefer to keep all our stats
  *     collection in software. As a rule, we do. However it can't be
  *     used for rx errors and collisions as, by default, the card discards
- *     bad rx packets. 
+ *     bad rx packets.
  *
  *     Setting the SAV BP in the rx filter command supposedly
  *     stops this behaviour. However, testing shows that it only seems to
@@ -1090,30 +1094,30 @@ static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
 static void mc32_update_stats(struct net_device *dev)
 {
        struct mc32_local *lp = netdev_priv(dev);
-       volatile struct mc32_stats *st = lp->stats; 
+       volatile struct mc32_stats *st = lp->stats;
+
+       u32 rx_errors=0;
 
-       u32 rx_errors=0; 
-      
-       rx_errors+=lp->net_stats.rx_crc_errors   +=st->rx_crc_errors;         
+       rx_errors+=dev->stats.rx_crc_errors   +=st->rx_crc_errors;
                                                   st->rx_crc_errors=0;
-       rx_errors+=lp->net_stats.rx_fifo_errors  +=st->rx_overrun_errors;   
-                                                  st->rx_overrun_errors=0; 
-       rx_errors+=lp->net_stats.rx_frame_errors +=st->rx_alignment_errors; 
+       rx_errors+=dev->stats.rx_fifo_errors  +=st->rx_overrun_errors;
+                                                  st->rx_overrun_errors=0;
+       rx_errors+=dev->stats.rx_frame_errors +=st->rx_alignment_errors;
                                                   st->rx_alignment_errors=0;
-       rx_errors+=lp->net_stats.rx_length_errors+=st->rx_tooshort_errors; 
+       rx_errors+=dev->stats.rx_length_errors+=st->rx_tooshort_errors;
                                                   st->rx_tooshort_errors=0;
-       rx_errors+=lp->net_stats.rx_missed_errors+=st->rx_outofresource_errors;
-                                                  st->rx_outofresource_errors=0; 
-        lp->net_stats.rx_errors=rx_errors; 
-                                                  
+       rx_errors+=dev->stats.rx_missed_errors+=st->rx_outofresource_errors;
+                                                  st->rx_outofresource_errors=0;
+        dev->stats.rx_errors=rx_errors;
+
        /* Number of packets which saw one collision */
-       lp->net_stats.collisions+=st->dataC[10];
-       st->dataC[10]=0; 
+       dev->stats.collisions+=st->dataC[10];
+       st->dataC[10]=0;
 
-       /* Number of packets which saw 2--15 collisions */ 
-       lp->net_stats.collisions+=st->dataC[11]; 
-       st->dataC[11]=0; 
-}      
+       /* Number of packets which saw 2--15 collisions */
+       dev->stats.collisions+=st->dataC[11];
+       st->dataC[11]=0;
+}
 
 
 /**
@@ -1130,7 +1134,7 @@ static void mc32_update_stats(struct net_device *dev)
  *     For each completed packet, we will either copy it and pass it up
  *     the stack or, if the packet is near MTU sized, we allocate
  *     another buffer and flip the old one up the stack.
- * 
+ *
  *     We must succeed in keeping a buffer on the ring. If necessary we
  *     will toss a received packet rather than lose a ring entry. Once
  *     the first uncompleted descriptor is found, we move the
@@ -1147,72 +1151,70 @@ static void mc32_rx_ring(struct net_device *dev)
        int x=0;
 
        rx_old_tail = rx_ring_tail = lp->rx_ring_tail;
-       
+
        do
-       { 
-               p=lp->rx_ring[rx_ring_tail].p; 
+       {
+               p=lp->rx_ring[rx_ring_tail].p;
 
-               if(!(p->status & (1<<7))) { /* Not COMPLETED */ 
+               if(!(p->status & (1<<7))) { /* Not COMPLETED */
                        break;
-               } 
+               }
                if(p->status & (1<<6)) /* COMPLETED_OK */
-               {                       
+               {
 
                        u16 length=p->length;
-                       struct sk_buff *skb; 
-                       struct sk_buff *newskb; 
+                       struct sk_buff *skb;
+                       struct sk_buff *newskb;
 
                        /* Try to save time by avoiding a copy on big frames */
 
-                       if ((length > RX_COPYBREAK) 
-                           && ((newskb=dev_alloc_skb(1532)) != NULL)) 
-                       { 
+                       if ((length > RX_COPYBREAK)
+                           && ((newskb=dev_alloc_skb(1532)) != NULL))
+                       {
                                skb=lp->rx_ring[rx_ring_tail].skb;
                                skb_put(skb, length);
-                               
-                               skb_reserve(newskb,18); 
-                               lp->rx_ring[rx_ring_tail].skb=newskb;  
-                               p->data=isa_virt_to_bus(newskb->data);  
-                       } 
-                       else 
+
+                               skb_reserve(newskb,18);
+                               lp->rx_ring[rx_ring_tail].skb=newskb;
+                               p->data=isa_virt_to_bus(newskb->data);
+                       }
+                       else
                        {
-                               skb=dev_alloc_skb(length+2);  
+                               skb=dev_alloc_skb(length+2);
 
                                if(skb==NULL) {
-                                       lp->net_stats.rx_dropped++; 
-                                       goto dropped; 
+                                       dev->stats.rx_dropped++;
+                                       goto dropped;
                                }
 
                                skb_reserve(skb,2);
                                memcpy(skb_put(skb, length),
                                       lp->rx_ring[rx_ring_tail].skb->data, length);
                        }
-                       
-                       skb->protocol=eth_type_trans(skb,dev); 
-                       skb->dev=dev; 
-                       dev->last_rx = jiffies;
-                       lp->net_stats.rx_packets++; 
-                       lp->net_stats.rx_bytes += length; 
+
+                       skb->protocol=eth_type_trans(skb,dev);
+                       dev->stats.rx_packets++;
+                       dev->stats.rx_bytes += length;
                        netif_rx(skb);
                }
 
        dropped:
-               p->length = 1532; 
+               p->length = 1532;
                p->status = 0;
-               
-               rx_ring_tail=next_rx(rx_ring_tail); 
+
+               rx_ring_tail=next_rx(rx_ring_tail);
        }
-        while(x++<48);  
+        while(x++<48);
 
-       /* If there was actually a frame to be processed, place the EOL bit */ 
-       /* at the descriptor prior to the one to be filled next */ 
+       /* If there was actually a frame to be processed, place the EOL bit */
+       /* at the descriptor prior to the one to be filled next */
 
-       if (rx_ring_tail != rx_old_tail) 
-       { 
-               lp->rx_ring[prev_rx(rx_ring_tail)].p->control |=  CONTROL_EOL; 
-               lp->rx_ring[prev_rx(rx_old_tail)].p->control  &= ~CONTROL_EOL; 
+       if (rx_ring_tail != rx_old_tail)
+       {
+               lp->rx_ring[prev_rx(rx_ring_tail)].p->control |=  CONTROL_EOL;
+               lp->rx_ring[prev_rx(rx_old_tail)].p->control  &= ~CONTROL_EOL;
 
-               lp->rx_ring_tail=rx_ring_tail; 
+               lp->rx_ring_tail=rx_ring_tail;
        }
 }
 
@@ -1228,10 +1230,10 @@ static void mc32_rx_ring(struct net_device *dev)
  *     any errors. This continues until the transmit ring is emptied
  *     or we reach a descriptor that hasn't yet been processed by the
  *     card.
- * 
+ *
  */
 
-static void mc32_tx_ring(struct net_device *dev) 
+static void mc32_tx_ring(struct net_device *dev)
 {
        struct mc32_local *lp = netdev_priv(dev);
        volatile struct skb_header *np;
@@ -1243,55 +1245,55 @@ static void mc32_tx_ring(struct net_device *dev)
         * condition with 'queue full'
         */
 
-       while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))  
-       {   
-               u16 t; 
+       while (lp->tx_ring_tail != atomic_read(&lp->tx_ring_head))
+       {
+               u16 t;
 
-               t=next_tx(lp->tx_ring_tail); 
-               np=lp->tx_ring[t].p; 
+               t=next_tx(lp->tx_ring_tail);
+               np=lp->tx_ring[t].p;
 
-               if(!(np->status & (1<<7))) 
+               if(!(np->status & (1<<7)))
                {
-                       /* Not COMPLETED */ 
-                       break; 
-               } 
-               lp->net_stats.tx_packets++;
+                       /* Not COMPLETED */
+                       break;
+               }
+               dev->stats.tx_packets++;
                if(!(np->status & (1<<6))) /* Not COMPLETED_OK */
                {
-                       lp->net_stats.tx_errors++;   
+                       dev->stats.tx_errors++;
 
                        switch(np->status&0x0F)
                        {
                                case 1:
-                                       lp->net_stats.tx_aborted_errors++;
-                                       break; /* Max collisions */ 
+                                       dev->stats.tx_aborted_errors++;
+                                       break; /* Max collisions */
                                case 2:
-                                       lp->net_stats.tx_fifo_errors++;
+                                       dev->stats.tx_fifo_errors++;
                                        break;
                                case 3:
-                                       lp->net_stats.tx_carrier_errors++;
+                                       dev->stats.tx_carrier_errors++;
                                        break;
                                case 4:
-                                       lp->net_stats.tx_window_errors++;
-                                       break;  /* CTS Lost */ 
+                                       dev->stats.tx_window_errors++;
+                                       break;  /* CTS Lost */
                                case 5:
-                                       lp->net_stats.tx_aborted_errors++;
-                                       break; /* Transmit timeout */ 
+                                       dev->stats.tx_aborted_errors++;
+                                       break; /* Transmit timeout */
                        }
                }
                /* Packets are sent in order - this is
                    basically a FIFO queue of buffers matching
                    the card ring */
-               lp->net_stats.tx_bytes+=lp->tx_ring[t].skb->len;
+               dev->stats.tx_bytes+=lp->tx_ring[t].skb->len;
                dev_kfree_skb_irq(lp->tx_ring[t].skb);
                lp->tx_ring[t].skb=NULL;
                atomic_inc(&lp->tx_count);
                netif_wake_queue(dev);
 
-               lp->tx_ring_tail=t; 
+               lp->tx_ring_tail=t;
        }
 
-} 
+}
 
 
 /**
@@ -1316,19 +1318,14 @@ static void mc32_tx_ring(struct net_device *dev)
  *
  */
 
-static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t mc32_interrupt(int irq, void *dev_id)
 {
        struct net_device *dev = dev_id;
        struct mc32_local *lp;
        int ioaddr, status, boguscount = 0;
        int rx_event = 0;
-       int tx_event = 0; 
-       
-       if (dev == NULL) {
-               printk(KERN_WARNING "%s: irq %d for unknown device.\n", cardname, irq);
-               return IRQ_NONE;
-       }
+       int tx_event = 0;
+
        ioaddr = dev->base_addr;
        lp = netdev_priv(dev);
 
@@ -1338,26 +1335,24 @@ static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
        {
                status=inb(ioaddr+HOST_CMD);
 
-#ifdef DEBUG_IRQ               
-               printk("Status TX%d RX%d EX%d OV%d BC%d\n",
+               pr_debug("Status TX%d RX%d EX%d OV%d BC%d\n",
                        (status&7), (status>>3)&7, (status>>6)&1,
                        (status>>7)&1, boguscount);
-#endif
-                       
+
                switch(status&7)
                {
                        case 0:
                                break;
                        case 6: /* TX fail */
                        case 2: /* TX ok */
-                               tx_event = 1; 
+                               tx_event = 1;
                                break;
                        case 3: /* Halt */
                        case 4: /* Abort */
                                complete(&lp->xceiver_cmd);
                                break;
                        default:
-                               printk("%s: strange tx ack %d\n", dev->name, status&7);
+                               pr_notice("%s: strange tx ack %d\n", dev->name, status&7);
                }
                status>>=3;
                switch(status&7)
@@ -1365,7 +1360,7 @@ static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
                        case 0:
                                break;
                        case 2: /* RX */
-                               rx_event=1; 
+                               rx_event=1;
                                break;
                        case 3: /* Halt */
                        case 4: /* Abort */
@@ -1374,13 +1369,13 @@ static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
                        case 6:
                                /* Out of RX buffers stat */
                                /* Must restart rx */
-                               lp->net_stats.rx_dropped++;
-                               mc32_rx_ring(dev); 
-                               mc32_start_transceiver(dev); 
+                               dev->stats.rx_dropped++;
+                               mc32_rx_ring(dev);
+                               mc32_start_transceiver(dev);
                                break;
                        default:
-                               printk("%s: strange rx ack %d\n", 
-                                       dev->name, status&7);                   
+                               pr_notice("%s: strange rx ack %d\n",
+                                       dev->name, status&7);
                }
                status>>=3;
                if(status&1)
@@ -1389,10 +1384,10 @@ static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
                         * No thread is waiting: we need to tidy
                         * up ourself.
                         */
-                                  
+
                        if (lp->cmd_nonblocking) {
                                up(&lp->cmd_mutex);
-                               if (lp->mc_reload_wait) 
+                               if (lp->mc_reload_wait)
                                        mc32_reset_multicast_list(dev);
                        }
                        else complete(&lp->execution_cmd);
@@ -1401,22 +1396,22 @@ static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
                {
                        /*
                         *      We get interrupted once per
-                        *      counter that is about to overflow. 
+                        *      counter that is about to overflow.
                         */
 
-                       mc32_update_stats(dev);                 
+                       mc32_update_stats(dev);
                }
        }
 
 
        /*
-        *      Process the transmit and receive rings 
+        *      Process the transmit and receive rings
          */
 
-       if(tx_event) 
+       if(tx_event)
                mc32_tx_ring(dev);
-        
-       if(rx_event) 
+
+       if(rx_event)
                mc32_rx_ring(dev);
 
        return IRQ_HANDLED;
@@ -1435,7 +1430,7 @@ static irqreturn_t mc32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  *     driver.  Otherwise, it is possible that the card may run out
  *     of receive buffers and restart the transceiver while we're
  *     trying to close it.
- * 
+ *
  *     We abort any receive and transmits going on and then wait until
  *     any pending exec commands have completed in other code threads.
  *     In theory we can't get here while that is true, in practice I am
@@ -1452,7 +1447,7 @@ static int mc32_close(struct net_device *dev)
 
        u8 regs;
        u16 one=1;
-       
+
        lp->xceiver_desired_state = HALTED;
        netif_stop_queue(dev);
 
@@ -1464,22 +1459,22 @@ static int mc32_close(struct net_device *dev)
 
        /* Shut down the transceiver */
 
-       mc32_halt_transceiver(dev); 
-       
+       mc32_halt_transceiver(dev);
+
        /* Ensure we issue no more commands beyond this point */
 
        down(&lp->cmd_mutex);
-       
-       /* Ok the card is now stopping */       
-       
+
+       /* Ok the card is now stopping */
+
        regs=inb(ioaddr+HOST_CTRL);
        regs&=~HOST_CTRL_INTE;
        outb(regs, ioaddr+HOST_CTRL);
 
        mc32_flush_rx_ring(dev);
        mc32_flush_tx_ring(dev);
-               
-       mc32_update_stats(dev); 
+
+       mc32_update_stats(dev);
 
        return 0;
 }
@@ -1490,23 +1485,21 @@ static int mc32_close(struct net_device *dev)
  *     @dev: The 3c527 card to handle
  *
  *     We've collected all the stats we can in software already. Now
- *     it's time to update those kept on-card and return the lot. 
- * 
+ *     it's time to update those kept on-card and return the lot.
+ *
  */
 
 static struct net_device_stats *mc32_get_stats(struct net_device *dev)
 {
-       struct mc32_local *lp = netdev_priv(dev);
-       
-       mc32_update_stats(dev); 
-       return &lp->net_stats;
+       mc32_update_stats(dev);
+       return &dev->stats;
 }
 
 
 /**
  *     do_mc32_set_multicast_list      -       attempt to update multicasts
  *     @dev: 3c527 device to load the list on
- *     @retry: indicates this is not the first call. 
+ *     @retry: indicates this is not the first call.
  *
  *
  *     Actually set or clear the multicast filter for this adaptor. The
@@ -1514,39 +1507,36 @@ static struct net_device_stats *mc32_get_stats(struct net_device *dev)
  *     state as it may take multiple calls to get the command sequence
  *     completed. We just keep trying to schedule the loads until we
  *     manage to process them all.
- * 
+ *
  *     num_addrs == -1 Promiscuous mode, receive all packets
- * 
+ *
  *     num_addrs == 0  Normal mode, clear multicast list
- * 
- *     num_addrs > 0   Multicast mode, receive normal and MC packets, 
- *                     and do best-effort filtering. 
  *
- *     See mc32_update_stats() regards setting the SAV BP bit. 
+ *     num_addrs > 0   Multicast mode, receive normal and MC packets,
+ *                     and do best-effort filtering.
+ *
+ *     See mc32_update_stats() regards setting the SAV BP bit.
  *
  */
 
 static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
 {
        struct mc32_local *lp = netdev_priv(dev);
-       u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */ 
+       u16 filt = (1<<2); /* Save Bad Packets, for stats purposes */
 
-       if (dev->flags&IFF_PROMISC)
+       if ((dev->flags&IFF_PROMISC) ||
+           (dev->flags&IFF_ALLMULTI) ||
+           dev->mc_count > 10)
                /* Enable promiscuous mode */
                filt |= 1;
-       else if((dev->flags&IFF_ALLMULTI) || dev->mc_count > 10)
-       {
-               dev->flags|=IFF_PROMISC;
-               filt |= 1;
-       }
        else if(dev->mc_count)
        {
                unsigned char block[62];
                unsigned char *bp;
                struct dev_mc_list *dmc=dev->mc_list;
-               
+
                int i;
-              
+
                if(retry==0)
                        lp->mc_list_valid = 0;
                if(!lp->mc_list_valid)
@@ -1554,7 +1544,7 @@ static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
                        block[1]=0;
                        block[0]=dev->mc_count;
                        bp=block+2;
-               
+
                        for(i=0;i<dev->mc_count;i++)
                        {
                                memcpy(bp, dmc->dmi_addr, 6);
@@ -1569,12 +1559,12 @@ static void do_mc32_set_multicast_list(struct net_device *dev, int retry)
                        lp->mc_list_valid=1;
                }
        }
-       
-       if(mc32_command_nowait(dev, 0, &filt, 2)==-1) 
+
+       if(mc32_command_nowait(dev, 0, &filt, 2)==-1)
        {
                lp->mc_reload_wait = 1;
-       } 
-       else { 
+       }
+       else {
                lp->mc_reload_wait = 0;
        }
 }
@@ -1627,7 +1617,7 @@ static void netdev_set_msglevel(struct net_device *dev, u32 level)
        mc32_debug = level;
 }
 
-static struct ethtool_ops netdev_ethtool_ops = {
+static const struct ethtool_ops netdev_ethtool_ops = {
        .get_drvinfo            = netdev_get_drvinfo,
        .get_msglevel           = netdev_get_msglevel,
        .set_msglevel           = netdev_set_msglevel,
@@ -1664,7 +1654,7 @@ int __init init_module(void)
  *     transmit operations are allowed to start scribbling into memory.
  */
 
-void cleanup_module(void)
+void __exit cleanup_module(void)
 {
        unregister_netdev(this_device);
        cleanup_card(this_device);