drivers/net: request_irq - Remove unnecessary leading & from second arg
[safe/jmp/linux-2.6] / drivers / net / eepro.c
index cd24756..94c5949 100644 (file)
@@ -154,7 +154,7 @@ static const char version[] =
 #include <asm/dma.h>
 
 #define DRV_NAME "eepro"
-#define DRV_VERSION "0.13b"
+#define DRV_VERSION "0.13c"
 
 #define compat_dev_kfree_skb( skb, mode ) dev_kfree_skb( (skb) )
 /* I had reports of looong delays with SLOW_DOWN defined as udelay(2) */
@@ -192,7 +192,6 @@ static unsigned int net_debug = NET_DEBUG;
 
 /* Information that need to be kept for each board. */
 struct eepro_local {
-       struct net_device_stats stats;
        unsigned rx_start;
        unsigned tx_start; /* start of the transmit chain */
        int tx_last;  /* pointer to last packet in the transmit chain */
@@ -310,12 +309,12 @@ struct eepro_local {
 
 static int     eepro_probe1(struct net_device *dev, int autoprobe);
 static int     eepro_open(struct net_device *dev);
-static int     eepro_send_packet(struct sk_buff *skb, struct net_device *dev);
-static irqreturn_t eepro_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static netdev_tx_t eepro_send_packet(struct sk_buff *skb,
+                                    struct net_device *dev);
+static irqreturn_t eepro_interrupt(int irq, void *dev_id);
 static void    eepro_rx(struct net_device *dev);
 static void    eepro_transmit_interrupt(struct net_device *dev);
 static int     eepro_close(struct net_device *dev);
-static struct net_device_stats *eepro_get_stats(struct net_device *dev);
 static void     set_multicast_list(struct net_device *dev);
 static void     eepro_tx_timeout (struct net_device *dev);
 
@@ -514,7 +513,7 @@ buffer (transmit-buffer = 32K - receive-buffer).
 
 /* a complete sel reset */
 #define eepro_complete_selreset(ioaddr) { \
-                                               lp->stats.tx_errors++;\
+                                               dev->stats.tx_errors++;\
                                                eepro_sel_reset(ioaddr);\
                                                lp->tx_end = \
                                                        lp->xmt_lower_limit;\
@@ -537,8 +536,6 @@ static int __init do_eepro_probe(struct net_device *dev)
        int base_addr = dev->base_addr;
        int irq = dev->irq;
 
-       SET_MODULE_OWNER(dev);
-
 #ifdef PnPWakeup
        /* XXXX for multiple cards should this only be run once? */
 
@@ -552,8 +549,7 @@ static int __init do_eepro_probe(struct net_device *dev)
        {
                unsigned short int WS[32]=WakeupSeq;
 
-               if (check_region(WakeupPort, 2)==0) {
-
+               if (request_region(WakeupPort, 2, "eepro wakeup")) {
                        if (net_debug>5)
                                printk(KERN_DEBUG "Waking UP\n");
 
@@ -563,7 +559,10 @@ static int __init do_eepro_probe(struct net_device *dev)
                                outb_p(WS[i],WakeupPort);
                                if (net_debug>5) printk(KERN_DEBUG ": %#x ",WS[i]);
                        }
-               } else printk(KERN_WARNING "Checkregion Failed!\n");
+
+                       release_region(WakeupPort, 2);
+               } else
+                       printk(KERN_WARNING "PnP wakeup region busy!\n");
        }
 #endif
 
@@ -592,20 +591,13 @@ struct net_device * __init eepro_probe(int unit)
        if (!dev)
                return ERR_PTR(-ENODEV);
 
-       SET_MODULE_OWNER(dev);
-
        sprintf(dev->name, "eth%d", unit);
        netdev_boot_setup_check(dev);
 
        err = do_eepro_probe(dev);
        if (err)
                goto out;
-       err = register_netdev(dev);
-       if (err)
-               goto out1;
        return dev;
-out1:
-       release_region(dev->base_addr, EEPRO_IO_EXTENT);
 out:
        free_netdev(dev);
        return ERR_PTR(err);
@@ -614,7 +606,7 @@ out:
 
 static void __init printEEPROMInfo(struct net_device *dev)
 {
-       struct eepro_local *lp = (struct eepro_local *)dev->priv;
+       struct eepro_local *lp = netdev_priv(dev);
        int ioaddr = dev->base_addr;
        unsigned short Word;
        int i,j;
@@ -642,7 +634,7 @@ static void __init printEEPROMInfo(struct net_device *dev)
                printk(KERN_DEBUG " PC: %d\n", GetBit(Word,ee_PC));
                printk(KERN_DEBUG " TPE/AUI: %d\n", GetBit(Word,ee_TPE_AUI));
                printk(KERN_DEBUG " Jabber: %d\n", GetBit(Word,ee_Jabber));
-               printk(KERN_DEBUG " AutoPort: %d\n", GetBit(!Word,ee_Jabber));
+               printk(KERN_DEBUG " AutoPort: %d\n", !GetBit(Word,ee_AutoPort));
                printk(KERN_DEBUG " Duplex: %d\n", GetBit(Word,ee_Duplex));
        }
 
@@ -710,7 +702,7 @@ static void __init eepro_print_info (struct net_device *dev)
                                        dev->name, (unsigned)dev->base_addr);
                        break;
                case LAN595FX:
-                       printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,", 
+                       printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,",
                                        dev->name, (unsigned)dev->base_addr);
                        break;
                case LAN595TX:
@@ -718,12 +710,12 @@ static void __init eepro_print_info (struct net_device *dev)
                                        dev->name, (unsigned)dev->base_addr);
                        break;
                case LAN595:
-                       printk("%s: Intel 82595-based lan card at %#x,", 
+                       printk("%s: Intel 82595-based lan card at %#x,",
                                        dev->name, (unsigned)dev->base_addr);
+                       break;
        }
 
-       for (i=0; i < 6; i++)
-               printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
+       printk(" %pM", dev->dev_addr);
 
        if (net_debug > 3)
                printk(KERN_DEBUG ", %dK RCV buffer",
@@ -731,7 +723,7 @@ static void __init eepro_print_info (struct net_device *dev)
 
        if (dev->irq > 2)
                printk(", IRQ %d, %s.\n", dev->irq, ifmap[dev->if_port]);
-       else 
+       else
                printk(", %s.\n", ifmap[dev->if_port]);
 
        if (net_debug > 3) {
@@ -746,7 +738,18 @@ static void __init eepro_print_info (struct net_device *dev)
                printEEPROMInfo(dev);
 }
 
-static struct ethtool_ops eepro_ethtool_ops;
+static const struct ethtool_ops eepro_ethtool_ops;
+
+static const struct net_device_ops eepro_netdev_ops = {
+       .ndo_open               = eepro_open,
+       .ndo_stop               = eepro_close,
+       .ndo_start_xmit         = eepro_send_packet,
+       .ndo_set_multicast_list = set_multicast_list,
+       .ndo_tx_timeout         = eepro_tx_timeout,
+       .ndo_change_mtu         = eth_change_mtu,
+       .ndo_set_mac_address    = eth_mac_addr,
+       .ndo_validate_addr      = eth_validate_addr,
+};
 
 /* This is the real probe routine.  Linux has a history of friendly device
    probes on the ISA bus.  A good device probe avoids doing writes, and
@@ -758,9 +761,10 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
        int i;
        struct eepro_local *lp;
        int ioaddr = dev->base_addr;
+       int err;
 
        /* Grab the region so we can find another board if autoIRQ fails. */
-       if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) { 
+       if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) {
                if (!autoprobe)
                        printk(KERN_WARNING "EEPRO: io-port 0x%04x in use \n",
                                ioaddr);
@@ -842,15 +846,15 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
                /* Mask off INT number */
                int count = lp->word[1] & 7;
                unsigned irqMask = lp->word[7];
+
                while (count--)
                        irqMask &= irqMask - 1;
+
                count = ffs(irqMask);
+
                if (count)
                        dev->irq = count - 1;
+
                if (dev->irq < 2) {
                        printk(KERN_ERR " Duh! illegal interrupt vector stored in EEPROM.\n");
                        goto exit;
@@ -858,25 +862,26 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
                        dev->irq = 9;
                }
        }
-       dev->open               = eepro_open;
-       dev->stop               = eepro_close;
-       dev->hard_start_xmit    = eepro_send_packet;
-       dev->get_stats          = eepro_get_stats;
-       dev->set_multicast_list = &set_multicast_list;
-       dev->tx_timeout         = eepro_tx_timeout;
+
+       dev->netdev_ops         = &eepro_netdev_ops;
        dev->watchdog_timeo     = TX_TIMEOUT;
        dev->ethtool_ops        = &eepro_ethtool_ops;
+
        /* print boot time info */
        eepro_print_info(dev);
 
        /* reset 82595 */
        eepro_reset(ioaddr);
+
+       err = register_netdev(dev);
+       if (err)
+               goto err;
        return 0;
 exit:
+       err = -ENODEV;
+err:
        release_region(dev->base_addr, EEPRO_IO_EXTENT);
-       return -ENODEV;
+       return err;
 }
 
 /* Open/initialize the board.  This is called (in the current kernel)
@@ -916,7 +921,7 @@ static int  eepro_grab_irq(struct net_device *dev)
 
                eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */
 
-               if (request_irq (*irqp, NULL, SA_SHIRQ, "bogus", dev) != EBUSY) {
+               if (request_irq (*irqp, NULL, IRQF_SHARED, "bogus", dev) != EBUSY) {
                        unsigned long irq_mask;
                        /* Twinkle the interrupt, and check if it's seen */
                        irq_mask = probe_irq_on();
@@ -985,21 +990,11 @@ static int eepro_open(struct net_device *dev)
                return -EAGAIN;
        }
 
-       if (request_irq(dev->irq , &eepro_interrupt, 0, dev->name, dev)) {
+       if (request_irq(dev->irq , eepro_interrupt, 0, dev->name, dev)) {
                printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
                return -EAGAIN;
        }
 
-#ifdef irq2dev_map
-       if  (((irq2dev_map[dev->irq] != 0)
-               || (irq2dev_map[dev->irq] = dev) == 0) &&
-               (irq2dev_map[dev->irq]!=dev)) {
-               /* printk("%s: IRQ map wrong\n", dev->name); */
-               free_irq(dev->irq, dev);
-               return -EAGAIN;
-       }
-#endif
-
        /* Initialize the 82595. */
 
        eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
@@ -1045,8 +1040,8 @@ static int eepro_open(struct net_device *dev)
 
 
        /* Initialize the RCV and XMT upper and lower limits */
-       outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG); 
-       outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG); 
+       outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG);
+       outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG);
        outb(lp->xmt_lower_limit >> 8, ioaddr + lp->xmt_lower_limit_reg);
        outb(lp->xmt_upper_limit >> 8, ioaddr + lp->xmt_upper_limit_reg);
 
@@ -1063,12 +1058,12 @@ static int eepro_open(struct net_device *dev)
        eepro_clear_int(ioaddr);
 
        /* Initialize RCV */
-       outw(lp->rcv_lower_limit, ioaddr + RCV_BAR); 
+       outw(lp->rcv_lower_limit, ioaddr + RCV_BAR);
        lp->rx_start = lp->rcv_lower_limit;
-       outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP); 
+       outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP);
 
        /* Initialize XMT */
-       outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar); 
+       outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar);
        lp->tx_start = lp->tx_end = lp->xmt_lower_limit;
        lp->tx_last = 0;
 
@@ -1132,14 +1127,15 @@ static void eepro_tx_timeout (struct net_device *dev)
        printk (KERN_ERR "%s: transmit timed out, %s?\n", dev->name,
                "network cable problem");
        /* This is not a duplicate. One message for the console,
-          one for the the log file  */
+          one for the log file  */
        printk (KERN_DEBUG "%s: transmit timed out, %s?\n", dev->name,
                "network cable problem");
        eepro_complete_selreset(ioaddr);
 }
 
 
-static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t eepro_send_packet(struct sk_buff *skb,
+                                    struct net_device *dev)
 {
        struct eepro_local *lp = netdev_priv(dev);
        unsigned long flags;
@@ -1150,9 +1146,8 @@ static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev)
                printk(KERN_DEBUG  "%s: entering eepro_send_packet routine.\n", dev->name);
 
        if (length < ETH_ZLEN) {
-               skb = skb_padto(skb, ETH_ZLEN);
-               if (skb == NULL)
-                       return 0;
+               if (skb_padto(skb, ETH_ZLEN))
+                       return NETDEV_TX_OK;
                length = ETH_ZLEN;
        }
        netif_stop_queue (dev);
@@ -1165,9 +1160,9 @@ static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev)
 
                if (hardware_send_packet(dev, buf, length))
                        /* we won't wake queue here because we're out of space */
-                       lp->stats.tx_dropped++;
+                       dev->stats.tx_dropped++;
                else {
-               lp->stats.tx_bytes+=skb->len;
+               dev->stats.tx_bytes+=skb->len;
                dev->trans_start = jiffies;
                        netif_wake_queue(dev);
                }
@@ -1177,7 +1172,7 @@ static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev)
        dev_kfree_skb (skb);
 
        /* You might need to clean up and record Tx statistics here. */
-       /* lp->stats.tx_aborted_errors++; */
+       /* dev->stats.tx_aborted_errors++; */
 
        if (net_debug > 5)
                printk(KERN_DEBUG "%s: exiting eepro_send_packet routine.\n", dev->name);
@@ -1185,7 +1180,7 @@ static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev)
        eepro_en_int(ioaddr);
        spin_unlock_irqrestore(&lp->lock, flags);
 
-       return 0;
+       return NETDEV_TX_OK;
 }
 
 
@@ -1193,19 +1188,13 @@ static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev)
        Handle the network interface interrupts. */
 
 static irqreturn_t
-eepro_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+eepro_interrupt(int irq, void *dev_id)
 {
-       struct net_device *dev =  (struct net_device *)dev_id;
-                             /* (struct net_device *)(irq2dev_map[irq]);*/
+       struct net_device *dev = dev_id;
        struct eepro_local *lp;
        int ioaddr, status, boguscount = 20;
        int handled = 0;
 
-       if (dev == NULL) {
-                printk (KERN_ERR "eepro_interrupt(): irq %d for unknown device.\\n", irq);
-                return IRQ_NONE;
-        }
-
        lp = netdev_priv(dev);
 
         spin_lock(&lp->lock);
@@ -1285,25 +1274,11 @@ static int eepro_close(struct net_device *dev)
        /* release the interrupt */
        free_irq(dev->irq, dev);
 
-#ifdef irq2dev_map
-       irq2dev_map[dev->irq] = 0;
-#endif
-
        /* Update the statistics here. What statistics? */
 
        return 0;
 }
 
-/* Get the current statistics. This may be called with the card open or
-   closed. */
-static struct net_device_stats *
-eepro_get_stats(struct net_device *dev)
-{
-       struct eepro_local *lp = netdev_priv(dev);
-
-       return &lp->stats;
-}
-
 /* Set or clear the multicast filter for this adaptor.
  */
 static void
@@ -1316,21 +1291,12 @@ set_multicast_list(struct net_device *dev)
 
        if (dev->flags&(IFF_ALLMULTI|IFF_PROMISC) || dev->mc_count > 63)
        {
-               /*
-                *      We must make the kernel realise we had to move
-                *      into promisc mode or we start all out war on
-                *      the cable. If it was a promisc request the
-                *      flag is already set. If not we assert it.
-                */
-               dev->flags|=IFF_PROMISC;
-
                eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
                mode = inb(ioaddr + REG2);
                outb(mode | PRMSC_Mode, ioaddr + REG2);
                mode = inb(ioaddr + REG3);
                outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
                eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */
-               printk(KERN_INFO "%s: promiscuous mode enabled.\n", dev->name);
        }
 
        else if (dev->mc_count==0 )
@@ -1409,7 +1375,7 @@ set_multicast_list(struct net_device *dev)
                                outb(0x08, ioaddr + STATUS_REG);
 
                                if (i & 0x20) { /* command ABORTed */
-                                       printk(KERN_NOTICE "%s: multicast setup failed.\n", 
+                                       printk(KERN_NOTICE "%s: multicast setup failed.\n",
                                                dev->name);
                                        break;
                                } else if ((i & 0x0f) == 0x03)  { /* MC-Done */
@@ -1438,7 +1404,7 @@ set_multicast_list(struct net_device *dev)
 #define eeprom_delay() { udelay(40); }
 #define EE_READ_CMD (6 << 6)
 
-int
+static int
 read_eeprom(int ioaddr, int location, struct net_device *dev)
 {
        int i;
@@ -1510,7 +1476,7 @@ hardware_send_packet(struct net_device *dev, void *buf, short length)
                end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
 
        if (end >= lp->xmt_upper_limit + 2) { /* the transmit buffer is wrapped around */
-               if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {   
+               if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {
                                /* Arrrr!!!, must keep the xmt header together,
                                several days were lost to chase this one down. */
                        last = lp->xmt_lower_limit;
@@ -1597,19 +1563,18 @@ eepro_rx(struct net_device *dev)
                        /* Malloc up new buffer. */
                        struct sk_buff *skb;
 
-                       lp->stats.rx_bytes+=rcv_size;
+                       dev->stats.rx_bytes+=rcv_size;
                        rcv_size &= 0x3fff;
                        skb = dev_alloc_skb(rcv_size+5);
                        if (skb == NULL) {
                                printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
-                               lp->stats.rx_dropped++;
+                               dev->stats.rx_dropped++;
                                rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
                                lp->rx_start = rcv_next_frame;
                                outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG);
 
                                break;
                        }
-                       skb->dev = dev;
                        skb_reserve(skb,2);
 
                        if (lp->version == LAN595)
@@ -1624,29 +1589,28 @@ eepro_rx(struct net_device *dev)
 
                        skb->protocol = eth_type_trans(skb,dev);
                        netif_rx(skb);
-                       dev->last_rx = jiffies;
-                       lp->stats.rx_packets++;
+                       dev->stats.rx_packets++;
                }
 
                else { /* Not sure will ever reach here,
                        I set the 595 to discard bad received frames */
-                       lp->stats.rx_errors++;
+                       dev->stats.rx_errors++;
 
                        if (rcv_status & 0x0100)
-                               lp->stats.rx_over_errors++;
+                               dev->stats.rx_over_errors++;
 
                        else if (rcv_status & 0x0400)
-                               lp->stats.rx_frame_errors++;
+                               dev->stats.rx_frame_errors++;
 
                        else if (rcv_status & 0x0800)
-                               lp->stats.rx_crc_errors++;
+                               dev->stats.rx_crc_errors++;
 
-                       printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n", 
+                       printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n",
                                dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size);
                }
 
                if (rcv_status & 0x1000)
-                       lp->stats.rx_length_errors++;
+                       dev->stats.rx_length_errors++;
 
                rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
                lp->rx_start = rcv_next_frame;
@@ -1672,10 +1636,10 @@ eepro_transmit_interrupt(struct net_device *dev)
 {
        struct eepro_local *lp = netdev_priv(dev);
        short ioaddr = dev->base_addr;
-       short boguscount = 25; 
+       short boguscount = 25;
        short xmt_status;
 
-       while ((lp->tx_start != lp->tx_end) && boguscount--) { 
+       while ((lp->tx_start != lp->tx_end) && boguscount--) {
 
                outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
                xmt_status = inw(ioaddr+IO_PORT);
@@ -1689,11 +1653,11 @@ eepro_transmit_interrupt(struct net_device *dev)
                netif_wake_queue (dev);
 
                if (xmt_status & TX_OK)
-                       lp->stats.tx_packets++;
+                       dev->stats.tx_packets++;
                else {
-                       lp->stats.tx_errors++;
+                       dev->stats.tx_errors++;
                        if (xmt_status & 0x0400) {
-                               lp->stats.tx_carrier_errors++;
+                               dev->stats.tx_carrier_errors++;
                                printk(KERN_DEBUG "%s: carrier error\n",
                                        dev->name);
                                printk(KERN_DEBUG "%s: XMT status = %#x\n",
@@ -1707,11 +1671,11 @@ eepro_transmit_interrupt(struct net_device *dev)
                        }
                }
                if (xmt_status & 0x000f) {
-                       lp->stats.collisions += (xmt_status & 0x000f);
+                       dev->stats.collisions += (xmt_status & 0x000f);
                }
 
                if ((xmt_status & 0x0040) == 0x0) {
-                       lp->stats.tx_heartbeat_errors++;
+                       dev->stats.tx_heartbeat_errors++;
                }
        }
 }
@@ -1719,9 +1683,9 @@ eepro_transmit_interrupt(struct net_device *dev)
 static int eepro_ethtool_get_settings(struct net_device *dev,
                                        struct ethtool_cmd *cmd)
 {
-       struct eepro_local      *lp = (struct eepro_local *)dev->priv;
+       struct eepro_local      *lp = netdev_priv(dev);
 
-       cmd->supported =        SUPPORTED_10baseT_Half | 
+       cmd->supported =        SUPPORTED_10baseT_Half |
                                SUPPORTED_10baseT_Full |
                                SUPPORTED_Autoneg;
        cmd->advertising =      ADVERTISED_10baseT_Half |
@@ -1769,7 +1733,7 @@ static void eepro_ethtool_get_drvinfo(struct net_device *dev,
        sprintf(drvinfo->bus_info, "ISA 0x%lx", dev->base_addr);
 }
 
-static struct ethtool_ops eepro_ethtool_ops = {
+static const struct ethtool_ops eepro_ethtool_ops = {
        .get_settings   = eepro_ethtool_get_settings,
        .get_drvinfo    = eepro_ethtool_get_drvinfo,
 };
@@ -1795,18 +1759,16 @@ MODULE_AUTHOR("Pascal Dupuis and others");
 MODULE_DESCRIPTION("Intel i82595 ISA EtherExpressPro10/10+ driver");
 MODULE_LICENSE("GPL");
 
-static int num_params;
-module_param_array(io, int, &num_params, 0);
-module_param_array(irq, int, &num_params, 0);
-module_param_array(mem, int, &num_params, 0);
+module_param_array(io, int, NULL, 0);
+module_param_array(irq, int, NULL, 0);
+module_param_array(mem, int, NULL, 0);
 module_param(autodetect, int, 0);
 MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base addres(es)");
 MODULE_PARM_DESC(irq, "EtherExpress Pro/10 IRQ number(s)");
 MODULE_PARM_DESC(mem, "EtherExpress Pro/10 Rx buffer size(es) in kB (3-29)");
 MODULE_PARM_DESC(autodetect, "EtherExpress Pro/10 force board(s) detection (0-1)");
 
-int
-init_module(void)
+int __init init_module(void)
 {
        struct net_device *dev;
        int i;
@@ -1824,7 +1786,7 @@ init_module(void)
                printk(KERN_INFO "eepro_init_module: Auto-detecting boards (May God protect us...)\n");
        }
 
-       for (i = 0; io[i] != -1 && i < MAX_EEPRO; i++) {
+       for (i = 0; i < MAX_EEPRO && io[i] != -1; i++) {
                dev = alloc_etherdev(sizeof(struct eepro_local));
                if (!dev)
                        break;
@@ -1834,11 +1796,8 @@ init_module(void)
                dev->irq = irq[i];
 
                if (do_eepro_probe(dev) == 0) {
-                       if (register_netdev(dev) == 0) {
-                               dev_eepro[n_eepro++] = dev;
-                               continue;
-                       }
-                       release_region(dev->base_addr, EEPRO_IO_EXTENT);
+                       dev_eepro[n_eepro++] = dev;
+                       continue;
                }
                free_netdev(dev);
                break;
@@ -1850,7 +1809,7 @@ init_module(void)
        return n_eepro ? 0 : -ENODEV;
 }
 
-void
+void __exit
 cleanup_module(void)
 {
        int i;