Lines Matching refs:pdata
76 u32 (*reg_read)(struct smsc911x_data *pdata, u32 reg);
77 void (*reg_write)(struct smsc911x_data *pdata, u32 reg, u32 val);
78 void (*rx_readfifo)(struct smsc911x_data *pdata,
80 void (*tx_writefifo)(struct smsc911x_data *pdata,
146 #define __smsc_shift(pdata, reg) ((reg) << ((pdata)->config.shift))
148 static inline u32 __smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
150 if (pdata->config.flags & SMSC911X_USE_32BIT)
151 return readl(pdata->ioaddr + reg);
153 if (pdata->config.flags & SMSC911X_USE_16BIT)
154 return ((readw(pdata->ioaddr + reg) & 0xFFFF) |
155 ((readw(pdata->ioaddr + reg + 2) & 0xFFFF) << 16));
162 __smsc911x_reg_read_shift(struct smsc911x_data *pdata, u32 reg)
164 if (pdata->config.flags & SMSC911X_USE_32BIT)
165 return readl(pdata->ioaddr + __smsc_shift(pdata, reg));
167 if (pdata->config.flags & SMSC911X_USE_16BIT)
168 return (readw(pdata->ioaddr +
169 __smsc_shift(pdata, reg)) & 0xFFFF) |
170 ((readw(pdata->ioaddr +
171 __smsc_shift(pdata, reg + 2)) & 0xFFFF) << 16);
177 static inline u32 smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
182 spin_lock_irqsave(&pdata->dev_lock, flags);
183 data = pdata->ops->reg_read(pdata, reg);
184 spin_unlock_irqrestore(&pdata->dev_lock, flags);
189 static inline void __smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg,
192 if (pdata->config.flags & SMSC911X_USE_32BIT) {
193 writel(val, pdata->ioaddr + reg);
197 if (pdata->config.flags & SMSC911X_USE_16BIT) {
198 writew(val & 0xFFFF, pdata->ioaddr + reg);
199 writew((val >> 16) & 0xFFFF, pdata->ioaddr + reg + 2);
207 __smsc911x_reg_write_shift(struct smsc911x_data *pdata, u32 reg, u32 val)
209 if (pdata->config.flags & SMSC911X_USE_32BIT) {
210 writel(val, pdata->ioaddr + __smsc_shift(pdata, reg));
214 if (pdata->config.flags & SMSC911X_USE_16BIT) {
216 pdata->ioaddr + __smsc_shift(pdata, reg));
218 pdata->ioaddr + __smsc_shift(pdata, reg + 2));
225 static inline void smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg,
230 spin_lock_irqsave(&pdata->dev_lock, flags);
231 pdata->ops->reg_write(pdata, reg, val);
232 spin_unlock_irqrestore(&pdata->dev_lock, flags);
237 smsc911x_tx_writefifo(struct smsc911x_data *pdata, unsigned int *buf,
242 spin_lock_irqsave(&pdata->dev_lock, flags);
244 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
246 __smsc911x_reg_write(pdata, TX_DATA_FIFO,
251 if (pdata->config.flags & SMSC911X_USE_32BIT) {
252 iowrite32_rep(pdata->ioaddr + TX_DATA_FIFO, buf, wordcount);
256 if (pdata->config.flags & SMSC911X_USE_16BIT) {
258 __smsc911x_reg_write(pdata, TX_DATA_FIFO, *buf++);
264 spin_unlock_irqrestore(&pdata->dev_lock, flags);
269 smsc911x_tx_writefifo_shift(struct smsc911x_data *pdata, unsigned int *buf,
274 spin_lock_irqsave(&pdata->dev_lock, flags);
276 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
278 __smsc911x_reg_write_shift(pdata, TX_DATA_FIFO,
283 if (pdata->config.flags & SMSC911X_USE_32BIT) {
284 iowrite32_rep(pdata->ioaddr + __smsc_shift(pdata,
289 if (pdata->config.flags & SMSC911X_USE_16BIT) {
291 __smsc911x_reg_write_shift(pdata,
298 spin_unlock_irqrestore(&pdata->dev_lock, flags);
303 smsc911x_rx_readfifo(struct smsc911x_data *pdata, unsigned int *buf,
308 spin_lock_irqsave(&pdata->dev_lock, flags);
310 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
312 *buf++ = swab32(__smsc911x_reg_read(pdata,
317 if (pdata->config.flags & SMSC911X_USE_32BIT) {
318 ioread32_rep(pdata->ioaddr + RX_DATA_FIFO, buf, wordcount);
322 if (pdata->config.flags & SMSC911X_USE_16BIT) {
324 *buf++ = __smsc911x_reg_read(pdata, RX_DATA_FIFO);
330 spin_unlock_irqrestore(&pdata->dev_lock, flags);
335 smsc911x_rx_readfifo_shift(struct smsc911x_data *pdata, unsigned int *buf,
340 spin_lock_irqsave(&pdata->dev_lock, flags);
342 if (pdata->config.flags & SMSC911X_SWAP_FIFO) {
344 *buf++ = swab32(__smsc911x_reg_read_shift(pdata,
349 if (pdata->config.flags & SMSC911X_USE_32BIT) {
350 ioread32_rep(pdata->ioaddr + __smsc_shift(pdata,
355 if (pdata->config.flags & SMSC911X_USE_16BIT) {
357 *buf++ = __smsc911x_reg_read_shift(pdata,
364 spin_unlock_irqrestore(&pdata->dev_lock, flags);
373 struct smsc911x_data *pdata = netdev_priv(ndev);
376 ret = regulator_bulk_enable(ARRAY_SIZE(pdata->supplies),
377 pdata->supplies);
382 if (!IS_ERR(pdata->clk)) {
383 ret = clk_prepare_enable(pdata->clk);
397 struct smsc911x_data *pdata = netdev_priv(ndev);
400 ret = regulator_bulk_disable(ARRAY_SIZE(pdata->supplies),
401 pdata->supplies);
403 if (!IS_ERR(pdata->clk))
404 clk_disable_unprepare(pdata->clk);
419 struct smsc911x_data *pdata = netdev_priv(ndev);
423 pdata->supplies[0].supply = "vdd33a";
424 pdata->supplies[1].supply = "vddvario";
426 ARRAY_SIZE(pdata->supplies),
427 pdata->supplies);
440 pdata->reset_gpiod = devm_gpiod_get_optional(&pdev->dev,
445 pdata->clk = clk_get(&pdev->dev, NULL);
446 if (IS_ERR(pdata->clk))
448 PTR_ERR(pdata->clk));
460 struct smsc911x_data *pdata = netdev_priv(ndev);
463 regulator_bulk_free(ARRAY_SIZE(pdata->supplies),
464 pdata->supplies);
467 if (!IS_ERR(pdata->clk)) {
468 clk_put(pdata->clk);
469 pdata->clk = NULL;
475 static int smsc911x_mac_complete(struct smsc911x_data *pdata)
480 SMSC_ASSERT_MAC_LOCK(pdata);
483 val = smsc911x_reg_read(pdata, MAC_CSR_CMD);
487 SMSC_WARN(pdata, hw, "Timed out waiting for MAC not BUSY. "
493 static u32 smsc911x_mac_read(struct smsc911x_data *pdata, unsigned int offset)
497 SMSC_ASSERT_MAC_LOCK(pdata);
499 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
501 SMSC_WARN(pdata, hw, "MAC busy at entry");
506 smsc911x_reg_write(pdata, MAC_CSR_CMD, ((offset & 0xFF) |
510 temp = smsc911x_reg_read(pdata, BYTE_TEST);
513 if (likely(smsc911x_mac_complete(pdata) == 0))
514 return smsc911x_reg_read(pdata, MAC_CSR_DATA);
516 SMSC_WARN(pdata, hw, "MAC busy after read");
521 static void smsc911x_mac_write(struct smsc911x_data *pdata,
526 SMSC_ASSERT_MAC_LOCK(pdata);
528 temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
530 SMSC_WARN(pdata, hw,
536 smsc911x_reg_write(pdata, MAC_CSR_DATA, val);
539 smsc911x_reg_write(pdata, MAC_CSR_CMD, ((offset & 0xFF) |
543 temp = smsc911x_reg_read(pdata, BYTE_TEST);
546 if (likely(smsc911x_mac_complete(pdata) == 0))
549 SMSC_WARN(pdata, hw, "smsc911x_mac_write failed, MAC busy after write");
555 struct smsc911x_data *pdata = (struct smsc911x_data *)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);
592 struct smsc911x_data *pdata = (struct smsc911x_data *)bus->priv;
597 spin_lock_irqsave(&pdata->mac_lock, flags);
600 if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
601 SMSC_WARN(pdata, hw, "MII is busy in smsc911x_mii_write???");
607 smsc911x_mac_write(pdata, MII_DATA, val);
612 smsc911x_mac_write(pdata, MII_ACC, addr);
616 if (!(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
621 SMSC_WARN(pdata, hw, "Timed out waiting for MII write to finish");
625 spin_unlock_irqrestore(&pdata->mac_lock, flags);
630 static void smsc911x_phy_enable_external(struct smsc911x_data *pdata)
632 unsigned int hwcfg = smsc911x_reg_read(pdata, HW_CFG);
637 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
642 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
647 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
651 smsc911x_reg_write(pdata, HW_CFG, hwcfg);
657 static void smsc911x_phy_initialise_external(struct smsc911x_data *pdata)
659 unsigned int hwcfg = smsc911x_reg_read(pdata, HW_CFG);
661 if (pdata->config.flags & SMSC911X_FORCE_INTERNAL_PHY) {
662 SMSC_TRACE(pdata, hw, "Forcing internal PHY");
663 pdata->using_extphy = 0;
664 } else if (pdata->config.flags & SMSC911X_FORCE_EXTERNAL_PHY) {
665 SMSC_TRACE(pdata, hw, "Forcing external PHY");
666 smsc911x_phy_enable_external(pdata);
667 pdata->using_extphy = 1;
669 SMSC_TRACE(pdata, hw,
671 smsc911x_phy_enable_external(pdata);
672 pdata->using_extphy = 1;
674 SMSC_TRACE(pdata, hw,
676 pdata->using_extphy = 0;
681 static unsigned int smsc911x_tx_get_txstatus(struct smsc911x_data *pdata)
684 smsc911x_reg_read(pdata, TX_FIFO_INF) & TX_FIFO_INF_TSUSED_;
687 result = smsc911x_reg_read(pdata, TX_STATUS_FIFO);
693 static unsigned int smsc911x_rx_get_rxstatus(struct smsc911x_data *pdata)
696 smsc911x_reg_read(pdata, RX_FIFO_INF) & RX_FIFO_INF_RXSUSED_;
699 result = smsc911x_reg_read(pdata, RX_STATUS_FIFO);
705 static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
720 memset(pdata->loopback_rx_pkt, 0, MIN_PACKET_SIZE);
723 txcmd_a = (u32)((ulong)pdata->loopback_tx_pkt & 0x03) << 16;
729 smsc911x_reg_write(pdata, TX_DATA_FIFO, txcmd_a);
730 smsc911x_reg_write(pdata, TX_DATA_FIFO, txcmd_b);
732 bufp = (ulong)pdata->loopback_tx_pkt & (~0x3);
734 wrsz += (u32)((ulong)pdata->loopback_tx_pkt & 0x3);
737 pdata->ops->tx_writefifo(pdata, (unsigned int *)bufp, wrsz);
743 status = smsc911x_tx_get_txstatus(pdata);
747 SMSC_WARN(pdata, hw,
752 SMSC_WARN(pdata, hw,
761 status = smsc911x_rx_get_rxstatus(pdata);
765 SMSC_WARN(pdata, hw,
770 SMSC_WARN(pdata, hw,
776 bufp = (ulong)pdata->loopback_rx_pkt;
778 rdsz += (u32)((ulong)pdata->loopback_rx_pkt & 0x3);
781 pdata->ops->rx_readfifo(pdata, (unsigned int *)bufp, rdsz);
784 SMSC_WARN(pdata, hw, "Unexpected packet size "
791 if (pdata->loopback_tx_pkt[j]
792 != pdata->loopback_rx_pkt[j]) {
798 SMSC_TRACE(pdata, hw, "Successfully verified "
802 SMSC_WARN(pdata, hw, "Data mismatch "
811 static int smsc911x_phy_reset(struct smsc911x_data *pdata)
816 temp = smsc911x_reg_read(pdata, PMT_CTRL);
817 smsc911x_reg_write(pdata, PMT_CTRL, temp | PMT_CTRL_PHY_RST_);
820 temp = smsc911x_reg_read(pdata, PMT_CTRL);
824 SMSC_WARN(pdata, hw, "PHY reset failed to complete");
837 struct smsc911x_data *pdata = netdev_priv(dev);
844 eth_broadcast_addr(pdata->loopback_tx_pkt);
848 pdata->loopback_tx_pkt[i] = (char)i;
851 pdata->loopback_tx_pkt[12] = 0x00;
852 pdata->loopback_tx_pkt[13] = 0x00;
855 pdata->loopback_tx_pkt[i] = (char)i;
857 val = smsc911x_reg_read(pdata, HW_CFG);
860 smsc911x_reg_write(pdata, HW_CFG, val);
862 smsc911x_reg_write(pdata, TX_CFG, TX_CFG_TX_ON_);
863 smsc911x_reg_write(pdata, RX_CFG,
864 (u32)((ulong)pdata->loopback_rx_pkt & 0x03) << 8);
872 spin_lock_irqsave(&pdata->mac_lock, flags);
873 smsc911x_mac_write(pdata, MAC_CR, MAC_CR_FDPX_
875 spin_unlock_irqrestore(&pdata->mac_lock, flags);
877 if (smsc911x_phy_check_loopbackpkt(pdata) == 0) {
881 pdata->resetcount++;
884 spin_lock_irqsave(&pdata->mac_lock, flags);
885 smsc911x_mac_write(pdata, MAC_CR, 0);
886 spin_unlock_irqrestore(&pdata->mac_lock, flags);
888 smsc911x_phy_reset(pdata);
892 spin_lock_irqsave(&pdata->mac_lock, flags);
893 smsc911x_mac_write(pdata, MAC_CR, 0);
894 spin_unlock_irqrestore(&pdata->mac_lock, flags);
899 smsc911x_reg_write(pdata, TX_CFG, 0);
900 smsc911x_reg_write(pdata, RX_CFG, 0);
906 static void smsc911x_phy_update_flowcontrol(struct smsc911x_data *pdata)
908 struct net_device *ndev = pdata->dev;
910 u32 afc = smsc911x_reg_read(pdata, AFC_CFG);
929 SMSC_TRACE(pdata, hw, "rx pause %s, tx pause %s",
933 SMSC_TRACE(pdata, hw, "half duplex");
938 spin_lock_irqsave(&pdata->mac_lock, flags);
939 smsc911x_mac_write(pdata, FLOW, flow);
940 spin_unlock_irqrestore(&pdata->mac_lock, flags);
942 smsc911x_reg_write(pdata, AFC_CFG, afc);
949 struct smsc911x_data *pdata = netdev_priv(dev);
954 if (phy_dev->duplex != pdata->last_duplex) {
956 SMSC_TRACE(pdata, hw, "duplex state has changed");
958 spin_lock_irqsave(&pdata->mac_lock, flags);
959 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
961 SMSC_TRACE(pdata, hw,
965 SMSC_TRACE(pdata, hw,
969 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
970 spin_unlock_irqrestore(&pdata->mac_lock, flags);
972 smsc911x_phy_update_flowcontrol(pdata);
973 pdata->last_duplex = phy_dev->duplex;
977 if (carrier != pdata->last_carrier) {
978 SMSC_TRACE(pdata, hw, "carrier state has changed");
980 SMSC_TRACE(pdata, hw, "configuring for carrier OK");
981 if ((pdata->gpio_orig_setting & GPIO_CFG_LED1_EN_) &&
982 (!pdata->using_extphy)) {
984 pdata->gpio_setting = pdata->gpio_orig_setting;
985 smsc911x_reg_write(pdata, GPIO_CFG,
986 pdata->gpio_setting);
989 SMSC_TRACE(pdata, hw, "configuring for no carrier");
992 pdata->gpio_setting = smsc911x_reg_read(pdata,
994 if ((pdata->gpio_setting & GPIO_CFG_LED1_EN_) &&
995 (!pdata->using_extphy)) {
998 pdata->gpio_orig_setting = pdata->gpio_setting;
1000 pdata->gpio_setting &= ~GPIO_CFG_LED1_EN_;
1001 pdata->gpio_setting |= (GPIO_CFG_GPIOBUF0_
1004 smsc911x_reg_write(pdata, GPIO_CFG,
1005 pdata->gpio_setting);
1008 pdata->last_carrier = carrier;
1014 struct smsc911x_data *pdata = netdev_priv(dev);
1019 phydev = phy_find_first(pdata->mii_bus);
1025 SMSC_TRACE(pdata, probe, "PHY: addr %d, phy_id 0x%08X",
1029 pdata->config.phy_interface);
1043 pdata->last_duplex = -1;
1044 pdata->last_carrier = -1;
1048 SMSC_WARN(pdata, hw, "Failed Loop Back Test");
1052 SMSC_TRACE(pdata, hw, "Passed Loop Back Test");
1055 SMSC_TRACE(pdata, hw, "phy initialised successfully");
1062 struct smsc911x_data *pdata = netdev_priv(dev);
1065 pdata->mii_bus = mdiobus_alloc();
1066 if (!pdata->mii_bus) {
1071 pdata->mii_bus->name = SMSC_MDIONAME;
1072 snprintf(pdata->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
1074 pdata->mii_bus->priv = pdata;
1075 pdata->mii_bus->read = smsc911x_mii_read;
1076 pdata->mii_bus->write = smsc911x_mii_write;
1078 pdata->mii_bus->parent = &pdev->dev;
1080 switch (pdata->idrev & 0xFFFF0000) {
1086 smsc911x_phy_initialise_external(pdata);
1089 SMSC_TRACE(pdata, hw, "External PHY is not supported, "
1091 pdata->using_extphy = 0;
1095 if (!pdata->using_extphy) {
1097 pdata->mii_bus->phy_mask = ~(1 << 1);
1100 if (mdiobus_register(pdata->mii_bus)) {
1101 SMSC_WARN(pdata, probe, "Error registering mii bus");
1108 mdiobus_free(pdata->mii_bus);
1114 static unsigned int smsc911x_tx_get_txstatcount(struct smsc911x_data *pdata)
1116 return (smsc911x_reg_read(pdata, TX_FIFO_INF)
1123 struct smsc911x_data *pdata = netdev_priv(dev);
1126 while ((tx_stat = smsc911x_tx_get_txstatus(pdata)) != 0) {
1135 SMSC_WARN(pdata, hw, "Packet tag reserved bit is high");
1184 smsc911x_rx_fastforward(struct smsc911x_data *pdata, unsigned int pktwords)
1189 smsc911x_reg_write(pdata, RX_DP_CTRL, RX_DP_CTRL_RX_FFWD_);
1192 val = smsc911x_reg_read(pdata, RX_DP_CTRL);
1196 SMSC_WARN(pdata, hw, "Timed out waiting for "
1200 smsc911x_reg_read(pdata, RX_DATA_FIFO);
1207 struct smsc911x_data *pdata =
1209 struct net_device *dev = pdata->dev;
1216 unsigned int rxstat = smsc911x_rx_get_rxstatus(pdata);
1222 smsc911x_reg_write(pdata, INT_STS, INT_STS_RSFL_);
1224 temp = smsc911x_reg_read(pdata, INT_EN);
1226 smsc911x_reg_write(pdata, INT_EN, temp);
1239 SMSC_WARN(pdata, rx_err,
1243 smsc911x_rx_fastforward(pdata, pktwords);
1250 SMSC_WARN(pdata, rx_err,
1253 smsc911x_rx_fastforward(pdata, pktwords);
1258 pdata->ops->rx_readfifo(pdata,
1285 static void smsc911x_rx_multicast_update(struct smsc911x_data *pdata)
1291 SMSC_ASSERT_MAC_LOCK(pdata);
1293 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
1294 mac_cr |= pdata->set_bits_mask;
1295 mac_cr &= ~(pdata->clear_bits_mask);
1296 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
1297 smsc911x_mac_write(pdata, HASHH, pdata->hashhi);
1298 smsc911x_mac_write(pdata, HASHL, pdata->hashlo);
1299 SMSC_TRACE(pdata, hw, "maccr 0x%08X, HASHH 0x%08X, HASHL 0x%08X",
1300 mac_cr, pdata->hashhi, pdata->hashlo);
1303 static void smsc911x_rx_multicast_update_workaround(struct smsc911x_data *pdata)
1314 spin_lock(&pdata->mac_lock);
1317 if (smsc911x_mac_read(pdata, MAC_CR) & MAC_CR_RXEN_)
1318 SMSC_WARN(pdata, drv, "Rx not stopped");
1321 smsc911x_rx_multicast_update(pdata);
1324 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
1326 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
1328 pdata->multicast_update_pending = 0;
1330 spin_unlock(&pdata->mac_lock);
1333 static int smsc911x_phy_general_power_up(struct smsc911x_data *pdata)
1335 struct net_device *ndev = pdata->dev;
1351 SMSC_WARN(pdata, drv, "Failed reading PHY control reg");
1361 SMSC_WARN(pdata, drv, "Failed writing PHY control reg");
1371 static int smsc911x_phy_disable_energy_detect(struct smsc911x_data *pdata)
1373 struct net_device *ndev = pdata->dev;
1383 SMSC_WARN(pdata, drv, "Failed reading PHY control reg");
1394 SMSC_WARN(pdata, drv, "Failed writing PHY control reg");
1404 static int smsc911x_phy_enable_energy_detect(struct smsc911x_data *pdata)
1406 struct net_device *ndev = pdata->dev;
1416 SMSC_WARN(pdata, drv, "Failed reading PHY control reg");
1427 SMSC_WARN(pdata, drv, "Failed writing PHY control reg");
1434 static int smsc911x_soft_reset(struct smsc911x_data *pdata)
1446 ret = smsc911x_phy_general_power_up(pdata);
1448 SMSC_WARN(pdata, drv, "Failed to power-up the PHY chip");
1458 if (pdata->generation == 4) {
1459 ret = smsc911x_phy_disable_energy_detect(pdata);
1462 SMSC_WARN(pdata, drv, "Failed to wakeup the PHY chip");
1467 if ((pdata->idrev & 0xFFFF0000) == LAN9250) {
1474 smsc911x_reg_write(pdata, reset_offset, reset_mask);
1480 temp = smsc911x_reg_read(pdata, reset_offset);
1484 SMSC_WARN(pdata, drv, "Failed to complete reset");
1488 if (pdata->generation == 4) {
1489 ret = smsc911x_phy_enable_energy_detect(pdata);
1492 SMSC_WARN(pdata, drv, "Failed to wakeup the PHY chip");
1502 smsc911x_set_hw_mac_address(struct smsc911x_data *pdata, u8 dev_addr[6])
1508 SMSC_ASSERT_MAC_LOCK(pdata);
1510 smsc911x_mac_write(pdata, ADDRH, mac_high16);
1511 smsc911x_mac_write(pdata, ADDRL, mac_low32);
1516 struct smsc911x_data *pdata = netdev_priv(dev);
1518 smsc911x_reg_write(pdata, INT_EN, 0);
1519 smsc911x_reg_write(pdata, INT_STS, 0xFFFFFFFF);
1525 struct smsc911x_data *pdata = netdev_priv(dev);
1526 u32 intsts = smsc911x_reg_read(pdata, INT_STS);
1527 u32 inten = smsc911x_reg_read(pdata, INT_EN);
1532 temp = smsc911x_reg_read(pdata, INT_EN);
1534 smsc911x_reg_write(pdata, INT_EN, temp);
1535 smsc911x_reg_write(pdata, INT_STS, INT_STS_SW_INT_);
1536 pdata->software_irq_signal = 1;
1544 SMSC_TRACE(pdata, intr, "RX Stop interrupt");
1545 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXSTOP_INT_);
1546 if (pdata->multicast_update_pending)
1547 smsc911x_rx_multicast_update_workaround(pdata);
1552 temp = smsc911x_reg_read(pdata, FIFO_INT);
1554 smsc911x_reg_write(pdata, FIFO_INT, temp);
1555 smsc911x_reg_write(pdata, INT_STS, INT_STS_TDFA_);
1561 SMSC_TRACE(pdata, intr, "RX Error interrupt");
1562 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXE_);
1567 if (likely(napi_schedule_prep(&pdata->napi))) {
1569 temp = smsc911x_reg_read(pdata, INT_EN);
1571 smsc911x_reg_write(pdata, INT_EN, temp);
1573 __napi_schedule(&pdata->napi);
1575 SMSC_WARN(pdata, rx_err, "napi_schedule_prep failed");
1585 struct smsc911x_data *pdata = netdev_priv(dev);
1596 SMSC_WARN(pdata, probe, "Error starting phy");
1602 retval = smsc911x_soft_reset(pdata);
1604 SMSC_WARN(pdata, hw, "soft reset failed");
1608 smsc911x_reg_write(pdata, HW_CFG, 0x00050000);
1609 smsc911x_reg_write(pdata, AFC_CFG, 0x006E3740);
1612 spin_lock_irq(&pdata->mac_lock);
1613 smsc911x_mac_write(pdata, VLAN1, ETH_P_8021Q);
1614 spin_unlock_irq(&pdata->mac_lock);
1618 while ((smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) &&
1624 SMSC_WARN(pdata, ifup,
1627 smsc911x_reg_write(pdata, GPIO_CFG, 0x70070000);
1631 spin_lock_irq(&pdata->mac_lock);
1632 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
1633 spin_unlock_irq(&pdata->mac_lock);
1641 if (pdata->config.irq_polarity) {
1642 SMSC_TRACE(pdata, ifup, "irq polarity: active high");
1645 SMSC_TRACE(pdata, ifup, "irq polarity: active low");
1648 if (pdata->config.irq_type) {
1649 SMSC_TRACE(pdata, ifup, "irq type: push-pull");
1652 SMSC_TRACE(pdata, ifup, "irq type: open drain");
1655 smsc911x_reg_write(pdata, INT_CFG, intcfg);
1657 SMSC_TRACE(pdata, ifup, "Testing irq handler using IRQ %d", dev->irq);
1658 pdata->software_irq_signal = 0;
1665 SMSC_WARN(pdata, probe,
1670 temp = smsc911x_reg_read(pdata, INT_EN);
1672 smsc911x_reg_write(pdata, INT_EN, temp);
1676 if (pdata->software_irq_signal)
1681 if (!pdata->software_irq_signal) {
1687 SMSC_TRACE(pdata, ifup, "IRQ handler passed test using IRQ %d",
1691 (unsigned long)pdata->ioaddr, dev->irq);
1694 pdata->last_duplex = -1;
1695 pdata->last_carrier = -1;
1700 temp = smsc911x_reg_read(pdata, HW_CFG);
1704 smsc911x_reg_write(pdata, HW_CFG, temp);
1706 temp = smsc911x_reg_read(pdata, FIFO_INT);
1709 smsc911x_reg_write(pdata, FIFO_INT, temp);
1712 smsc911x_reg_write(pdata, RX_CFG, (NET_IP_ALIGN << 8));
1715 napi_enable(&pdata->napi);
1717 temp = smsc911x_reg_read(pdata, INT_EN);
1719 smsc911x_reg_write(pdata, INT_EN, temp);
1721 spin_lock_irq(&pdata->mac_lock);
1722 temp = smsc911x_mac_read(pdata, MAC_CR);
1724 smsc911x_mac_write(pdata, MAC_CR, temp);
1725 spin_unlock_irq(&pdata->mac_lock);
1727 smsc911x_reg_write(pdata, TX_CFG, TX_CFG_TX_ON_);
1744 struct smsc911x_data *pdata = netdev_priv(dev);
1748 temp = smsc911x_reg_read(pdata, INT_CFG);
1750 smsc911x_reg_write(pdata, INT_CFG, temp);
1754 napi_disable(&pdata->napi);
1757 dev->stats.rx_dropped += smsc911x_reg_read(pdata, RX_DROP);
1770 SMSC_TRACE(pdata, ifdown, "Interface stopped");
1778 struct smsc911x_data *pdata = netdev_priv(dev);
1786 freespace = smsc911x_reg_read(pdata, TX_FIFO_INF) & TX_FIFO_INF_TDFREE_;
1789 SMSC_WARN(pdata, tx_err,
1800 smsc911x_reg_write(pdata, TX_DATA_FIFO, tx_cmd_a);
1801 smsc911x_reg_write(pdata, TX_DATA_FIFO, tx_cmd_b);
1808 pdata->ops->tx_writefifo(pdata, (unsigned int *)bufp, wrsz);
1813 if (unlikely(smsc911x_tx_get_txstatcount(pdata) >= 30))
1818 temp = smsc911x_reg_read(pdata, FIFO_INT);
1821 smsc911x_reg_write(pdata, FIFO_INT, temp);
1830 struct smsc911x_data *pdata = netdev_priv(dev);
1832 dev->stats.rx_dropped += smsc911x_reg_read(pdata, RX_DROP);
1839 struct smsc911x_data *pdata = netdev_priv(dev);
1844 pdata->set_bits_mask = MAC_CR_PRMS_;
1845 pdata->clear_bits_mask = (MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
1846 pdata->hashhi = 0;
1847 pdata->hashlo = 0;
1850 pdata->set_bits_mask = MAC_CR_MCPAS_;
1851 pdata->clear_bits_mask = (MAC_CR_PRMS_ | MAC_CR_HPFILT_);
1852 pdata->hashhi = 0;
1853 pdata->hashlo = 0;
1860 pdata->set_bits_mask = MAC_CR_HPFILT_;
1861 pdata->clear_bits_mask = (MAC_CR_PRMS_ | MAC_CR_MCPAS_);
1873 pdata->hashhi = hash_high;
1874 pdata->hashlo = hash_low;
1877 pdata->set_bits_mask = 0;
1878 pdata->clear_bits_mask =
1880 pdata->hashhi = 0;
1881 pdata->hashlo = 0;
1884 spin_lock_irqsave(&pdata->mac_lock, flags);
1886 if (pdata->generation <= 1) {
1889 if (!pdata->multicast_update_pending) {
1891 SMSC_TRACE(pdata, hw, "scheduling mcast update");
1892 pdata->multicast_update_pending = 1;
1896 temp = smsc911x_mac_read(pdata, MAC_CR);
1898 smsc911x_mac_write(pdata, MAC_CR, temp);
1905 smsc911x_rx_multicast_update(pdata);
1908 spin_unlock_irqrestore(&pdata->mac_lock, flags);
1922 struct smsc911x_data *pdata = netdev_priv(dev);
1928 if (pdata->generation <= 1 && netif_running(dev))
1936 spin_lock_irq(&pdata->mac_lock);
1937 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
1938 spin_unlock_irq(&pdata->mac_lock);
1956 struct smsc911x_data *pdata = netdev_priv(dev);
1957 return pdata->msg_enable;
1962 struct smsc911x_data *pdata = netdev_priv(dev);
1963 pdata->msg_enable = level;
1976 struct smsc911x_data *pdata = netdev_priv(dev);
1983 regs->version = pdata->idrev;
1985 data[j++] = smsc911x_reg_read(pdata, i);
1988 spin_lock_irqsave(&pdata->mac_lock, flags);
1989 data[j++] = smsc911x_mac_read(pdata, i);
1990 spin_unlock_irqrestore(&pdata->mac_lock, flags);
1998 static void smsc911x_eeprom_enable_access(struct smsc911x_data *pdata)
2000 unsigned int temp = smsc911x_reg_read(pdata, GPIO_CFG);
2002 smsc911x_reg_write(pdata, GPIO_CFG, temp);
2006 static int smsc911x_eeprom_send_cmd(struct smsc911x_data *pdata, u32 op)
2011 SMSC_TRACE(pdata, drv, "op 0x%08x", op);
2012 if (smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) {
2013 SMSC_WARN(pdata, drv, "Busy at start");
2018 smsc911x_reg_write(pdata, E2P_CMD, e2cmd);
2022 e2cmd = smsc911x_reg_read(pdata, E2P_CMD);
2026 SMSC_TRACE(pdata, drv, "TIMED OUT");
2031 SMSC_TRACE(pdata, drv, "Error occurred during eeprom operation");
2038 static int smsc911x_eeprom_read_location(struct smsc911x_data *pdata,
2044 SMSC_TRACE(pdata, drv, "address 0x%x", address);
2045 ret = smsc911x_eeprom_send_cmd(pdata, op);
2048 data[address] = smsc911x_reg_read(pdata, E2P_DATA);
2053 static int smsc911x_eeprom_write_location(struct smsc911x_data *pdata,
2059 SMSC_TRACE(pdata, drv, "address 0x%x, data 0x%x", address, data);
2060 ret = smsc911x_eeprom_send_cmd(pdata, op);
2064 smsc911x_reg_write(pdata, E2P_DATA, (u32)data);
2067 smsc911x_reg_read(pdata, BYTE_TEST);
2069 ret = smsc911x_eeprom_send_cmd(pdata, op);
2083 struct smsc911x_data *pdata = netdev_priv(dev);
2088 smsc911x_eeprom_enable_access(pdata);
2092 int ret = smsc911x_eeprom_read_location(pdata, i, eeprom_data);
2108 struct smsc911x_data *pdata = netdev_priv(dev);
2110 smsc911x_eeprom_enable_access(pdata);
2111 smsc911x_eeprom_send_cmd(pdata, E2P_CMD_EPC_CMD_EWEN_);
2112 ret = smsc911x_eeprom_write_location(pdata, eeprom->offset, *data);
2113 smsc911x_eeprom_send_cmd(pdata, E2P_CMD_EPC_CMD_EWDS_);
2154 struct smsc911x_data *pdata = netdev_priv(dev);
2155 u32 mac_high16 = smsc911x_mac_read(pdata, ADDRH);
2156 u32 mac_low32 = smsc911x_mac_read(pdata, ADDRL);
2169 struct smsc911x_data *pdata = netdev_priv(dev);
2173 SMSC_TRACE(pdata, probe, "Driver Parameters:");
2174 SMSC_TRACE(pdata, probe, "LAN base: 0x%08lX",
2175 (unsigned long)pdata->ioaddr);
2176 SMSC_TRACE(pdata, probe, "IRQ: %d", dev->irq);
2177 SMSC_TRACE(pdata, probe, "PHY will be autodetected.");
2179 spin_lock_init(&pdata->dev_lock);
2180 spin_lock_init(&pdata->mac_lock);
2182 if (pdata->ioaddr == NULL) {
2183 SMSC_WARN(pdata, probe, "pdata->ioaddr: 0x00000000");
2203 while (!(smsc911x_reg_read(pdata, PMT_CTRL) & mask) && --to)
2212 byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
2213 SMSC_TRACE(pdata, probe, "BYTE_TEST: 0x%08X", byte_test);
2215 SMSC_TRACE(pdata, probe, "BYTE_TEST looks swapped, "
2217 smsc911x_reg_write(pdata, WORD_SWAP, 0xffffffff);
2221 byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
2223 byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
2227 SMSC_WARN(pdata, drv, "BYTE_TEST: 0x%08X", byte_test);
2229 SMSC_WARN(pdata, probe,
2231 SMSC_TRACE(pdata, probe,
2239 pdata->generation = 0;
2241 pdata->idrev = smsc911x_reg_read(pdata, ID_REV);
2242 switch (pdata->idrev & 0xFFFF0000) {
2249 pdata->generation = pdata->idrev & 0x0000FFFF;
2257 pdata->generation = 3;
2266 pdata->generation = 4;
2270 SMSC_WARN(pdata, probe, "LAN911x not identified, idrev: 0x%08X",
2271 pdata->idrev);
2275 SMSC_TRACE(pdata, probe,
2277 pdata->idrev, pdata->generation);
2279 if (pdata->generation == 0)
2280 SMSC_WARN(pdata, probe,
2286 if (pdata->config.flags & SMSC911X_SAVE_MAC_ADDRESS) {
2287 spin_lock_irq(&pdata->mac_lock);
2289 spin_unlock_irq(&pdata->mac_lock);
2293 if (smsc911x_phy_reset(pdata) || smsc911x_soft_reset(pdata))
2297 netif_napi_add(dev, &pdata->napi, smsc911x_poll, SMSC_NAPI_WEIGHT);
2307 struct smsc911x_data *pdata;
2312 pdata = netdev_priv(dev);
2313 BUG_ON(!pdata);
2314 BUG_ON(!pdata->ioaddr);
2316 SMSC_TRACE(pdata, ifdown, "Stopping driver");
2320 mdiobus_unregister(pdata->mii_bus);
2321 mdiobus_free(pdata->mii_bus);
2330 iounmap(pdata->ioaddr);
2404 struct smsc911x_data *pdata;
2444 pdata = netdev_priv(dev);
2446 pdata->ioaddr = ioremap(res->start, res_size);
2447 if (!pdata->ioaddr) {
2452 pdata->dev = dev;
2453 pdata->msg_enable = ((1 << debug) - 1);
2465 if (pdata->ioaddr == NULL) {
2466 SMSC_WARN(pdata, probe, "Error smsc911x base address invalid");
2471 retval = smsc911x_probe_config(&pdata->config, &pdev->dev);
2473 /* copy config parameters across to pdata */
2474 memcpy(&pdata->config, config, sizeof(pdata->config));
2479 SMSC_WARN(pdata, probe, "Error smsc911x config not found");
2484 pdata->ops = &standard_smsc911x_ops;
2486 if (pdata->config.shift)
2487 pdata->ops = &shifted_smsc911x_ops;
2500 SMSC_WARN(pdata, probe, "Error %i initialising mii", retval);
2506 SMSC_WARN(pdata, probe, "Error %i registering device", retval);
2509 SMSC_TRACE(pdata, probe,
2513 spin_lock_irq(&pdata->mac_lock);
2517 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
2518 SMSC_TRACE(pdata, probe,
2520 } else if (is_valid_ether_addr(pdata->config.mac)) {
2521 memcpy(dev->dev_addr, pdata->config.mac, ETH_ALEN);
2522 SMSC_TRACE(pdata, probe,
2531 SMSC_TRACE(pdata, probe,
2536 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
2537 SMSC_TRACE(pdata, probe,
2542 spin_unlock_irq(&pdata->mac_lock);
2556 iounmap(pdata->ioaddr);
2574 struct smsc911x_data *pdata = netdev_priv(ndev);
2583 smsc911x_reg_write(pdata, PMT_CTRL,
2596 struct smsc911x_data *pdata = netdev_priv(ndev);
2606 smsc911x_reg_write(pdata, BYTE_TEST, 0);
2611 while (!(smsc911x_reg_read(pdata, PMT_CTRL) & PMT_CTRL_READY_) && --to)