Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / drivers / net / smc91x.c
index 24768c1..682bc4f 100644 (file)
@@ -35,7 +35,7 @@
  *
  * contributors:
  *     Daris A Nevil <dnevil@snmc.com>
- *      Nicolas Pitre <nico@cam.org>
+ *      Nicolas Pitre <nico@fluxnic.net>
  *     Russell King <rmk@arm.linux.org.uk>
  *
  * History:
@@ -58,7 +58,7 @@
  *   22/09/04  Nicolas Pitre      big update (see commit log for details)
  */
 static const char version[] =
-       "smc91x.c: v1.1, sep 22 2004 by Nicolas Pitre <nico@cam.org>\n";
+       "smc91x.c: v1.1, sep 22 2004 by Nicolas Pitre <nico@fluxnic.net>\n";
 
 /* Debugging level */
 #ifndef SMC_DEBUG
@@ -70,7 +70,6 @@ static const char version[] =
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
@@ -90,33 +89,6 @@ static const char version[] =
 
 #include "smc91x.h"
 
-#ifdef CONFIG_ISA
-/*
- * the LAN91C111 can be at any of the following port addresses.  To change,
- * for a slightly different card, you can add it to the array.  Keep in
- * mind that the array must end in zero.
- */
-static unsigned int smc_portlist[] __initdata = {
-       0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0,
-       0x300, 0x320, 0x340, 0x360, 0x380, 0x3A0, 0x3C0, 0x3E0, 0
-};
-
-#ifndef SMC_IOADDR
-# define SMC_IOADDR            -1
-#endif
-static unsigned long io = SMC_IOADDR;
-module_param(io, ulong, 0400);
-MODULE_PARM_DESC(io, "I/O base address");
-
-#ifndef SMC_IRQ
-# define SMC_IRQ               -1
-#endif
-static int irq = SMC_IRQ;
-module_param(irq, int, 0400);
-MODULE_PARM_DESC(irq, "IRQ number");
-
-#endif  /* CONFIG_ISA */
-
 #ifndef SMC_NOWAIT
 # define SMC_NOWAIT            0
 #endif
@@ -223,21 +195,23 @@ static void PRINT_PKT(u_char *buf, int length)
 /* this enables an interrupt in the interrupt mask register */
 #define SMC_ENABLE_INT(lp, x) do {                                     \
        unsigned char mask;                                             \
-       spin_lock_irq(&lp->lock);                                       \
+       unsigned long smc_enable_flags;                                 \
+       spin_lock_irqsave(&lp->lock, smc_enable_flags);                 \
        mask = SMC_GET_INT_MASK(lp);                                    \
        mask |= (x);                                                    \
        SMC_SET_INT_MASK(lp, mask);                                     \
-       spin_unlock_irq(&lp->lock);                                     \
+       spin_unlock_irqrestore(&lp->lock, smc_enable_flags);            \
 } while (0)
 
 /* this disables an interrupt from the interrupt mask register */
 #define SMC_DISABLE_INT(lp, x) do {                                    \
        unsigned char mask;                                             \
-       spin_lock_irq(&lp->lock);                                       \
+       unsigned long smc_disable_flags;                                \
+       spin_lock_irqsave(&lp->lock, smc_disable_flags);                \
        mask = SMC_GET_INT_MASK(lp);                                    \
        mask &= ~(x);                                                   \
        SMC_SET_INT_MASK(lp, mask);                                     \
-       spin_unlock_irq(&lp->lock);                                     \
+       spin_unlock_irqrestore(&lp->lock, smc_disable_flags);           \
 } while (0)
 
 /*
@@ -270,7 +244,7 @@ static void smc_reset(struct net_device *dev)
        unsigned int ctl, cfg;
        struct sk_buff *pending_skb;
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        /* Disable all interrupts, block TX tasklet */
        spin_lock_irq(&lp->lock);
@@ -363,7 +337,7 @@ static void smc_enable(struct net_device *dev)
        void __iomem *ioaddr = lp->base;
        int mask;
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        /* see the header file for options in TCR/RCR DEFAULT */
        SMC_SELECT_BANK(lp, 0);
@@ -397,7 +371,7 @@ static void smc_shutdown(struct net_device *dev)
        void __iomem *ioaddr = lp->base;
        struct sk_buff *pending_skb;
 
-       DBG(2, "%s: %s\n", CARDNAME, __FUNCTION__);
+       DBG(2, "%s: %s\n", CARDNAME, __func__);
 
        /* no more interrupts for me */
        spin_lock_irq(&lp->lock);
@@ -430,7 +404,7 @@ static inline void  smc_rcv(struct net_device *dev)
        void __iomem *ioaddr = lp->base;
        unsigned int packet_number, status, packet_len;
 
-       DBG(3, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(3, "%s: %s\n", dev->name, __func__);
 
        packet_number = SMC_GET_RXFIFO(lp);
        if (unlikely(packet_number & RXFIFO_REMPTY)) {
@@ -518,7 +492,6 @@ static inline void  smc_rcv(struct net_device *dev)
 
                PRINT_PKT(data, packet_len - 4);
 
-               dev->last_rx = jiffies;
                skb->protocol = eth_type_trans(skb, dev);
                netif_rx(skb);
                dev->stats.rx_packets++;
@@ -548,21 +521,21 @@ static inline void  smc_rcv(struct net_device *dev)
  * any other concurrent access and C would always interrupt B. But life
  * isn't that easy in a SMP world...
  */
-#define smc_special_trylock(lock)                                      \
+#define smc_special_trylock(lock, flags)                               \
 ({                                                                     \
        int __ret;                                                      \
-       local_irq_disable();                                            \
+       local_irq_save(flags);                                          \
        __ret = spin_trylock(lock);                                     \
        if (!__ret)                                                     \
-               local_irq_enable();                                     \
+               local_irq_restore(flags);                               \
        __ret;                                                          \
 })
-#define smc_special_lock(lock)         spin_lock_irq(lock)
-#define smc_special_unlock(lock)       spin_unlock_irq(lock)
+#define smc_special_lock(lock, flags)          spin_lock_irqsave(lock, flags)
+#define smc_special_unlock(lock, flags)        spin_unlock_irqrestore(lock, flags)
 #else
-#define smc_special_trylock(lock)      (1)
-#define smc_special_lock(lock)         do { } while (0)
-#define smc_special_unlock(lock)       do { } while (0)
+#define smc_special_trylock(lock, flags)       (flags == flags)
+#define smc_special_lock(lock, flags)          do { flags = 0; } while (0)
+#define smc_special_unlock(lock, flags)        do { flags = 0; } while (0)
 #endif
 
 /*
@@ -576,10 +549,11 @@ static void smc_hardware_send_pkt(unsigned long data)
        struct sk_buff *skb;
        unsigned int packet_no, len;
        unsigned char *buf;
+       unsigned long flags;
 
-       DBG(3, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(3, "%s: %s\n", dev->name, __func__);
 
-       if (!smc_special_trylock(&lp->lock)) {
+       if (!smc_special_trylock(&lp->lock, flags)) {
                netif_stop_queue(dev);
                tasklet_schedule(&lp->tx_task);
                return;
@@ -587,7 +561,7 @@ static void smc_hardware_send_pkt(unsigned long data)
 
        skb = lp->pending_tx_skb;
        if (unlikely(!skb)) {
-               smc_special_unlock(&lp->lock);
+               smc_special_unlock(&lp->lock, flags);
                return;
        }
        lp->pending_tx_skb = NULL;
@@ -597,7 +571,7 @@ static void smc_hardware_send_pkt(unsigned long data)
                printk("%s: Memory allocation failed.\n", dev->name);
                dev->stats.tx_errors++;
                dev->stats.tx_fifo_errors++;
-               smc_special_unlock(&lp->lock);
+               smc_special_unlock(&lp->lock, flags);
                goto done;
        }
 
@@ -636,7 +610,7 @@ static void smc_hardware_send_pkt(unsigned long data)
 
        /* queue the packet for TX */
        SMC_SET_MMU_CMD(lp, MC_ENQUEUE);
-       smc_special_unlock(&lp->lock);
+       smc_special_unlock(&lp->lock, flags);
 
        dev->trans_start = jiffies;
        dev->stats.tx_packets++;
@@ -661,8 +635,9 @@ static int smc_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
        struct smc_local *lp = netdev_priv(dev);
        void __iomem *ioaddr = lp->base;
        unsigned int numPages, poll_count, status;
+       unsigned long flags;
 
-       DBG(3, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(3, "%s: %s\n", dev->name, __func__);
 
        BUG_ON(lp->pending_tx_skb != NULL);
 
@@ -683,10 +658,10 @@ static int smc_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                dev->stats.tx_errors++;
                dev->stats.tx_dropped++;
                dev_kfree_skb(skb);
-               return 0;
+               return NETDEV_TX_OK;
        }
 
-       smc_special_lock(&lp->lock);
+       smc_special_lock(&lp->lock, flags);
 
        /* now, try to allocate the memory */
        SMC_SET_MMU_CMD(lp, MC_ALLOC | numPages);
@@ -704,7 +679,7 @@ static int smc_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                }
        } while (--poll_count);
 
-       smc_special_unlock(&lp->lock);
+       smc_special_unlock(&lp->lock, flags);
 
        lp->pending_tx_skb = skb;
        if (!poll_count) {
@@ -720,7 +695,7 @@ static int smc_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                smc_hardware_send_pkt((unsigned long)dev);
        }
 
-       return 0;
+       return NETDEV_TX_OK;
 }
 
 /*
@@ -734,7 +709,7 @@ static void smc_tx(struct net_device *dev)
        void __iomem *ioaddr = lp->base;
        unsigned int saved_packet, packet_no, tx_status, pkt_len;
 
-       DBG(3, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(3, "%s: %s\n", dev->name, __func__);
 
        /* If the TX FIFO is empty then nothing to do */
        packet_no = SMC_GET_TXFIFO(lp);
@@ -856,7 +831,7 @@ static int smc_phy_read(struct net_device *dev, int phyaddr, int phyreg)
        SMC_SET_MII(lp, SMC_GET_MII(lp) & ~(MII_MCLK|MII_MDOE|MII_MDO));
 
        DBG(3, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n",
-               __FUNCTION__, phyaddr, phyreg, phydata);
+               __func__, phyaddr, phyreg, phydata);
 
        SMC_SELECT_BANK(lp, 2);
        return phydata;
@@ -883,7 +858,7 @@ static void smc_phy_write(struct net_device *dev, int phyaddr, int phyreg,
        SMC_SET_MII(lp, SMC_GET_MII(lp) & ~(MII_MCLK|MII_MDOE|MII_MDO));
 
        DBG(3, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n",
-               __FUNCTION__, phyaddr, phyreg, phydata);
+               __func__, phyaddr, phyreg, phydata);
 
        SMC_SELECT_BANK(lp, 2);
 }
@@ -896,7 +871,7 @@ static void smc_phy_detect(struct net_device *dev)
        struct smc_local *lp = netdev_priv(dev);
        int phyaddr;
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        lp->phy_type = 0;
 
@@ -935,7 +910,7 @@ static int smc_phy_fixed(struct net_device *dev)
        int phyaddr = lp->mii.phy_id;
        int bmcr, cfg1;
 
-       DBG(3, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(3, "%s: %s\n", dev->name, __func__);
 
        /* Enter Link Disable state */
        cfg1 = smc_phy_read(dev, phyaddr, PHY_CFG1_REG);
@@ -1168,7 +1143,7 @@ static void smc_phy_interrupt(struct net_device *dev)
        int phyaddr = lp->mii.phy_id;
        int phy18;
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        if (lp->phy_type == 0)
                return;
@@ -1236,7 +1211,7 @@ static irqreturn_t smc_interrupt(int irq, void *dev_id)
        int status, mask, timeout, card_stats;
        int saved_pointer;
 
-       DBG(3, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(3, "%s: %s\n", dev->name, __func__);
 
        spin_lock(&lp->lock);
 
@@ -1310,7 +1285,7 @@ static irqreturn_t smc_interrupt(int irq, void *dev_id)
                        smc_phy_interrupt(dev);
                } else if (status & IM_ERCV_INT) {
                        SMC_ACK_INT(lp, IM_ERCV_INT);
-                       PRINTK("%s: UNSUPPORTED: ERCV INTERRUPT \n", dev->name);
+                       PRINTK("%s: UNSUPPORTED: ERCV INTERRUPT\n", dev->name);
                }
        } while (--timeout);
 
@@ -1358,7 +1333,7 @@ static void smc_timeout(struct net_device *dev)
        void __iomem *ioaddr = lp->base;
        int status, mask, eph_st, meminfo, fifo;
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        spin_lock_irq(&lp->lock);
        status = SMC_GET_INT(lp);
@@ -1402,7 +1377,7 @@ static void smc_set_multicast_list(struct net_device *dev)
        unsigned char multicast_table[8];
        int update_multicast = 0;
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        if (dev->flags & IFF_PROMISC) {
                DBG(2, "%s: RCR_PRMS\n", dev->name);
@@ -1419,7 +1394,7 @@ static void smc_set_multicast_list(struct net_device *dev)
         * I don't need to zero the multicast table, because the flag is
         * checked before the table is
         */
-       else if (dev->flags & IFF_ALLMULTI || dev->mc_count > 16) {
+       else if (dev->flags & IFF_ALLMULTI || netdev_mc_count(dev) > 16) {
                DBG(2, "%s: RCR_ALMUL\n", dev->name);
                lp->rcr_cur_mode |= RCR_ALMUL;
        }
@@ -1436,9 +1411,8 @@ static void smc_set_multicast_list(struct net_device *dev)
         * the number of the 8 bit register, while the low 3 bits are the bit
         * within that register.
         */
-       else if (dev->mc_count)  {
-               int i;
-               struct dev_mc_list *cur_addr;
+       else if (!netdev_mc_empty(dev)) {
+               struct netdev_hw_addr *ha;
 
                /* table for flipping the order of 3 bits */
                static const unsigned char invert3[] = {0, 4, 2, 6, 1, 5, 3, 7};
@@ -1446,20 +1420,16 @@ static void smc_set_multicast_list(struct net_device *dev)
                /* start with a table of all zeros: reject all */
                memset(multicast_table, 0, sizeof(multicast_table));
 
-               cur_addr = dev->mc_list;
-               for (i = 0; i < dev->mc_count; i++, cur_addr = cur_addr->next) {
+               netdev_for_each_mc_addr(ha, dev) {
                        int position;
 
-                       /* do we have a pointer here? */
-                       if (!cur_addr)
-                               break;
                        /* make sure this is a multicast address -
                           shouldn't this be a given if we have it here ? */
-                       if (!(*cur_addr->dmi_addr & 1))
+                       if (!(*ha->addr & 1))
                                continue;
 
                        /* only use the low order bits */
-                       position = crc32_le(~0, cur_addr->dmi_addr, 6) & 0x3f;
+                       position = crc32_le(~0, ha->addr, 6) & 0x3f;
 
                        /* do some messy swapping to put the bit in the right spot */
                        multicast_table[invert3[position&7]] |=
@@ -1505,7 +1475,7 @@ smc_open(struct net_device *dev)
 {
        struct smc_local *lp = netdev_priv(dev);
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        /*
         * Check that the address is valid.  If its not, refuse
@@ -1513,14 +1483,16 @@ smc_open(struct net_device *dev)
         * address using ifconfig eth0 hw ether xx:xx:xx:xx:xx:xx
         */
        if (!is_valid_ether_addr(dev->dev_addr)) {
-               PRINTK("%s: no valid ethernet hw addr\n", __FUNCTION__);
+               PRINTK("%s: no valid ethernet hw addr\n", __func__);
                return -EINVAL;
        }
 
        /* Setup the default Register Modes */
        lp->tcr_cur_mode = TCR_DEFAULT;
        lp->rcr_cur_mode = RCR_DEFAULT;
-       lp->rpc_cur_mode = RPC_DEFAULT;
+       lp->rpc_cur_mode = RPC_DEFAULT |
+                               lp->cfg.leda << RPC_LSXA_SHFT |
+                               lp->cfg.ledb << RPC_LSXB_SHFT;
 
        /*
         * If we are not using a MII interface, we need to
@@ -1557,7 +1529,7 @@ static int smc_close(struct net_device *dev)
 {
        struct smc_local *lp = netdev_priv(dev);
 
-       DBG(2, "%s: %s\n", dev->name, __FUNCTION__);
+       DBG(2, "%s: %s\n", dev->name, __func__);
 
        netif_stop_queue(dev);
        netif_carrier_off(dev);
@@ -1640,7 +1612,7 @@ smc_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
        strncpy(info->driver, CARDNAME, sizeof(info->driver));
        strncpy(info->version, version, sizeof(info->version));
-       strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
+       strncpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info));
 }
 
 static int smc_ethtool_nwayreset(struct net_device *dev)
@@ -1669,6 +1641,117 @@ static void smc_ethtool_setmsglevel(struct net_device *dev, u32 level)
        lp->msg_enable = level;
 }
 
+static int smc_write_eeprom_word(struct net_device *dev, u16 addr, u16 word)
+{
+       u16 ctl;
+       struct smc_local *lp = netdev_priv(dev);
+       void __iomem *ioaddr = lp->base;
+
+       spin_lock_irq(&lp->lock);
+       /* load word into GP register */
+       SMC_SELECT_BANK(lp, 1);
+       SMC_SET_GP(lp, word);
+       /* set the address to put the data in EEPROM */
+       SMC_SELECT_BANK(lp, 2);
+       SMC_SET_PTR(lp, addr);
+       /* tell it to write */
+       SMC_SELECT_BANK(lp, 1);
+       ctl = SMC_GET_CTL(lp);
+       SMC_SET_CTL(lp, ctl | (CTL_EEPROM_SELECT | CTL_STORE));
+       /* wait for it to finish */
+       do {
+               udelay(1);
+       } while (SMC_GET_CTL(lp) & CTL_STORE);
+       /* clean up */
+       SMC_SET_CTL(lp, ctl);
+       SMC_SELECT_BANK(lp, 2);
+       spin_unlock_irq(&lp->lock);
+       return 0;
+}
+
+static int smc_read_eeprom_word(struct net_device *dev, u16 addr, u16 *word)
+{
+       u16 ctl;
+       struct smc_local *lp = netdev_priv(dev);
+       void __iomem *ioaddr = lp->base;
+
+       spin_lock_irq(&lp->lock);
+       /* set the EEPROM address to get the data from */
+       SMC_SELECT_BANK(lp, 2);
+       SMC_SET_PTR(lp, addr | PTR_READ);
+       /* tell it to load */
+       SMC_SELECT_BANK(lp, 1);
+       SMC_SET_GP(lp, 0xffff); /* init to known */
+       ctl = SMC_GET_CTL(lp);
+       SMC_SET_CTL(lp, ctl | (CTL_EEPROM_SELECT | CTL_RELOAD));
+       /* wait for it to finish */
+       do {
+               udelay(1);
+       } while (SMC_GET_CTL(lp) & CTL_RELOAD);
+       /* read word from GP register */
+       *word = SMC_GET_GP(lp);
+       /* clean up */
+       SMC_SET_CTL(lp, ctl);
+       SMC_SELECT_BANK(lp, 2);
+       spin_unlock_irq(&lp->lock);
+       return 0;
+}
+
+static int smc_ethtool_geteeprom_len(struct net_device *dev)
+{
+       return 0x23 * 2;
+}
+
+static int smc_ethtool_geteeprom(struct net_device *dev,
+               struct ethtool_eeprom *eeprom, u8 *data)
+{
+       int i;
+       int imax;
+
+       DBG(1, "Reading %d bytes at %d(0x%x)\n",
+               eeprom->len, eeprom->offset, eeprom->offset);
+       imax = smc_ethtool_geteeprom_len(dev);
+       for (i = 0; i < eeprom->len; i += 2) {
+               int ret;
+               u16 wbuf;
+               int offset = i + eeprom->offset;
+               if (offset > imax)
+                       break;
+               ret = smc_read_eeprom_word(dev, offset >> 1, &wbuf);
+               if (ret != 0)
+                       return ret;
+               DBG(2, "Read 0x%x from 0x%x\n", wbuf, offset >> 1);
+               data[i] = (wbuf >> 8) & 0xff;
+               data[i+1] = wbuf & 0xff;
+       }
+       return 0;
+}
+
+static int smc_ethtool_seteeprom(struct net_device *dev,
+               struct ethtool_eeprom *eeprom, u8 *data)
+{
+       int i;
+       int imax;
+
+       DBG(1, "Writing %d bytes to %d(0x%x)\n",
+                       eeprom->len, eeprom->offset, eeprom->offset);
+       imax = smc_ethtool_geteeprom_len(dev);
+       for (i = 0; i < eeprom->len; i += 2) {
+               int ret;
+               u16 wbuf;
+               int offset = i + eeprom->offset;
+               if (offset > imax)
+                       break;
+               wbuf = (data[i] << 8) | data[i + 1];
+               DBG(2, "Writing 0x%x to 0x%x\n", wbuf, offset >> 1);
+               ret = smc_write_eeprom_word(dev, offset >> 1, wbuf);
+               if (ret != 0)
+                       return ret;
+       }
+       return 0;
+}
+
+
 static const struct ethtool_ops smc_ethtool_ops = {
        .get_settings   = smc_ethtool_getsettings,
        .set_settings   = smc_ethtool_setsettings,
@@ -1678,8 +1761,23 @@ static const struct ethtool_ops smc_ethtool_ops = {
        .set_msglevel   = smc_ethtool_setmsglevel,
        .nway_reset     = smc_ethtool_nwayreset,
        .get_link       = ethtool_op_get_link,
-//     .get_eeprom     = smc_ethtool_geteeprom,
-//     .set_eeprom     = smc_ethtool_seteeprom,
+       .get_eeprom_len = smc_ethtool_geteeprom_len,
+       .get_eeprom     = smc_ethtool_geteeprom,
+       .set_eeprom     = smc_ethtool_seteeprom,
+};
+
+static const struct net_device_ops smc_netdev_ops = {
+       .ndo_open               = smc_open,
+       .ndo_stop               = smc_close,
+       .ndo_start_xmit         = smc_hard_start_xmit,
+       .ndo_tx_timeout         = smc_timeout,
+       .ndo_set_multicast_list = smc_set_multicast_list,
+       .ndo_change_mtu         = eth_change_mtu,
+       .ndo_validate_addr      = eth_validate_addr,
+       .ndo_set_mac_address    = eth_mac_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+       .ndo_poll_controller    = smc_poll_controller,
+#endif
 };
 
 /*
@@ -1694,13 +1792,13 @@ static const struct ethtool_ops smc_ethtool_ops = {
  * I just deleted auto_irq.c, since it was never built...
  *   --jgarzik
  */
-static int __init smc_findirq(struct smc_local *lp)
+static int __devinit smc_findirq(struct smc_local *lp)
 {
        void __iomem *ioaddr = lp->base;
        int timeout = 20;
        unsigned long cookie;
 
-       DBG(2, "%s: %s\n", CARDNAME, __FUNCTION__);
+       DBG(2, "%s: %s\n", CARDNAME, __func__);
 
        cookie = probe_irq_on();
 
@@ -1768,7 +1866,7 @@ static int __init smc_findirq(struct smc_local *lp)
  * o  actually GRAB the irq.
  * o  GRAB the region
  */
-static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
+static int __devinit smc_probe(struct net_device *dev, void __iomem *ioaddr,
                            unsigned long irq_flags)
 {
        struct smc_local *lp = netdev_priv(dev);
@@ -1776,9 +1874,8 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
        int retval;
        unsigned int val, revision_register;
        const char *version_string;
-       DECLARE_MAC_BUF(mac);
 
-       DBG(2, "%s: %s\n", CARDNAME, __FUNCTION__);
+       DBG(2, "%s: %s\n", CARDNAME, __func__);
 
        /* First, see if the high byte is 0x33 */
        val = SMC_CURRENT_BANK(lp);
@@ -1892,16 +1989,9 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
        /* Fill in the fields of the device structure with ethernet values. */
        ether_setup(dev);
 
-       dev->open = smc_open;
-       dev->stop = smc_close;
-       dev->hard_start_xmit = smc_hard_start_xmit;
-       dev->tx_timeout = smc_timeout;
        dev->watchdog_timeo = msecs_to_jiffies(watchdog);
-       dev->set_multicast_list = smc_set_multicast_list;
+       dev->netdev_ops = &smc_netdev_ops;
        dev->ethtool_ops = &smc_ethtool_ops;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-       dev->poll_controller = smc_poll_controller;
-#endif
 
        tasklet_init(&lp->tx_task, smc_hardware_send_pkt, (unsigned long)dev);
        INIT_WORK(&lp->phy_configure, smc_phy_configure);
@@ -1935,7 +2025,7 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
        }
 
        /* Grab the IRQ */
-       retval = request_irq(dev->irq, &smc_interrupt, irq_flags, dev->name, dev);
+       retval = request_irq(dev->irq, smc_interrupt, irq_flags, dev->name, dev);
        if (retval)
                goto err_out;
 
@@ -1961,7 +2051,8 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
                if (dev->dma != (unsigned char)-1)
                        printk(" DMA %d", dev->dma);
 
-               printk("%s%s\n", nowait ? " [nowait]" : "",
+               printk("%s%s\n",
+                       lp->cfg.flags & SMC91X_NOWAIT ? " [nowait]" : "",
                        THROTTLE_TX_PKTS ? " [throttle_tx]" : "");
 
                if (!is_valid_ether_addr(dev->dev_addr)) {
@@ -1969,8 +2060,8 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr,
                               "set using ifconfig\n", dev->name);
                } else {
                        /* Print the Ethernet address */
-                       printk("%s: Ethernet addr: %s\n",
-                              dev->name, print_mac(mac, dev->dev_addr));
+                       printk("%s: Ethernet addr: %pM\n",
+                              dev->name, dev->dev_addr);
                }
 
                if (lp->phy_type == 0) {
@@ -2057,7 +2148,7 @@ static int smc_request_attrib(struct platform_device *pdev,
                              struct net_device *ndev)
 {
        struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-attrib");
-       struct smc_local *lp = netdev_priv(ndev);
+       struct smc_local *lp __maybe_unused = netdev_priv(ndev);
 
        if (!res)
                return 0;
@@ -2072,7 +2163,7 @@ static void smc_release_attrib(struct platform_device *pdev,
                               struct net_device *ndev)
 {
        struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-attrib");
-       struct smc_local *lp = netdev_priv(ndev);
+       struct smc_local *lp __maybe_unused = netdev_priv(ndev);
 
        if (res)
                release_mem_region(res->start, ATTRIB_SIZE);
@@ -2123,7 +2214,7 @@ static void smc_release_datacs(struct platform_device *pdev, struct net_device *
  *     0 --> there is a device
  *     anything else, error
  */
-static int smc_drv_probe(struct platform_device *pdev)
+static int __devinit smc_drv_probe(struct platform_device *pdev)
 {
        struct smc91x_platdata *pd = pdev->dev.platform_data;
        struct smc_local *lp;
@@ -2157,6 +2248,11 @@ static int smc_drv_probe(struct platform_device *pdev)
                lp->cfg.flags |= (nowait) ? SMC91X_NOWAIT : 0;
        }
 
+       if (!lp->cfg.leda && !lp->cfg.ledb) {
+               lp->cfg.leda = RPC_LSA_DEFAULT;
+               lp->cfg.ledb = RPC_LSB_DEFAULT;
+       }
+
        ndev->dma = (unsigned char)-1;
 
        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-regs");
@@ -2181,7 +2277,7 @@ static int smc_drv_probe(struct platform_device *pdev)
 
        ndev->irq = ires->start;
 
-       if (ires->flags & IRQF_TRIGGER_MASK)
+       if (irq_flags == -1 || ires->flags & IRQF_TRIGGER_MASK)
                irq_flags = ires->flags & IRQF_TRIGGER_MASK;
 
        ret = smc_request_attrib(pdev, ndev);
@@ -2232,7 +2328,7 @@ static int smc_drv_probe(struct platform_device *pdev)
        return ret;
 }
 
-static int smc_drv_remove(struct platform_device *pdev)
+static int __devexit smc_drv_remove(struct platform_device *pdev)
 {
        struct net_device *ndev = platform_get_drvdata(pdev);
        struct smc_local *lp = netdev_priv(ndev);
@@ -2263,9 +2359,10 @@ static int smc_drv_remove(struct platform_device *pdev)
        return 0;
 }
 
-static int smc_drv_suspend(struct platform_device *dev, pm_message_t state)
+static int smc_drv_suspend(struct device *dev)
 {
-       struct net_device *ndev = platform_get_drvdata(dev);
+       struct platform_device *pdev = to_platform_device(dev);
+       struct net_device *ndev = platform_get_drvdata(pdev);
 
        if (ndev) {
                if (netif_running(ndev)) {
@@ -2277,13 +2374,14 @@ static int smc_drv_suspend(struct platform_device *dev, pm_message_t state)
        return 0;
 }
 
-static int smc_drv_resume(struct platform_device *dev)
+static int smc_drv_resume(struct device *dev)
 {
-       struct net_device *ndev = platform_get_drvdata(dev);
+       struct platform_device *pdev = to_platform_device(dev);
+       struct net_device *ndev = platform_get_drvdata(pdev);
 
        if (ndev) {
                struct smc_local *lp = netdev_priv(ndev);
-               smc_enable_device(dev);
+               smc_enable_device(pdev);
                if (netif_running(ndev)) {
                        smc_reset(ndev);
                        smc_enable(ndev);
@@ -2295,28 +2393,23 @@ static int smc_drv_resume(struct platform_device *dev)
        return 0;
 }
 
-static struct platform_driver smc_driver = {
-       .probe          = smc_drv_probe,
-       .remove         = smc_drv_remove,
+static struct dev_pm_ops smc_drv_pm_ops = {
        .suspend        = smc_drv_suspend,
        .resume         = smc_drv_resume,
+};
+
+static struct platform_driver smc_driver = {
+       .probe          = smc_drv_probe,
+       .remove         = __devexit_p(smc_drv_remove),
        .driver         = {
                .name   = CARDNAME,
                .owner  = THIS_MODULE,
+               .pm     = &smc_drv_pm_ops,
        },
 };
 
 static int __init smc_init(void)
 {
-#ifdef MODULE
-#ifdef CONFIG_ISA
-       if (io == -1)
-               printk(KERN_WARNING
-                       "%s: You shouldn't use auto-probing with insmod!\n",
-                       CARDNAME);
-#endif
-#endif
-
        return platform_driver_register(&smc_driver);
 }