Lines Matching refs:pdata
75 u32 (*reg_read)(struct smsc911x_data *pdata, u32 reg);
76 void (*reg_write)(struct smsc911x_data *pdata, u32 reg, u32 val);
77 void (*rx_readfifo)(struct smsc911x_data *pdata,
79 void (*tx_writefifo)(struct smsc911x_data *pdata,
145 #define __smsc_shift(pdata, reg) ((reg) << ((pdata)->config.shift))
147 static inline u32 __smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
149 if (pdata->config.flags & SMSC911X_USE_32BIT)
150 return readl(pdata->ioaddr + reg);
152 if (pdata->config.flags & SMSC911X_USE_16BIT)
153 return ((readw(pdata->ioaddr + reg) & 0xFFFF) |
154 ((readw(pdata->ioaddr + reg + 2) & 0xFFFF) << 16));
161 __smsc911x_reg_read_shift(struct smsc911x_data *pdata, u32 reg)
163 if (pdata->config.flags & SMSC911X_USE_32BIT)
164 return readl(pdata->ioaddr + __smsc_shift(pdata, reg));
166 if (pdata->config.flags & SMSC911X_USE_16BIT)
167 return (readw(pdata->ioaddr +
168 __smsc_shift(pdata, reg)) & 0xFFFF) |
169 ((readw(pdata->ioaddr +
170 __smsc_shift(pdata, reg + 2)) & 0xFFFF) << 16);
176 static inline u32 smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
181 spin_lock_irqsave(&pdata->dev_lock, flags);
182 data = pdata->ops->reg_read(pdata, reg);
183 spin_unlock_irqrestore(&pdata->dev_lock, flags);
188 static inline void __smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg,
191 if (pdata->config.flags & SMSC911X_USE_32BIT) {
192 writel(val, pdata->ioaddr + reg);
196 if (pdata->config.flags & SMSC911X_USE_16BIT) {
197 writew(val & 0xFFFF, pdata->ioaddr + reg);
198 writew((val >> 16) & 0xFFFF, pdata->ioaddr + reg + 2);
206 __smsc911x_reg_write_shift(struct smsc911x_data *pdata, u32 reg, u32 val)
208 if (pdata->config.flags & SMSC911X_USE_32BIT) {
209 writel(val, pdata->ioaddr + __smsc_shift(pdata, reg));
213 if (pdata->config.flags & SMSC911X_USE_16BIT) {
215 pdata->ioaddr + __smsc_shift(pdata, reg));
217 pdata->ioaddr + __smsc_shift(pdata, reg + 2));
224 static inline void smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg,
229 spin_lock_irqsave(&pdata->dev_lock, flags);
230 pdata->ops->reg_write(pdata, reg, val);
231 spin_unlock_irqrestore(&pdata->dev_lock, flags);
236 smsc911x_tx_writefifo(struct smsc911x_data *pdata, unsigned int *buf,
241 spin_lock_irqsave(&pdata->dev_lock, flags);
243 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
245 __smsc911x_reg_write(pdata, TX_DATA_FIFO,
250 if (pdata->config.flags & SMSC911X_USE_32BIT) {
251 iowrite32_rep(pdata->ioaddr + TX_DATA_FIFO, buf, wordcount);
255 if (pdata->config.flags & SMSC911X_USE_16BIT) {
257 __smsc911x_reg_write(pdata, TX_DATA_FIFO, *buf++);
263 spin_unlock_irqrestore(&pdata->dev_lock, flags);
268 smsc911x_tx_writefifo_shift(struct smsc911x_data *pdata, unsigned int *buf,
273 spin_lock_irqsave(&pdata->dev_lock, flags);
275 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
277 __smsc911x_reg_write_shift(pdata, TX_DATA_FIFO,
282 if (pdata->config.flags & SMSC911X_USE_32BIT) {
283 iowrite32_rep(pdata->ioaddr + __smsc_shift(pdata,
288 if (pdata->config.flags & SMSC911X_USE_16BIT) {
290 __smsc911x_reg_write_shift(pdata,
297 spin_unlock_irqrestore(&pdata->dev_lock, flags);
302 smsc911x_rx_readfifo(struct smsc911x_data *pdata, unsigned int *buf,
307 spin_lock_irqsave(&pdata->dev_lock, flags);
309 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
311 *buf++ = swab32(__smsc911x_reg_read(pdata,
316 if (pdata->config.flags & SMSC911X_USE_32BIT) {
317 ioread32_rep(pdata->ioaddr + RX_DATA_FIFO, buf, wordcount);
321 if (pdata->config.flags & SMSC911X_USE_16BIT) {
323 *buf++ = __smsc911x_reg_read(pdata, RX_DATA_FIFO);
329 spin_unlock_irqrestore(&pdata->dev_lock, flags);
334 smsc911x_rx_readfifo_shift(struct smsc911x_data *pdata, unsigned int *buf,
339 spin_lock_irqsave(&pdata->dev_lock, flags);
341 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
343 *buf++ = swab32(__smsc911x_reg_read_shift(pdata,
348 if (pdata->config.flags & SMSC911X_USE_32BIT) {
349 ioread32_rep(pdata->ioaddr + __smsc_shift(pdata,
354 if (pdata->config.flags & SMSC911X_USE_16BIT) {
356 *buf++ = __smsc911x_reg_read_shift(pdata,
363 spin_unlock_irqrestore(&pdata->dev_lock, flags);
372 struct smsc911x_data *pdata = netdev_priv(ndev);
375 ret = regulator_bulk_enable(ARRAY_SIZE(pdata->supplies),
376 pdata->supplies);
381 if (!IS_ERR(pdata->clk)) {
382 ret = clk_prepare_enable(pdata->clk);
396 struct smsc911x_data *pdata = netdev_priv(ndev);
399 ret = regulator_bulk_disable(ARRAY_SIZE(pdata->supplies),
400 pdata->supplies);
402 if (!IS_ERR(pdata->clk))
403 clk_disable_unprepare(pdata->clk);
418 struct smsc911x_data *pdata = netdev_priv(ndev);
422 pdata->supplies[0].supply = "vdd33a";
423 pdata->supplies[1].supply = "vddvario";
425 ARRAY_SIZE(pdata->supplies),
426 pdata->supplies);
439 pdata->reset_gpiod = devm_gpiod_get_optional(&pdev->dev,
444 pdata->clk = clk_get(&pdev->dev, NULL);
445 if (IS_ERR(pdata->clk))
447 PTR_ERR(pdata->clk));
459 struct smsc911x_data *pdata = netdev_priv(ndev);
462 regulator_bulk_free(ARRAY_SIZE(pdata->supplies),
463 pdata->supplies);
466 if (!IS_ERR(pdata->clk)) {
467 clk_put(pdata->clk);
468 pdata->clk = NULL;
474 static int smsc911x_mac_complete(struct smsc911x_data *pdata)
479 SMSC_ASSERT_MAC_LOCK(pdata);
482 val = smsc911x_reg_read(pdata, MAC_CSR_CMD);
486 SMSC_WARN(pdata, hw, "Timed out waiting for MAC not BUSY. "
492 static u32 smsc911x_mac_read(struct smsc911x_data *pdata, unsigned int offset)
496 SMSC_ASSERT_MAC_LOCK(pdata);
498 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
500 SMSC_WARN(pdata, hw, "MAC busy at entry");
505 smsc911x_reg_write(pdata, MAC_CSR_CMD, ((offset & 0xFF) |
509 temp = smsc911x_reg_read(pdata, BYTE_TEST);
512 if (likely(smsc911x_mac_complete(pdata) == 0))
513 return smsc911x_reg_read(pdata, MAC_CSR_DATA);
515 SMSC_WARN(pdata, hw, "MAC busy after read");
520 static void smsc911x_mac_write(struct smsc911x_data *pdata,
525 SMSC_ASSERT_MAC_LOCK(pdata);
527 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
529 SMSC_WARN(pdata, hw,
535 smsc911x_reg_write(pdata, MAC_CSR_DATA, val);
538 smsc911x_reg_write(pdata, MAC_CSR_CMD, ((offset & 0xFF) |
542 temp = smsc911x_reg_read(pdata, BYTE_TEST);
545 if (likely(smsc911x_mac_complete(pdata) == 0))
548 SMSC_WARN(pdata, hw, "smsc911x_mac_write failed, MAC busy after write");
554 struct smsc911x_data *pdata = bus->priv;
560 spin_lock_irqsave(&pdata->mac_lock, flags);
563 if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
564 SMSC_WARN(pdata, hw, "MII is busy in smsc911x_mii_read???");
571 smsc911x_mac_write(pdata, MII_ACC, addr);
575 if (!(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
576 reg = smsc911x_mac_read(pdata, MII_DATA);
580 SMSC_WARN(pdata, hw, "Timed out waiting for MII read to finish");
584 spin_unlock_irqrestore(&pdata->mac_lock, flags);
593 struct smsc911x_data *pdata = bus->priv;
599 spin_lock_irqsave(&pdata->mac_lock, flags);
602 if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
603 SMSC_WARN(pdata, hw, "MII is busy in smsc911x_mii_write???");
609 smsc911x_mac_write(pdata, MII_DATA, val);
614 smsc911x_mac_write(pdata, MII_ACC, addr);
618 if (!(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
623 SMSC_WARN(pdata, hw, "Timed out waiting for MII write to finish");
627 spin_unlock_irqrestore(&pdata->mac_lock, flags);
633 static void smsc911x_phy_enable_external(struct smsc911x_data *pdata)
635 unsigned int hwcfg = smsc911x_reg_read(pdata, HW_CFG);
640 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
645 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
650 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
654 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
660 static void smsc911x_phy_initialise_external(struct smsc911x_data *pdata)
662 unsigned int hwcfg = smsc911x_reg_read(pdata, HW_CFG);
664 if (pdata->config.flags & SMSC911X_FORCE_INTERNAL_PHY) {
665 SMSC_TRACE(pdata, hw, "Forcing internal PHY");
666 pdata->using_extphy = 0;
667 } else if (pdata->config.flags & SMSC911X_FORCE_EXTERNAL_PHY) {
668 SMSC_TRACE(pdata, hw, "Forcing external PHY");
669 smsc911x_phy_enable_external(pdata);
670 pdata->using_extphy = 1;
672 SMSC_TRACE(pdata, hw,
674 smsc911x_phy_enable_external(pdata);
675 pdata->using_extphy = 1;
677 SMSC_TRACE(pdata, hw,
679 pdata->using_extphy = 0;
684 static unsigned int smsc911x_tx_get_txstatus(struct smsc911x_data *pdata)
687 smsc911x_reg_read(pdata, TX_FIFO_INF) & TX_FIFO_INF_TSUSED_;
690 result = smsc911x_reg_read(pdata, TX_STATUS_FIFO);
696 static unsigned int smsc911x_rx_get_rxstatus(struct smsc911x_data *pdata)
699 smsc911x_reg_read(pdata, RX_FIFO_INF) & RX_FIFO_INF_RXSUSED_;
702 result = smsc911x_reg_read(pdata, RX_STATUS_FIFO);
708 static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
723 memset(pdata->loopback_rx_pkt, 0, MIN_PACKET_SIZE);
726 txcmd_a = (u32)((ulong)pdata->loopback_tx_pkt & 0x03) << 16;
732 smsc911x_reg_write(pdata, TX_DATA_FIFO, txcmd_a);
733 smsc911x_reg_write(pdata, TX_DATA_FIFO, txcmd_b);
735 bufp = (ulong)pdata->loopback_tx_pkt & (~0x3);
737 wrsz += (u32)((ulong)pdata->loopback_tx_pkt & 0x3);
740 pdata->ops->tx_writefifo(pdata, (unsigned int *)bufp, wrsz);
746 status = smsc911x_tx_get_txstatus(pdata);
750 SMSC_WARN(pdata, hw,
755 SMSC_WARN(pdata, hw,
764 status = smsc911x_rx_get_rxstatus(pdata);
768 SMSC_WARN(pdata, hw,
773 SMSC_WARN(pdata, hw,
779 bufp = (ulong)pdata->loopback_rx_pkt;
781 rdsz += (u32)((ulong)pdata->loopback_rx_pkt & 0x3);
784 pdata->ops->rx_readfifo(pdata, (unsigned int *)bufp, rdsz);
787 SMSC_WARN(pdata, hw, "Unexpected packet size "
794 if (pdata->loopback_tx_pkt[j]
795 != pdata->loopback_rx_pkt[j]) {
801 SMSC_TRACE(pdata, hw, "Successfully verified "
805 SMSC_WARN(pdata, hw, "Data mismatch "
814 static int smsc911x_phy_reset(struct smsc911x_data *pdata)
819 temp = smsc911x_reg_read(pdata, PMT_CTRL);
820 smsc911x_reg_write(pdata, PMT_CTRL, temp | PMT_CTRL_PHY_RST_);
823 temp = smsc911x_reg_read(pdata, PMT_CTRL);
827 SMSC_WARN(pdata, hw, "PHY reset failed to complete");
840 struct smsc911x_data *pdata = netdev_priv(dev);
847 eth_broadcast_addr(pdata->loopback_tx_pkt);
851 pdata->loopback_tx_pkt[i] = (char)i;
854 pdata->loopback_tx_pkt[12] = 0x00;
855 pdata->loopback_tx_pkt[13] = 0x00;
858 pdata->loopback_tx_pkt[i] = (char)i;
860 val = smsc911x_reg_read(pdata, HW_CFG);
863 smsc911x_reg_write(pdata, HW_CFG, val);
865 smsc911x_reg_write(pdata, TX_CFG, TX_CFG_TX_ON_);
866 smsc911x_reg_write(pdata, RX_CFG,
867 (u32)((ulong)pdata->loopback_rx_pkt & 0x03) << 8);
875 spin_lock_irqsave(&pdata->mac_lock, flags);
876 smsc911x_mac_write(pdata, MAC_CR, MAC_CR_FDPX_
878 spin_unlock_irqrestore(&pdata->mac_lock, flags);
880 if (smsc911x_phy_check_loopbackpkt(pdata) == 0) {
884 pdata->resetcount++;
887 spin_lock_irqsave(&pdata->mac_lock, flags);
888 smsc911x_mac_write(pdata, MAC_CR, 0);
889 spin_unlock_irqrestore(&pdata->mac_lock, flags);
891 smsc911x_phy_reset(pdata);
895 spin_lock_irqsave(&pdata->mac_lock, flags);
896 smsc911x_mac_write(pdata, MAC_CR, 0);
897 spin_unlock_irqrestore(&pdata->mac_lock, flags);
902 smsc911x_reg_write(pdata, TX_CFG, 0);
903 smsc911x_reg_write(pdata, RX_CFG, 0);
909 static void smsc911x_phy_update_flowcontrol(struct smsc911x_data *pdata)
911 struct net_device *ndev = pdata->dev;
913 u32 afc = smsc911x_reg_read(pdata, AFC_CFG);
932 SMSC_TRACE(pdata, hw, "rx pause %s, tx pause %s",
936 SMSC_TRACE(pdata, hw, "half duplex");
941 spin_lock_irqsave(&pdata->mac_lock, flags);
942 smsc911x_mac_write(pdata, FLOW, flow);
943 spin_unlock_irqrestore(&pdata->mac_lock, flags);
945 smsc911x_reg_write(pdata, AFC_CFG, afc);
952 struct smsc911x_data *pdata = netdev_priv(dev);
957 if (phy_dev->duplex != pdata->last_duplex) {
959 SMSC_TRACE(pdata, hw, "duplex state has changed");
961 spin_lock_irqsave(&pdata->mac_lock, flags);
962 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
964 SMSC_TRACE(pdata, hw,
968 SMSC_TRACE(pdata, hw,
972 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
973 spin_unlock_irqrestore(&pdata->mac_lock, flags);
975 smsc911x_phy_update_flowcontrol(pdata);
976 pdata->last_duplex = phy_dev->duplex;
980 if (carrier != pdata->last_carrier) {
981 SMSC_TRACE(pdata, hw, "carrier state has changed");
983 SMSC_TRACE(pdata, hw, "configuring for carrier OK");
984 if ((pdata->gpio_orig_setting & GPIO_CFG_LED1_EN_) &&
985 (!pdata->using_extphy)) {
987 pdata->gpio_setting = pdata->gpio_orig_setting;
988 smsc911x_reg_write(pdata, GPIO_CFG,
989 pdata->gpio_setting);
992 SMSC_TRACE(pdata, hw, "configuring for no carrier");
995 pdata->gpio_setting = smsc911x_reg_read(pdata,
997 if ((pdata->gpio_setting & GPIO_CFG_LED1_EN_) &&
998 (!pdata->using_extphy)) {
1001 pdata->gpio_orig_setting = pdata->gpio_setting;
1003 pdata->gpio_setting &= ~GPIO_CFG_LED1_EN_;
1004 pdata->gpio_setting |= (GPIO_CFG_GPIOBUF0_
1007 smsc911x_reg_write(pdata, GPIO_CFG,
1008 pdata->gpio_setting);
1011 pdata->last_carrier = carrier;
1017 struct smsc911x_data *pdata = netdev_priv(dev);
1022 phydev = phy_find_first(pdata->mii_bus);
1028 SMSC_TRACE(pdata, probe, "PHY: addr %d, phy_id 0x%08X",
1032 pdata->config.phy_interface);
1046 pdata->last_duplex = -1;
1047 pdata->last_carrier = -1;
1051 SMSC_WARN(pdata, hw, "Failed Loop Back Test");
1055 SMSC_TRACE(pdata, hw, "Passed Loop Back Test");
1058 SMSC_TRACE(pdata, hw, "phy initialised successfully");
1065 struct smsc911x_data *pdata = netdev_priv(dev);
1069 pdata->mii_bus = mdiobus_alloc();
1070 if (!pdata->mii_bus) {
1075 pdata->mii_bus->name = SMSC_MDIONAME;
1076 snprintf(pdata->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
1078 pdata->mii_bus->priv = pdata;
1079 pdata->mii_bus->read = smsc911x_mii_read;
1080 pdata->mii_bus->write = smsc911x_mii_write;
1082 pdata->mii_bus->parent = &pdev->dev;
1084 switch (pdata->idrev & 0xFFFF0000) {
1090 smsc911x_phy_initialise_external(pdata);
1093 SMSC_TRACE(pdata, hw, "External PHY is not supported, "
1095 pdata->using_extphy = 0;
1099 if (!pdata->using_extphy) {
1101 pdata->mii_bus->phy_mask = ~(1 << 1);
1104 if (mdiobus_register(pdata->mii_bus)) {
1105 SMSC_WARN(pdata, probe, "Error registering mii bus");
1109 phydev = phy_find_first(pdata->mii_bus);
1116 mdiobus_free(pdata->mii_bus);
1122 static unsigned int smsc911x_tx_get_txstatcount(struct smsc911x_data *pdata)
1124 return (smsc911x_reg_read(pdata, TX_FIFO_INF)
1131 struct smsc911x_data *pdata = netdev_priv(dev);
1134 while ((tx_stat = smsc911x_tx_get_txstatus(pdata)) != 0) {
1143 SMSC_WARN(pdata, hw, "Packet tag reserved bit is high");
1192 smsc911x_rx_fastforward(struct smsc911x_data *pdata, unsigned int pktwords)
1197 smsc911x_reg_write(pdata, RX_DP_CTRL, RX_DP_CTRL_RX_FFWD_);
1200 val = smsc911x_reg_read(pdata, RX_DP_CTRL);
1204 SMSC_WARN(pdata, hw, "Timed out waiting for "
1208 smsc911x_reg_read(pdata, RX_DATA_FIFO);
1215 struct smsc911x_data *pdata =
1217 struct net_device *dev = pdata->dev;
1224 unsigned int rxstat = smsc911x_rx_get_rxstatus(pdata);
1230 smsc911x_reg_write(pdata, INT_STS, INT_STS_RSFL_);
1232 temp = smsc911x_reg_read(pdata, INT_EN);
1234 smsc911x_reg_write(pdata, INT_EN, temp);
1247 SMSC_WARN(pdata, rx_err,
1251 smsc911x_rx_fastforward(pdata, pktwords);
1258 SMSC_WARN(pdata, rx_err,
1261 smsc911x_rx_fastforward(pdata, pktwords);
1266 pdata->ops->rx_readfifo(pdata,
1293 static void smsc911x_rx_multicast_update(struct smsc911x_data *pdata)
1299 SMSC_ASSERT_MAC_LOCK(pdata);
1301 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
1302 mac_cr |= pdata->set_bits_mask;
1303 mac_cr &= ~(pdata->clear_bits_mask);
1304 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
1305 smsc911x_mac_write(pdata, HASHH, pdata->hashhi);
1306 smsc911x_mac_write(pdata, HASHL, pdata->hashlo);
1307 SMSC_TRACE(pdata, hw, "maccr 0x%08X, HASHH 0x%08X, HASHL 0x%08X",
1308 mac_cr, pdata->hashhi, pdata->hashlo);
1311 static void smsc911x_rx_multicast_update_workaround(struct smsc911x_data *pdata)
1322 spin_lock(&pdata->mac_lock);
1325 if (smsc911x_mac_read(pdata, MAC_CR) & MAC_CR_RXEN_)
1326 SMSC_WARN(pdata, drv, "Rx not stopped");
1329 smsc911x_rx_multicast_update(pdata);
1332 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
1334 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
1336 pdata->multicast_update_pending = 0;
1338 spin_unlock(&pdata->mac_lock);
1341 static int smsc911x_phy_general_power_up(struct smsc911x_data *pdata)
1343 struct net_device *ndev = pdata->dev;
1359 SMSC_WARN(pdata, drv, "Failed reading PHY control reg");
1369 SMSC_WARN(pdata, drv, "Failed writing PHY control reg");
1379 static int smsc911x_phy_disable_energy_detect(struct smsc911x_data *pdata)
1381 struct net_device *ndev = pdata->dev;
1391 SMSC_WARN(pdata, drv, "Failed reading PHY control reg");
1402 SMSC_WARN(pdata, drv, "Failed writing PHY control reg");
1412 static int smsc911x_phy_enable_energy_detect(struct smsc911x_data *pdata)
1414 struct net_device *ndev = pdata->dev;
1424 SMSC_WARN(pdata, drv, "Failed reading PHY control reg");
1435 SMSC_WARN(pdata, drv, "Failed writing PHY control reg");
1442 static int smsc911x_soft_reset(struct smsc911x_data *pdata)
1454 ret = smsc911x_phy_general_power_up(pdata);
1456 SMSC_WARN(pdata, drv, "Failed to power-up the PHY chip");
1466 if (pdata->generation == 4) {
1467 ret = smsc911x_phy_disable_energy_detect(pdata);
1470 SMSC_WARN(pdata, drv, "Failed to wakeup the PHY chip");
1475 if ((pdata->idrev & 0xFFFF0000) == LAN9250) {
1482 smsc911x_reg_write(pdata, reset_offset, reset_mask);
1488 temp = smsc911x_reg_read(pdata, reset_offset);
1492 SMSC_WARN(pdata, drv, "Failed to complete reset");
1496 if (pdata->generation == 4) {
1497 ret = smsc911x_phy_enable_energy_detect(pdata);
1500 SMSC_WARN(pdata, drv, "Failed to wakeup the PHY chip");
1510 smsc911x_set_hw_mac_address(struct smsc911x_data *pdata, const u8 dev_addr[6])
1516 SMSC_ASSERT_MAC_LOCK(pdata);
1518 smsc911x_mac_write(pdata, ADDRH, mac_high16);
1519 smsc911x_mac_write(pdata, ADDRL, mac_low32);
1524 struct smsc911x_data *pdata = netdev_priv(dev);
1526 smsc911x_reg_write(pdata, INT_EN, 0);
1527 smsc911x_reg_write(pdata, INT_STS, 0xFFFFFFFF);
1533 struct smsc911x_data *pdata = netdev_priv(dev);
1534 u32 intsts = smsc911x_reg_read(pdata, INT_STS);
1535 u32 inten = smsc911x_reg_read(pdata, INT_EN);
1540 temp = smsc911x_reg_read(pdata, INT_EN);
1542 smsc911x_reg_write(pdata, INT_EN, temp);
1543 smsc911x_reg_write(pdata, INT_STS, INT_STS_SW_INT_);
1544 pdata->software_irq_signal = 1;
1552 SMSC_TRACE(pdata, intr, "RX Stop interrupt");
1553 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXSTOP_INT_);
1554 if (pdata->multicast_update_pending)
1555 smsc911x_rx_multicast_update_workaround(pdata);
1560 temp = smsc911x_reg_read(pdata, FIFO_INT);
1562 smsc911x_reg_write(pdata, FIFO_INT, temp);
1563 smsc911x_reg_write(pdata, INT_STS, INT_STS_TDFA_);
1569 SMSC_TRACE(pdata, intr, "RX Error interrupt");
1570 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXE_);
1575 if (likely(napi_schedule_prep(&pdata->napi))) {
1577 temp = smsc911x_reg_read(pdata, INT_EN);
1579 smsc911x_reg_write(pdata, INT_EN, temp);
1581 __napi_schedule(&pdata->napi);
1583 SMSC_WARN(pdata, rx_err, "napi_schedule_prep failed");
1593 struct smsc911x_data *pdata = netdev_priv(dev);
1606 SMSC_WARN(pdata, probe, "Error starting phy");
1612 retval = smsc911x_soft_reset(pdata);
1614 SMSC_WARN(pdata, hw, "soft reset failed");
1618 smsc911x_reg_write(pdata, HW_CFG, 0x00050000);
1619 smsc911x_reg_write(pdata, AFC_CFG, 0x006E3740);
1622 spin_lock_irq(&pdata->mac_lock);
1623 smsc911x_mac_write(pdata, VLAN1, ETH_P_8021Q);
1624 spin_unlock_irq(&pdata->mac_lock);
1628 while ((smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) &&
1634 SMSC_WARN(pdata, ifup,
1637 smsc911x_reg_write(pdata, GPIO_CFG, 0x70070000);
1641 spin_lock_irq(&pdata->mac_lock);
1642 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
1643 spin_unlock_irq(&pdata->mac_lock);
1651 if (pdata->config.irq_polarity) {
1652 SMSC_TRACE(pdata, ifup, "irq polarity: active high");
1655 SMSC_TRACE(pdata, ifup, "irq polarity: active low");
1658 if (pdata->config.irq_type) {
1659 SMSC_TRACE(pdata, ifup, "irq type: push-pull");
1662 SMSC_TRACE(pdata, ifup, "irq type: open drain");
1665 smsc911x_reg_write(pdata, INT_CFG, intcfg);
1667 SMSC_TRACE(pdata, ifup, "Testing irq handler using IRQ %d", dev->irq);
1668 pdata->software_irq_signal = 0;
1675 SMSC_WARN(pdata, probe,
1680 temp = smsc911x_reg_read(pdata, INT_EN);
1682 smsc911x_reg_write(pdata, INT_EN, temp);
1686 if (pdata->software_irq_signal)
1691 if (!pdata->software_irq_signal) {
1697 SMSC_TRACE(pdata, ifup, "IRQ handler passed test using IRQ %d",
1701 (unsigned long)pdata->ioaddr, dev->irq);
1704 pdata->last_duplex = -1;
1705 pdata->last_carrier = -1;
1710 temp = smsc911x_reg_read(pdata, HW_CFG);
1714 smsc911x_reg_write(pdata, HW_CFG, temp);
1716 temp = smsc911x_reg_read(pdata, FIFO_INT);
1719 smsc911x_reg_write(pdata, FIFO_INT, temp);
1722 smsc911x_reg_write(pdata, RX_CFG, (NET_IP_ALIGN << 8));
1725 napi_enable(&pdata->napi);
1727 temp = smsc911x_reg_read(pdata, INT_EN);
1729 smsc911x_reg_write(pdata, INT_EN, temp);
1731 spin_lock_irq(&pdata->mac_lock);
1732 temp = smsc911x_mac_read(pdata, MAC_CR);
1734 smsc911x_mac_write(pdata, MAC_CR, temp);
1735 spin_unlock_irq(&pdata->mac_lock);
1737 smsc911x_reg_write(pdata, TX_CFG, TX_CFG_TX_ON_);
1754 struct smsc911x_data *pdata = netdev_priv(dev);
1758 temp = smsc911x_reg_read(pdata, INT_CFG);
1760 smsc911x_reg_write(pdata, INT_CFG, temp);
1764 napi_disable(&pdata->napi);
1767 dev->stats.rx_dropped += smsc911x_reg_read(pdata, RX_DROP);
1780 SMSC_TRACE(pdata, ifdown, "Interface stopped");
1788 struct smsc911x_data *pdata = netdev_priv(dev);
1796 freespace = smsc911x_reg_read(pdata, TX_FIFO_INF) & TX_FIFO_INF_TDFREE_;
1799 SMSC_WARN(pdata, tx_err,
1810 smsc911x_reg_write(pdata, TX_DATA_FIFO, tx_cmd_a);
1811 smsc911x_reg_write(pdata, TX_DATA_FIFO, tx_cmd_b);
1818 pdata->ops->tx_writefifo(pdata, (unsigned int *)bufp, wrsz);
1823 if (unlikely(smsc911x_tx_get_txstatcount(pdata) >= 30))
1828 temp = smsc911x_reg_read(pdata, FIFO_INT);
1831 smsc911x_reg_write(pdata, FIFO_INT, temp);
1840 struct smsc911x_data *pdata = netdev_priv(dev);
1842 dev->stats.rx_dropped += smsc911x_reg_read(pdata, RX_DROP);
1849 struct smsc911x_data *pdata = netdev_priv(dev);
1854 pdata->set_bits_mask = MAC_CR_PRMS_;
1855 pdata->clear_bits_mask = (MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
1856 pdata->hashhi = 0;
1857 pdata->hashlo = 0;
1860 pdata->set_bits_mask = MAC_CR_MCPAS_;
1861 pdata->clear_bits_mask = (MAC_CR_PRMS_ | MAC_CR_HPFILT_);
1862 pdata->hashhi = 0;
1863 pdata->hashlo = 0;
1870 pdata->set_bits_mask = MAC_CR_HPFILT_;
1871 pdata->clear_bits_mask = (MAC_CR_PRMS_ | MAC_CR_MCPAS_);
1883 pdata->hashhi = hash_high;
1884 pdata->hashlo = hash_low;
1887 pdata->set_bits_mask = 0;
1888 pdata->clear_bits_mask =
1890 pdata->hashhi = 0;
1891 pdata->hashlo = 0;
1894 spin_lock_irqsave(&pdata->mac_lock, flags);
1896 if (pdata->generation <= 1) {
1899 if (!pdata->multicast_update_pending) {
1901 SMSC_TRACE(pdata, hw, "scheduling mcast update");
1902 pdata->multicast_update_pending = 1;
1906 temp = smsc911x_mac_read(pdata, MAC_CR);
1908 smsc911x_mac_write(pdata, MAC_CR, temp);
1915 smsc911x_rx_multicast_update(pdata);
1918 spin_unlock_irqrestore(&pdata->mac_lock, flags);
1932 struct smsc911x_data *pdata = netdev_priv(dev);
1938 if (pdata->generation <= 1 && netif_running(dev))
1946 spin_lock_irq(&pdata->mac_lock);
1947 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
1948 spin_unlock_irq(&pdata->mac_lock);
1966 struct smsc911x_data *pdata = netdev_priv(dev);
1967 return pdata->msg_enable;
1972 struct smsc911x_data *pdata = netdev_priv(dev);
1973 pdata->msg_enable = level;
1986 struct smsc911x_data *pdata = netdev_priv(dev);
1993 regs->version = pdata->idrev;
1995 data[j++] = smsc911x_reg_read(pdata, i);
1998 spin_lock_irqsave(&pdata->mac_lock, flags);
1999 data[j++] = smsc911x_mac_read(pdata, i);
2000 spin_unlock_irqrestore(&pdata->mac_lock, flags);
2008 static void smsc911x_eeprom_enable_access(struct smsc911x_data *pdata)
2010 unsigned int temp = smsc911x_reg_read(pdata, GPIO_CFG);
2012 smsc911x_reg_write(pdata, GPIO_CFG, temp);
2016 static int smsc911x_eeprom_send_cmd(struct smsc911x_data *pdata, u32 op)
2021 SMSC_TRACE(pdata, drv, "op 0x%08x", op);
2022 if (smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) {
2023 SMSC_WARN(pdata, drv, "Busy at start");
2028 smsc911x_reg_write(pdata, E2P_CMD, e2cmd);
2032 e2cmd = smsc911x_reg_read(pdata, E2P_CMD);
2036 SMSC_TRACE(pdata, drv, "TIMED OUT");
2041 SMSC_TRACE(pdata, drv, "Error occurred during eeprom operation");
2048 static int smsc911x_eeprom_read_location(struct smsc911x_data *pdata,
2054 SMSC_TRACE(pdata, drv, "address 0x%x", address);
2055 ret = smsc911x_eeprom_send_cmd(pdata, op);
2058 data[address] = smsc911x_reg_read(pdata, E2P_DATA);
2063 static int smsc911x_eeprom_write_location(struct smsc911x_data *pdata,
2069 SMSC_TRACE(pdata, drv, "address 0x%x, data 0x%x", address, data);
2070 ret = smsc911x_eeprom_send_cmd(pdata, op);
2074 smsc911x_reg_write(pdata, E2P_DATA, (u32)data);
2077 smsc911x_reg_read(pdata, BYTE_TEST);
2079 ret = smsc911x_eeprom_send_cmd(pdata, op);
2093 struct smsc911x_data *pdata = netdev_priv(dev);
2098 smsc911x_eeprom_enable_access(pdata);
2102 int ret = smsc911x_eeprom_read_location(pdata, i, eeprom_data);
2118 struct smsc911x_data *pdata = netdev_priv(dev);
2120 smsc911x_eeprom_enable_access(pdata);
2121 smsc911x_eeprom_send_cmd(pdata, E2P_CMD_EPC_CMD_EWEN_);
2122 ret = smsc911x_eeprom_write_location(pdata, eeprom->offset, *data);
2123 smsc911x_eeprom_send_cmd(pdata, E2P_CMD_EPC_CMD_EWDS_);
2164 struct smsc911x_data *pdata = netdev_priv(dev);
2165 u32 mac_high16 = smsc911x_mac_read(pdata, ADDRH);
2166 u32 mac_low32 = smsc911x_mac_read(pdata, ADDRL);
2181 struct smsc911x_data *pdata = netdev_priv(dev);
2185 SMSC_TRACE(pdata, probe, "Driver Parameters:");
2186 SMSC_TRACE(pdata, probe, "LAN base: 0x%08lX",
2187 (unsigned long)pdata->ioaddr);
2188 SMSC_TRACE(pdata, probe, "IRQ: %d", dev->irq);
2189 SMSC_TRACE(pdata, probe, "PHY will be autodetected.");
2191 spin_lock_init(&pdata->dev_lock);
2192 spin_lock_init(&pdata->mac_lock);
2194 if (pdata->ioaddr == NULL) {
2195 SMSC_WARN(pdata, probe, "pdata->ioaddr: 0x00000000");
2215 while (!(smsc911x_reg_read(pdata, PMT_CTRL) & mask) && --to)
2224 byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
2225 SMSC_TRACE(pdata, probe, "BYTE_TEST: 0x%08X", byte_test);
2227 SMSC_TRACE(pdata, probe, "BYTE_TEST looks swapped, "
2229 smsc911x_reg_write(pdata, WORD_SWAP, 0xffffffff);
2233 byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
2235 byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
2239 SMSC_WARN(pdata, drv, "BYTE_TEST: 0x%08X", byte_test);
2241 SMSC_WARN(pdata, probe,
2243 SMSC_TRACE(pdata, probe,
2251 pdata->generation = 0;
2253 pdata->idrev = smsc911x_reg_read(pdata, ID_REV);
2254 switch (pdata->idrev & 0xFFFF0000) {
2261 pdata->generation = pdata->idrev & 0x0000FFFF;
2269 pdata->generation = 3;
2278 pdata->generation = 4;
2282 SMSC_WARN(pdata, probe, "LAN911x not identified, idrev: 0x%08X",
2283 pdata->idrev);
2287 SMSC_TRACE(pdata, probe,
2289 pdata->idrev, pdata->generation);
2291 if (pdata->generation == 0)
2292 SMSC_WARN(pdata, probe,
2298 if (pdata->config.flags & SMSC911X_SAVE_MAC_ADDRESS) {
2299 spin_lock_irq(&pdata->mac_lock);
2301 spin_unlock_irq(&pdata->mac_lock);
2305 if (smsc911x_phy_reset(pdata) || smsc911x_soft_reset(pdata))
2309 netif_napi_add_weight(dev, &pdata->napi, smsc911x_poll,
2320 struct smsc911x_data *pdata;
2325 pdata = netdev_priv(dev);
2326 BUG_ON(!pdata);
2327 BUG_ON(!pdata->ioaddr);
2329 SMSC_TRACE(pdata, ifdown, "Stopping driver");
2333 mdiobus_unregister(pdata->mii_bus);
2334 mdiobus_free(pdata->mii_bus);
2343 iounmap(pdata->ioaddr);
2416 struct smsc911x_data *pdata;
2456 pdata = netdev_priv(dev);
2458 pdata->ioaddr = ioremap(res->start, res_size);
2459 if (!pdata->ioaddr) {
2464 pdata->dev = dev;
2465 pdata->msg_enable = ((1 << debug) - 1);
2477 if (pdata->ioaddr == NULL) {
2478 SMSC_WARN(pdata, probe, "Error smsc911x base address invalid");
2483 retval = smsc911x_probe_config(&pdata->config, &pdev->dev);
2485 /* copy config parameters across to pdata */
2486 memcpy(&pdata->config, config, sizeof(pdata->config));
2491 SMSC_WARN(pdata, probe, "Error smsc911x config not found");
2496 pdata->ops = &standard_smsc911x_ops;
2498 if (pdata->config.shift)
2499 pdata->ops = &shifted_smsc911x_ops;
2512 SMSC_WARN(pdata, probe, "Error %i initialising mii", retval);
2518 SMSC_WARN(pdata, probe, "Error %i registering device", retval);
2521 SMSC_TRACE(pdata, probe,
2525 spin_lock_irq(&pdata->mac_lock);
2529 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
2530 SMSC_TRACE(pdata, probe,
2532 } else if (is_valid_ether_addr(pdata->config.mac)) {
2533 eth_hw_addr_set(dev, pdata->config.mac);
2534 SMSC_TRACE(pdata, probe,
2543 SMSC_TRACE(pdata, probe,
2548 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
2549 SMSC_TRACE(pdata, probe,
2554 spin_unlock_irq(&pdata->mac_lock);
2569 iounmap(pdata->ioaddr);
2587 struct smsc911x_data *pdata = netdev_priv(ndev);
2598 smsc911x_reg_write(pdata, PMT_CTRL,
2611 struct smsc911x_data *pdata = netdev_priv(ndev);
2621 smsc911x_reg_write(pdata, BYTE_TEST, 0);
2626 while (!(smsc911x_reg_read(pdata, PMT_CTRL) & PMT_CTRL_READY_) && --to)