static int lpc_eth_close(struct net_device *ndev) { unsigned long flags; struct netdata_local *pldat = netdev_priv(ndev); if (netif_msg_ifdown(pldat)) dev_dbg(&pldat->pdev->dev, "shutting down %s\n", ndev->name); napi_disable(&pldat->napi); netif_stop_queue(ndev); if (pldat->phy_dev) phy_stop(pldat->phy_dev); spin_lock_irqsave(&pldat->lock, flags); __lpc_eth_reset(pldat); netif_carrier_off(ndev); writel(0, LPC_ENET_MAC1(pldat->net_base)); writel(0, LPC_ENET_MAC2(pldat->net_base)); spin_unlock_irqrestore(&pldat->lock, flags); __lpc_eth_clock_enable(pldat, false); return 0; }
static int dsa_slave_close(struct net_device *dev) { struct dsa_slave_priv *p = netdev_priv(dev); struct net_device *master = p->parent->dst->master_netdev; struct dsa_switch *ds = p->parent; if (p->phy) phy_stop(p->phy); dev_mc_unsync(master, dev); dev_uc_unsync(master, dev); if (dev->flags & IFF_ALLMULTI) dev_set_allmulti(master, -1); if (dev->flags & IFF_PROMISC) dev_set_promiscuity(master, -1); if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) dev_uc_del(master, dev->dev_addr); if (ds->drv->port_disable) ds->drv->port_disable(ds, p->port, p->phy); if (ds->drv->port_stp_update) ds->drv->port_stp_update(ds, p->port, BR_STATE_DISABLED); return 0; }
static void cpsw_slave_stop(struct cpsw_slave *slave, struct cpsw_priv *priv) { if (!slave->phy) return; phy_stop(slave->phy); phy_disconnect(slave->phy); slave->phy = NULL; }
static void sfp_sm_phy_detach(struct sfp *sfp) { phy_stop(sfp->mod_phy); sfp_remove_phy(sfp->sfp_bus); phy_device_remove(sfp->mod_phy); phy_device_free(sfp->mod_phy); sfp->mod_phy = NULL; }
static void ramips_phy_stop(struct raeth_priv *re) { if (re->phy_dev) { phy_stop(re->phy_dev); } else { re->link = 0; ramips_link_adjust(re); } }
void ag71xx_phy_stop(struct ag71xx *ag) { if (ag->phy_dev) { phy_stop(ag->phy_dev); } else { ag->duplex = -1; ag->link = 0; ag->speed = 0; ag71xx_phy_link_update(ag); } }
void phylink_stop(struct phylink *pl) { WARN_ON(!lockdep_rtnl_is_held()); if (pl->phydev) phy_stop(pl->phydev); if (pl->sfp_bus) sfp_upstream_stop(pl->sfp_bus); set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); flush_work(&pl->resolve); }
/** * phylink_stop() - stop a phylink instance * @pl: a pointer to a &struct phylink returned from phylink_create() * * Stop the phylink instance specified by @pl. This should be called from the * network device driver's &struct net_device_ops ndo_stop() method. The * network device's carrier state should not be changed prior to calling this * function. */ void phylink_stop(struct phylink *pl) { ASSERT_RTNL(); if (pl->phydev) phy_stop(pl->phydev); if (pl->sfp_bus) sfp_upstream_stop(pl->sfp_bus); if (pl->link_an_mode == MLO_AN_FIXED && !IS_ERR(pl->link_gpio)) del_timer_sync(&pl->link_poll); phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_STOPPED); }
static void ramips_phy_stop(struct raeth_priv *re) { unsigned long flags; if (re->phy_dev) phy_stop(re->phy_dev); spin_lock_irqsave(&re->phy_lock, flags); re->link = 0; ramips_link_adjust(re); spin_unlock_irqrestore(&re->phy_lock, flags); }
/* Stop RDC MAC and Free the allocated resource */ static void pci_eth_down(struct net_device *dev) { struct pci_eth_private *priv = netdev_priv(dev); void __iomem *ioaddr = dev->base_addr; /* TODO: Stop MAC */ /* TODO: Reset MAC */ /* TODO: Restore MAC Address to MIDx */ phy_stop(priv->phydev); }
int dsa_slave_suspend(struct net_device *slave_dev) { struct dsa_slave_priv *p = netdev_priv(slave_dev); if (p->phy) { phy_stop(p->phy); p->old_pause = -1; p->old_link = -1; p->old_duplex = -1; phy_suspend(p->phy); } return 0; }
static int xge_close(struct net_device *ndev) { struct xge_pdata *pdata = netdev_priv(ndev); netif_stop_queue(ndev); xge_mac_disable(pdata); phy_stop(ndev->phydev); xge_intr_disable(pdata); xge_free_irq(ndev); napi_disable(&pdata->napi); xge_delete_desc_rings(ndev); return 0; }
/** * phylink_stop() - stop a phylink instance * @pl: a pointer to a &struct phylink returned from phylink_create() * * Stop the phylink instance specified by @pl. This should be called from the * network device driver's &struct net_device_ops ndo_stop() method. The * network device's carrier state should not be changed prior to calling this * function. */ void phylink_stop(struct phylink *pl) { ASSERT_RTNL(); if (pl->phydev) phy_stop(pl->phydev); if (pl->sfp_bus) sfp_upstream_stop(pl->sfp_bus); if (pl->link_an_mode == MLO_AN_FIXED && !IS_ERR(pl->link_gpio)) del_timer_sync(&pl->link_poll); set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); queue_work(system_power_efficient_wq, &pl->resolve); flush_work(&pl->resolve); }
static int ax88172a_stop(struct usbnet *dev) { struct ax88172a_private *priv = dev->driver_priv; netdev_dbg(dev->net, "Stopping interface\n"); if (priv->phydev) { netdev_info(dev->net, "Disconnecting from phy %s\n", priv->phy_name); phy_stop(priv->phydev); phy_disconnect(priv->phydev); } return 0; }
static int hisi_femac_net_close(struct net_device *dev) { struct hisi_femac_priv *priv = netdev_priv(dev); hisi_femac_irq_disable(priv, IRQ_ENA_PORT0); if (dev->phydev) phy_stop(dev->phydev); netif_stop_queue(dev); napi_disable(&priv->napi); hisi_femac_free_skb_rings(priv); return 0; }
static int bgmac_stop(struct net_device *net_dev) { struct bgmac *bgmac = netdev_priv(net_dev); netif_carrier_off(net_dev); phy_stop(bgmac->phy_dev); napi_disable(&bgmac->napi); bgmac_chip_intrs_off(bgmac); free_irq(bgmac->core->irq, net_dev); bgmac_chip_reset(bgmac); return 0; }
static int s6gmac_stop(struct net_device *dev) { struct s6gmac *pd = netdev_priv(dev); unsigned long flags; netif_stop_queue(dev); phy_stop(pd->phydev); spin_lock_irqsave(&pd->lock, flags); s6gmac_init_dmac(dev); s6gmac_stop_device(dev); while (pd->tx_skb_i != pd->tx_skb_o) dev_kfree_skb(pd->tx_skb[(pd->tx_skb_o++) % S6_NUM_TX_SKB]); while (pd->rx_skb_i != pd->rx_skb_o) dev_kfree_skb(pd->rx_skb[(pd->rx_skb_o++) % S6_NUM_RX_SKB]); spin_unlock_irqrestore(&pd->lock, flags); return 0; }
void ag71xx_phy_stop(struct ag71xx *ag) { struct ag71xx_platform_data *pdata = ag71xx_get_pdata(ag); unsigned long flags; if (ag->phy_dev) phy_stop(ag->phy_dev); else if (pdata->mii_bus_dev && pdata->switch_data) ag71xx_ar7240_stop(ag); spin_lock_irqsave(&ag->lock, flags); if (ag->link) { ag->link = 0; ag71xx_link_adjust(ag); } spin_unlock_irqrestore(&ag->lock, flags); }
static void mtk_phy_stop(struct mtk_mac *mac) { struct mtk_eth *eth = mac->hw; unsigned long flags; int i; for (i = 0; i < 8; i++) if (eth->phy->phy_fixed[i]) { spin_lock_irqsave(ð->phy->lock, flags); eth->link[i] = 0; if (eth->soc->mdio_adjust_link) eth->soc->mdio_adjust_link(eth, i); spin_unlock_irqrestore(ð->phy->lock, flags); } else if (eth->phy->phy[i]) { phy_stop(eth->phy->phy[i]); } }
/* * this makes the board clean up everything that it can * and not talk to the outside world. Caused by * an 'ifconfig ethX down' */ static int bfin_mac_close(struct net_device *dev) { struct bfin_mac_local *lp = netdev_priv(dev); pr_debug("%s: %s\n", dev->name, __func__); netif_stop_queue(dev); netif_carrier_off(dev); phy_stop(lp->phydev); phy_write(lp->phydev, MII_BMCR, BMCR_PDOWN); /* clear everything */ bfin_mac_shutdown(dev); /* free the rx/tx buffers */ desc_list_free(); return 0; }
/* Stop the interface. * The interface is stopped when it is brought. */ static int emac_stop(struct net_device *ndev) { struct emac_board_info *db = netdev_priv(ndev); if (netif_msg_ifdown(db)) dev_dbg(db->dev, "shutting down %s\n", ndev->name); netif_stop_queue(ndev); netif_carrier_off(ndev); phy_stop(ndev->phydev); emac_mdio_remove(ndev); emac_shutdown(ndev); free_irq(ndev->irq, ndev); return 0; }
/* Stop RDC MAC and Free the allocated resource */ static void r6040_down(struct net_device *dev) { struct r6040_private *lp = netdev_priv(dev); void __iomem *ioaddr = lp->base; u16 *adrp; /* Stop MAC */ iowrite16(MSK_INT, ioaddr + MIER); /* Mask Off Interrupt */ /* Reset RDC MAC */ r6040_reset_mac(lp); /* Restore MAC Address to MIDx */ adrp = (u16 *) dev->dev_addr; iowrite16(adrp[0], ioaddr + MID_0L); iowrite16(adrp[1], ioaddr + MID_0M); iowrite16(adrp[2], ioaddr + MID_0H); phy_stop(lp->phydev); }
static int fs_enet_close(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); unsigned long flags; netif_stop_queue(dev); netif_carrier_off(dev); phy_stop(fep->phydev); spin_lock_irqsave(&fep->lock, flags); (*fep->ops->stop)(dev); spin_unlock_irqrestore(&fep->lock, flags); /* release any irqs */ phy_disconnect(fep->phydev); fep->phydev = NULL; fs_free_irq(dev, fep->interrupt); return 0; }
int bgmac_enet_suspend(struct bgmac *bgmac) { if (!netif_running(bgmac->net_dev)) return 0; phy_stop(bgmac->net_dev->phydev); netif_stop_queue(bgmac->net_dev); napi_disable(&bgmac->napi); netif_tx_lock(bgmac->net_dev); netif_device_detach(bgmac->net_dev); netif_tx_unlock(bgmac->net_dev); bgmac_chip_intrs_off(bgmac); bgmac_chip_reset(bgmac); bgmac_dma_cleanup(bgmac); return 0; }
static int stmmac_suspend(struct device *dev) { struct net_device *ndev = dev_get_drvdata(dev); struct stmmac_priv *priv = netdev_priv(ndev); int dis_ic = 0; if (!ndev || !netif_running(ndev)) return 0; spin_lock(&priv->lock); netif_device_detach(ndev); netif_stop_queue(ndev); if (priv->phydev) phy_stop(priv->phydev); #ifdef CONFIG_STMMAC_TIMER priv->tm->timer_stop(); if (likely(priv->tm->enable)) dis_ic = 1; #endif napi_disable(&priv->napi); /* Stop TX/RX DMA */ priv->hw->dma->stop_tx(priv->ioaddr); priv->hw->dma->stop_rx(priv->ioaddr); /* Clear the Rx/Tx descriptors */ priv->hw->desc->init_rx_desc(priv->dma_rx, priv->dma_rx_size, dis_ic); priv->hw->desc->init_tx_desc(priv->dma_tx, priv->dma_tx_size); /* Enable Power down mode by programming the PMT regs */ if (device_may_wakeup(priv->device)) priv->hw->mac->pmt(priv->ioaddr, priv->wolopts); else stmmac_disable_mac(priv->ioaddr); spin_unlock(&priv->lock); return 0; }
/* device close function */ static int sh_eth_close(struct net_device *ndev) { struct sh_eth_private *mdp = netdev_priv(ndev); u32 ioaddr = ndev->base_addr; int ringsize; netif_stop_queue(ndev); /* Disable interrupts by clearing the interrupt mask. */ writel(0x0000, ioaddr + EESIPR); /* Stop the chip's Tx and Rx processes. */ writel(0, ioaddr + EDTRR); writel(0, ioaddr + EDRRR); /* PHY Disconnect */ if (mdp->phydev) { phy_stop(mdp->phydev); phy_disconnect(mdp->phydev); } free_irq(ndev->irq, ndev); del_timer_sync(&mdp->timer); /* Free all the skbuffs in the Rx queue. */ sh_eth_ring_free(ndev); /* free DMA buffer */ ringsize = sizeof(struct sh_eth_rxdesc) * RX_RING_SIZE; dma_free_coherent(NULL, ringsize, mdp->rx_ring, mdp->rx_desc_dma); /* free DMA buffer */ ringsize = sizeof(struct sh_eth_txdesc) * TX_RING_SIZE; dma_free_coherent(NULL, ringsize, mdp->tx_ring, mdp->tx_desc_dma); pm_runtime_put_sync(&mdp->pdev->dev); return 0; }
/** * stmmac_release - close entry point of the driver * @dev : device pointer. * Description: * This is the stop entry point of the driver. */ static int stmmac_release(struct net_device *dev) { struct stmmac_priv *priv = netdev_priv(dev); /* Stop and disconnect the PHY */ if (priv->phydev) { phy_stop(priv->phydev); phy_disconnect(priv->phydev); priv->phydev = NULL; } netif_stop_queue(dev); #ifdef CONFIG_STMMAC_TIMER /* Stop and release the timer */ stmmac_close_ext_timer(); if (priv->tm != NULL) kfree(priv->tm); #endif napi_disable(&priv->napi); skb_queue_purge(&priv->rx_recycle); /* Free the IRQ lines */ free_irq(dev->irq, dev); /* Stop TX/RX DMA and clear the descriptors */ priv->hw->dma->stop_tx(priv->ioaddr); priv->hw->dma->stop_rx(priv->ioaddr); /* Release and free the Rx/Tx resources */ free_dma_desc_resources(priv); /* Disable the MAC Rx/Tx */ stmmac_disable_mac(priv->ioaddr); netif_carrier_off(dev); return 0; }
static int hieth_net_close(struct net_device *dev) { struct hieth_netdev_local *ld = netdev_priv(dev); hieth_irq_disable(ld, UD_BIT_NAME(HIETH_INT_MULTI_RXRDY)); phy_stop(ld->phy); del_timer_sync(&ld->monitor); /* reset and init port */ hieth_port_reset(ld, ld->port); hieth_port_init(ld, ld->port); skb_queue_purge(&ld->rx_head); skb_queue_purge(&ld->rx_hw); skb_queue_purge(&ld->tx_hw); ld->tx_hw_cnt = 0; module_put(THIS_MODULE); return 0; }
static void fs_timeout(struct net_device *dev) { struct fs_enet_private *fep = netdev_priv(dev); unsigned long flags; int wake = 0; fep->stats.tx_errors++; spin_lock_irqsave(&fep->lock, flags); if (dev->flags & IFF_UP) { phy_stop(fep->phydev); (*fep->ops->stop)(dev); (*fep->ops->restart)(dev); phy_start(fep->phydev); } phy_start(fep->phydev); wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY); spin_unlock_irqrestore(&fep->lock, flags); if (wake) netif_wake_queue(dev); }
static int au1000_close(struct net_device *dev) { unsigned long flags; struct au1000_private *const aup = netdev_priv(dev); if (au1000_debug > 4) printk("%s: close: dev=%p\n", dev->name, dev); if (aup->phy_dev) phy_stop(aup->phy_dev); spin_lock_irqsave(&aup->lock, flags); reset_mac_unlocked (dev); /* stop the device */ netif_stop_queue(dev); /* disable the interrupt */ free_irq(dev->irq, dev); spin_unlock_irqrestore(&aup->lock, flags); return 0; }