void synopGMAC_linux_cable_unplug_function(void *adaptr) { s32 data; synopGMACPciNetworkAdapter *adapter = (synopGMACPciNetworkAdapter *)adaptr; synopGMACdevice *gmacdev = adapter->synopGMACdev; struct ethtool_cmd cmd; //rt_kprintf("%s\n",__FUNCTION__); if(!mii_link_ok(&adapter->mii)){ if(gmacdev->LinkState) rt_kprintf("\r\nNo Link\r\n"); gmacdev->DuplexMode = 0; gmacdev->Speed = 0; gmacdev->LoopBackMode = 0; gmacdev->LinkState = 0; } else{ data = synopGMAC_check_phy_init(adapter); if(gmacdev->LinkState != data){ gmacdev->LinkState = data; synopGMAC_mac_init(gmacdev); rt_kprintf("Link is up in %s mode\n",(gmacdev->DuplexMode == FULLDUPLEX) ? "FULL DUPLEX": "HALF DUPLEX"); if(gmacdev->Speed == SPEED1000) rt_kprintf("Link is with 1000M Speed \r\n"); if(gmacdev->Speed == SPEED100) rt_kprintf("Link is with 100M Speed \n"); if(gmacdev->Speed == SPEED10) rt_kprintf("Link is with 10M Speed \n"); } } }
s32 synopGMAC_check_phy_init (synopGMACPciNetworkAdapter *adapter) { struct ethtool_cmd cmd; synopGMACdevice *gmacdev = adapter->synopGMACdev; if(!mii_link_ok(&adapter->mii)) { gmacdev->DuplexMode = FULLDUPLEX; gmacdev->Speed = SPEED100; return 0; } else { mii_ethtool_gset(&adapter->mii, &cmd); gmacdev->DuplexMode = (cmd.duplex == DUPLEX_FULL) ? FULLDUPLEX: HALFDUPLEX ; if(cmd.speed == SPEED_1000) gmacdev->Speed = SPEED1000; else if(cmd.speed == SPEED_100) gmacdev->Speed = SPEED100; else gmacdev->Speed = SPEED10; } return gmacdev->Speed|(gmacdev->DuplexMode<<4); }
/* One link status poll per endpoint -- called with endpoint lock */ static void wrn_update_link_status(struct net_device *dev) { struct wrn_ep *ep = netdev_priv(dev); u32 ecr, bmsr, bmcr, lpa; bmsr = wrn_phy_read(dev, 0, MII_BMSR); bmcr = wrn_phy_read(dev, 0, MII_BMCR); //netdev_dbg(dev, "%s: read %x %x", __func__, bmsr, bmcr); // printk("%s: read %x %x %x\n", __func__, bmsr, bmcr); /* Link wnt down? */ if (!mii_link_ok(&ep->mii)) { if(netif_carrier_ok(dev)) { netif_carrier_off(dev); clear_bit(WRN_EP_UP, &ep->ep_flags); printk(KERN_INFO "%s: Link down.\n", dev->name); return; } return; } /* Currently the link is active */ if(netif_carrier_ok(dev)) { /* Software already knows it's up */ return; } /* What follows is the bring-up step */ if (bmcr & BMCR_ANENABLE) { /* AutoNegotiation is enabled */ if (!(bmsr & BMSR_ANEGCOMPLETE)) { /* Wait next timer, until it completes */ return; } lpa = wrn_phy_read(dev, 0, MII_LPA); if (0) { /* was commented in minic */ wrn_ep_write(ep, FCR, EP_FCR_TXPAUSE |EP_FCR_RXPAUSE | EP_FCR_TX_THR_W(128) | EP_FCR_TX_QUANTA_W(200)); } printk(KERN_INFO "%s: Link up, lpa 0x%04x.\n", dev->name, lpa); } else { /* No autonegotiation. It's up immediately */ printk(KERN_INFO "%s: Link up.\n", dev->name); } netif_carrier_on(dev); set_bit(WRN_EP_UP, &ep->ep_flags); /* reset RMON counters */ ecr = wrn_ep_read(ep, ECR); wrn_ep_write(ep, ECR, ecr | EP_ECR_RST_CNT); wrn_ep_write(ep, ECR, ecr ); }
static u32 et_virt_get_link(struct net_device *dev) { #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35) PSEUDO_ADAPTER *pseudo = netdev_priv(dev); #else PSEUDO_ADAPTER *pseudo = dev->priv; #endif return mii_link_ok(&pseudo->mii_info); }
static u32 et_get_link(struct net_device *dev) { #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35) END_DEVICE *ei_local = netdev_priv(dev); #else END_DEVICE *ei_local = dev->priv; #endif return mii_link_ok(&ei_local->mii_info); }
/** * mii_check_link - check MII link status * @mii: MII interface * * If the link status changed (previous != current), call * netif_carrier_on() if current link status is Up or call * netif_carrier_off() if current link status is Down. */ void mii_check_link (struct mii_if_info *mii) { int cur_link = mii_link_ok(mii); int prev_link = netif_carrier_ok(mii->dev); if (cur_link && !prev_link) netif_carrier_on(mii->dev); else if (prev_link && !cur_link) netif_carrier_off(mii->dev); }
static u32 cvm_oct_get_link(struct net_device *dev) { struct octeon_ethernet *priv = netdev_priv(dev); u32 ret; down(&mdio_sem); ret = mii_link_ok(&priv->mii_info); up(&mdio_sem); return ret; }
/** * mii_check_link - check MII link status * @mii: MII interface * * If the link status changed (previous != current), call * netif_carrier_on() if current link status is Up or call * netif_carrier_off() if current link status is Down. */ void mii_check_link(struct mii_if_info *mii) { #warning "figure out what to do about etherboot netdev; does ours work?" #if 0 int cur_link = mii_link_ok(mii); int prev_link = netdev_link_ok(mii->dev); if (cur_link && !prev_link) netdev_link_up(mii->dev); else if (prev_link && !cur_link) netdev_link_down(mii->dev); #endif }
static u32 enet_get_link(struct net_device *dev) { struct tangox_enet_priv *priv; int ret; priv = netdev_priv(dev); spin_lock_bh(&priv->mii_lock); ret = mii_link_ok(&priv->mii); spin_unlock_bh(&priv->mii_lock); return ret; }
static void update_linkspeed(struct net_device *dev) { struct w90p910_ether *ether = netdev_priv(dev); struct platform_device *pdev; unsigned int bmsr, bmcr, lpa, speed, duplex; pdev = ether->pdev; if (!mii_link_ok(ðer->mii)) { ether->linkflag = 0x0; netif_carrier_off(dev); dev_warn(&pdev->dev, "%s: Link down.\n", dev->name); return; } if (ether->linkflag == 1) return; bmsr = w90p910_mdio_read(dev, ether->mii.phy_id, MII_BMSR); bmcr = w90p910_mdio_read(dev, ether->mii.phy_id, MII_BMCR); if (bmcr & BMCR_ANENABLE) { if (!(bmsr & BMSR_ANEGCOMPLETE)) return; lpa = w90p910_mdio_read(dev, ether->mii.phy_id, MII_LPA); if ((lpa & LPA_100FULL) || (lpa & LPA_100HALF)) speed = SPEED_100; else speed = SPEED_10; if ((lpa & LPA_100FULL) || (lpa & LPA_10FULL)) duplex = DUPLEX_FULL; else duplex = DUPLEX_HALF; } else { speed = (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10; duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF; } update_linkspeed_register(dev, speed, duplex); dev_info(&pdev->dev, "%s: Link now %i-%s\n", dev->name, speed, (duplex == DUPLEX_FULL) ? "FullDuplex" : "HalfDuplex"); ether->linkflag = 0x01; netif_carrier_on(dev); }
u32 usbnet_get_link (struct net_device *net) { struct usbnet *dev = netdev_priv(net); /* If a check_connect is defined, return its result */ if (dev->driver_info->check_connect) return dev->driver_info->check_connect (dev) == 0; /* if the device has mii operations, use those */ if (dev->mii.mdio_read) return mii_link_ok(&dev->mii); /* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */ return ethtool_op_get_link(net); }
u32 usbnet_get_link (struct net_device *net) { struct usbnet *dev = netdev_priv(net); /* If a check_connect is defined, return its result */ if (dev->driver_info->check_connect) return dev->driver_info->check_connect (dev) == 0; /* if the device has mii operations, use those */ if (dev->mii.mdio_read) return mii_link_ok(&dev->mii); /* Otherwise, say we're up (to avoid breaking scripts) */ return 1; }
/* * Access the PHY to determine the current link speed and mode, and update the * MAC accordingly. * If no link or auto-negotiation is busy, then no changes are made. */ static void update_linkspeed(struct net_device *dev, int silent) { struct at91_private *lp = netdev_priv(dev); unsigned int bmsr, bmcr, lpa, mac_cfg; unsigned int speed, duplex; if (!mii_link_ok(&lp->mii)) { /* no link */ netif_carrier_off(dev); if (!silent) printk(KERN_INFO "%s: Link down.\n", dev->name); return; } /* Link up, or auto-negotiation still in progress */ read_phy(lp->phy_address, MII_BMSR, &bmsr); read_phy(lp->phy_address, MII_BMCR, &bmcr); if (bmcr & BMCR_ANENABLE) { /* AutoNegotiation is enabled */ if (!(bmsr & BMSR_ANEGCOMPLETE)) return; /* Do nothing - another interrupt generated when negotiation complete */ read_phy(lp->phy_address, MII_LPA, &lpa); if ((lpa & LPA_100FULL) || (lpa & LPA_100HALF)) speed = SPEED_100; else speed = SPEED_10; if ((lpa & LPA_100FULL) || (lpa & LPA_10FULL)) duplex = DUPLEX_FULL; else duplex = DUPLEX_HALF; } else { speed = (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10; duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF; } /* Update the MAC */ mac_cfg = at91_emac_read(AT91_EMAC_CFG) & ~(AT91_EMAC_SPD | AT91_EMAC_FD); if (speed == SPEED_100) { if (duplex == DUPLEX_FULL) /* 100 Full Duplex */ mac_cfg |= AT91_EMAC_SPD | AT91_EMAC_FD; else /* 100 Half Duplex */ mac_cfg |= AT91_EMAC_SPD; } else { if (duplex == DUPLEX_FULL) /* 10 Full Duplex */ mac_cfg |= AT91_EMAC_FD; else {} /* 10 Half Duplex */ } at91_emac_write(AT91_EMAC_CFG, mac_cfg); if (!silent) printk(KERN_INFO "%s: Link now %i-%s\n", dev->name, speed, (duplex == DUPLEX_FULL) ? "FullDuplex" : "HalfDuplex"); netif_carrier_on(dev); }
static void update_linkspeed(struct net_device *dev, int silent) { struct at91_private *lp = netdev_priv(dev); unsigned int bmsr, bmcr, lpa, mac_cfg; unsigned int speed, duplex; if (!mii_link_ok(&lp->mii)) { netif_carrier_off(dev); if (!silent) printk(KERN_INFO "%s: Link down.\n", dev->name); return; } read_phy(lp->phy_address, MII_BMSR, &bmsr); read_phy(lp->phy_address, MII_BMCR, &bmcr); if (bmcr & BMCR_ANENABLE) { if (!(bmsr & BMSR_ANEGCOMPLETE)) return; read_phy(lp->phy_address, MII_LPA, &lpa); if ((lpa & LPA_100FULL) || (lpa & LPA_100HALF)) speed = SPEED_100; else speed = SPEED_10; if ((lpa & LPA_100FULL) || (lpa & LPA_10FULL)) duplex = DUPLEX_FULL; else duplex = DUPLEX_HALF; } else { speed = (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10; duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF; } mac_cfg = at91_emac_read(AT91_EMAC_CFG) & ~(AT91_EMAC_SPD | AT91_EMAC_FD); if (speed == SPEED_100) { if (duplex == DUPLEX_FULL) mac_cfg |= AT91_EMAC_SPD | AT91_EMAC_FD; else mac_cfg |= AT91_EMAC_SPD; } else { if (duplex == DUPLEX_FULL) mac_cfg |= AT91_EMAC_FD; else {} } at91_emac_write(AT91_EMAC_CFG, mac_cfg); if (!silent) printk(KERN_INFO "%s: Link now %i-%s\n", dev->name, speed, (duplex == DUPLEX_FULL) ? "FullDuplex" : "HalfDuplex"); netif_carrier_on(dev); }
/* * setup netdev link state when PHY link status change and * update UMAC and RGMII block when link up */ void bcmgenet_mii_setup(struct net_device *dev) { struct BcmEnet_devctrl *pDevCtrl = netdev_priv(dev); struct ethtool_cmd ecmd ; volatile struct uniMacRegs *umac = pDevCtrl->umac; int cur_link, prev_link; unsigned int val, cmd_bits = 0; if (pDevCtrl->phyType == BRCM_PHY_TYPE_MOCA) return; cur_link = mii_link_ok(&pDevCtrl->mii); prev_link = netif_carrier_ok(pDevCtrl->dev); if (cur_link && !prev_link) { mii_ethtool_gset(&pDevCtrl->mii, &ecmd); /* * program UMAC and RGMII block based on established link * speed, pause, and duplex. * the speed set in umac->cmd tell RGMII block which clock * 25MHz(100Mbps)/125MHz(1Gbps) to use for transmit. * receive clock is provided by PHY. */ if (pDevCtrl->phyType != BRCM_PHY_TYPE_EXT_RGMII_IBS) { GENET_RGMII_OOB_CTRL(pDevCtrl) &= ~OOB_DISABLE; GENET_RGMII_OOB_CTRL(pDevCtrl) |= RGMII_LINK; /* speed */ if (ecmd.speed == SPEED_1000) cmd_bits = UMAC_SPEED_1000; else if (ecmd.speed == SPEED_100) cmd_bits = UMAC_SPEED_100; else cmd_bits = UMAC_SPEED_10; cmd_bits <<= CMD_SPEED_SHIFT; /* duplex */ if (ecmd.duplex != DUPLEX_FULL) cmd_bits |= CMD_HD_EN; } /* pause capability */ if (pDevCtrl->phyType == BRCM_PHY_TYPE_INT || pDevCtrl->phyType == BRCM_PHY_TYPE_EXT_MII) { val = bcmgenet_mii_read( dev, pDevCtrl->phyAddr, MII_LPA); if (!(val & LPA_PAUSE_CAP)) { cmd_bits |= CMD_RX_PAUSE_IGNORE; cmd_bits |= CMD_TX_PAUSE_IGNORE; } } else if (pDevCtrl->phyType == BRCM_PHY_TYPE_EXT_RGMII || pDevCtrl->phyType == BRCM_PHY_TYPE_EXT_RGMII_IBS) { val = bcmgenet_mii_read(dev, pDevCtrl->phyAddr, MII_BRCM_AUX_STAT_SUM); if (!(val & MII_BRCM_AUX_GPHY_RX_PAUSE)) cmd_bits |= CMD_RX_PAUSE_IGNORE; if (!(val & MII_BRCM_AUX_GPHY_TX_PAUSE)) cmd_bits |= CMD_TX_PAUSE_IGNORE; } umac->cmd &= ~((CMD_SPEED_MASK << CMD_SPEED_SHIFT) | CMD_HD_EN | CMD_RX_PAUSE_IGNORE | CMD_TX_PAUSE_IGNORE); umac->cmd |= cmd_bits; netif_carrier_on(pDevCtrl->dev); netdev_info(dev, "link up, %d Mbps, %s duplex\n", ecmd.speed, ecmd.duplex == DUPLEX_FULL ? "full" : "half"); } else if (!cur_link && prev_link) { netif_carrier_off(pDevCtrl->dev); netdev_info(dev, "link down\n"); } }
/** * mii_check_media - check the MII interface for a duplex change * @mii: the MII interface * @ok_to_print: OK to print link up/down messages * @init_media: OK to save duplex mode in @mii * * Returns 1 if the duplex mode changed, 0 if not. * If the media type is forced, always returns 0. */ unsigned int mii_check_media (struct mii_if_info *mii, unsigned int ok_to_print, unsigned int init_media) { unsigned int old_carrier, new_carrier; int advertise, lpa, media, duplex; int lpa2 = 0; /* if forced media, go no further */ if (mii->force_media) return 0; /* duplex did not change */ /* check current and old link status */ old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0; new_carrier = (unsigned int) mii_link_ok(mii); /* if carrier state did not change, this is a "bounce", * just exit as everything is already set correctly */ if ((!init_media) && (old_carrier == new_carrier)) return 0; /* duplex did not change */ /* no carrier, nothing much to do */ if (!new_carrier) { netif_carrier_off(mii->dev); if (ok_to_print) netdev_info(mii->dev, "link down\n"); return 0; /* duplex did not change */ } /* * we have carrier, see who's on the other end */ netif_carrier_on(mii->dev); /* get MII advertise and LPA values */ if ((!init_media) && (mii->advertising)) advertise = mii->advertising; else { advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE); mii->advertising = advertise; } lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA); if (mii->supports_gmii) lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000); /* figure out media and duplex from advertise and LPA values */ media = mii_nway_result(lpa & advertise); duplex = (media & ADVERTISE_FULL) ? 1 : 0; if (lpa2 & LPA_1000FULL) duplex = 1; if (ok_to_print) netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n", lpa2 & (LPA_1000FULL | LPA_1000HALF) ? 1000 : media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ? 100 : 10, duplex ? "full" : "half", lpa); if ((init_media) || (mii->full_duplex != duplex)) { mii->full_duplex = duplex; return 1; /* duplex changed */ } return 0; /* duplex did not change */ }
static u32 gp_get_link(struct net_device *dev) { struct gt64240_private *gp = (struct gt64240_private *) dev->priv; return mii_link_ok(&gp->mii_if); }
static u32 qf9700_get_link(struct net_device *net) { struct usbnet *dev = netdev_priv(net); return mii_link_ok(&dev->mii); }
/* * restart auto-negotiation, config UMAC and RGMII block */ void mii_setup(struct net_device *dev) { struct BcmEnet_devctrl *pDevCtrl = netdev_priv(dev); struct ethtool_cmd ecmd ; volatile struct uniMacRegs *umac = pDevCtrl->umac; TRACE(("%s: %s\n", __func__, netif_carrier_ok(pDevCtrl->dev) ? "netif_carrier_on" : "netif_carrier_off")); if (pDevCtrl->phyType == BRCM_PHY_TYPE_MOCA) { /* MoCA case */ netif_carrier_on(pDevCtrl->dev); pDevCtrl->dev->flags |= IFF_RUNNING; return ; } mii_ethtool_gset(&pDevCtrl->mii, &ecmd); if (mii_link_ok(&pDevCtrl->mii) && !netif_carrier_ok(pDevCtrl->dev)) { printk(KERN_INFO "%s: Link is up, %d Mbps %s Duplex\n", pDevCtrl->dev->name, ecmd.speed, ecmd.duplex == DUPLEX_FULL ? "Full" : "Half"); } else if (!mii_link_ok(&pDevCtrl->mii) && netif_carrier_ok(pDevCtrl->dev)) { printk(KERN_INFO "%s: Link is down\n", pDevCtrl->dev->name); return; } mii_check_link(&pDevCtrl->mii); /* * program UMAC and RGMII block accordingly, if the PHY is * not capable of in-band signaling. */ if (pDevCtrl->phyType != BRCM_PHY_TYPE_EXT_RGMII_IBS) { GENET_RGMII_OOB_CTRL(pDevCtrl) &= ~OOB_DISABLE; GENET_RGMII_OOB_CTRL(pDevCtrl) |= RGMII_LINK; if (ecmd.duplex == DUPLEX_FULL) umac->cmd &= ~CMD_HD_EN; else umac->cmd |= CMD_HD_EN; /* speed */ umac->cmd = umac->cmd & ~(CMD_SPEED_MASK << CMD_SPEED_SHIFT); if (ecmd.speed == SPEED_10) umac->cmd |= (UMAC_SPEED_10 << CMD_SPEED_SHIFT); else if (ecmd.speed == SPEED_100) umac->cmd |= (UMAC_SPEED_100 << CMD_SPEED_SHIFT); else if (ecmd.speed == SPEED_1000) umac->cmd |= (UMAC_SPEED_1000 << CMD_SPEED_SHIFT); } /* pause capability */ if (pDevCtrl->phyType == BRCM_PHY_TYPE_INT || pDevCtrl->phyType == BRCM_PHY_TYPE_EXT_MII) { unsigned int val; val = mii_read(dev, pDevCtrl->phyAddr, MII_LPA); if (!(val & LPA_PAUSE_CAP)) { umac->cmd |= CMD_RX_PAUSE_IGNORE; umac->cmd |= CMD_TX_PAUSE_IGNORE; } } else if (pDevCtrl->phyType == BRCM_PHY_TYPE_EXT_RGMII || pDevCtrl->phyType == BRCM_PHY_TYPE_EXT_RGMII_IBS) { unsigned int val; val = mii_read(dev, pDevCtrl->phyAddr, MII_BRCM_AUX_STAT_SUM); if (!(val & MII_BRCM_AUX_GPHY_RX_PAUSE)) umac->cmd |= CMD_RX_PAUSE_IGNORE; if (!(val & MII_BRCM_AUX_GPHY_TX_PAUSE)) umac->cmd |= CMD_TX_PAUSE_IGNORE; } }
static u32 pegasus_get_link(struct net_device *dev) { pegasus_t *pegasus = netdev_priv(dev); return mii_link_ok(&pegasus->mii); }
static u32 ftmac100_get_link(struct net_device *netdev) { struct ftmac100 *priv = netdev_priv(netdev); return mii_link_ok(&priv->mii); }
static int pegasus_ethtool_ioctl(struct net_device *dev, void __user *useraddr) { u32 ethcmd; pegasus_t *pegasus = dev->priv; if (copy_from_user(ðcmd, useraddr, sizeof (ethcmd))) return -EFAULT; switch (ethcmd) { /* get driver-specific version/etc. info */ case ETHTOOL_GDRVINFO:{ struct ethtool_drvinfo info; memset (&info, 0, sizeof (info)); info.cmd = ETHTOOL_GDRVINFO; strncpy(info.driver, driver_name, sizeof (info.driver) - 1); strncpy(info.version, DRIVER_VERSION, sizeof (info.version) - 1); usb_make_path(pegasus->usb, info.bus_info, sizeof (info.bus_info)); if (copy_to_user(useraddr, &info, sizeof (info))) return -EFAULT; return 0; } /* get settings */ case ETHTOOL_GSET:{ struct ethtool_cmd ecmd = { ETHTOOL_GSET }; mii_ethtool_gset(&pegasus->mii, &ecmd); if (copy_to_user(useraddr, &ecmd, sizeof (ecmd))) return -EFAULT; return 0; } /* set settings */ case ETHTOOL_SSET:{ int r; struct ethtool_cmd ecmd; if (copy_from_user(&ecmd, useraddr, sizeof (ecmd))) return -EFAULT; r = mii_ethtool_sset(&pegasus->mii, &ecmd); return r; } /* restart autonegotiation */ case ETHTOOL_NWAY_RST:{ return mii_nway_restart(&pegasus->mii); } /* get link status */ case ETHTOOL_GLINK:{ struct ethtool_value edata = { ETHTOOL_GLINK }; edata.data = mii_link_ok(&pegasus->mii); if (copy_to_user(useraddr, &edata, sizeof (edata))) return -EFAULT; return 0; } /* get message-level */ case ETHTOOL_GMSGLVL:{ struct ethtool_value edata = { ETHTOOL_GMSGLVL }; /* edata.data = pegasus->msg_enable; FIXME */ if (copy_to_user(useraddr, &edata, sizeof (edata))) return -EFAULT; return 0; } /* set message-level */ case ETHTOOL_SMSGLVL:{ struct ethtool_value edata; if (copy_from_user(&edata, useraddr, sizeof (edata))) return -EFAULT; /* sp->msg_enable = edata.data; FIXME */ return 0; } } return -EOPNOTSUPP; }
static void update_link_speed(unsigned short phy_addr) { unsigned int bmsr, bmcr, lpa, mac_cfg; unsigned int speed, duplex; if (!mii_link_ok(phy_addr)) { EOUT("Link Down\n"); //goto result; } read_phy(phy_addr,MII_BMSR,&bmsr); read_phy(phy_addr,MII_BMCR,&bmcr); if (bmcr & BMCR_ANENABLE) /* AutoNegotiation is enabled */ { if (!(bmsr & BMSR_ANEGCOMPLETE)) /* Do nothing - another interrupt generated when negotiation complete */ goto result; read_phy(phy_addr, MII_LPA, &lpa); if ((lpa & LPA_100FULL) || (lpa & LPA_100HALF)) speed = SPEED_100; else speed = SPEED_10; if ((lpa & LPA_100FULL) || (lpa & LPA_10FULL)) duplex = DUPLEX_FULL; else duplex = DUPLEX_HALF; } else { speed = (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10; duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF; } /* Update the MAC */ mac_cfg = sep_emac_read(MAC_CTRL); if (speed == SPEED_100) { mac_cfg |= 0x800; /* set speed 100 M */ //bmcr &=(~0x2000); //write_phy(lp->phy_address, MII_BMCR, bmcr); //将dm9161的速度设为10M if (duplex == DUPLEX_FULL) /* 100 Full Duplex */ mac_cfg |= 0x400; else /* 100 Half Duplex */ mac_cfg &= (~0x400); } else { mac_cfg &= (~0x800); /* set speed 10 M */ if (duplex == DUPLEX_FULL) /* 10 Full Duplex */ mac_cfg |= 0x400; else /* 10 Half Duplex */ mac_cfg &= (~0x400); } sep_emac_write(MAC_CTRL, mac_cfg); rt_kprintf("Link now %i M-%s\n", speed, (duplex == DUPLEX_FULL) ? "FullDuplex" : "HalfDuplex"); result: mac_cfg = sep_emac_read(MAC_CTRL); DBOUT("After mac_cfg=%d\n",mac_cfg); return; }
static u32 gp_get_link(struct net_device *dev) { struct gt64240_private *gp = netdev_priv(dev); return mii_link_ok(&gp->mii_if); }
/* * Check the link state */ static u32 dmfe_get_link(struct net_device *dev) { board_info_t *db = (board_info_t *)dev->priv; return mii_link_ok(&db->mii); }