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);
}
static int dmfe_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
board_info_t *db = (board_info_t *)dev->priv;
spin_lock_irq(&db->lock);
mii_ethtool_gset(&db->mii, cmd);
spin_unlock_irq(&db->lock);
return 0;
}
int usbnet_get_settings (struct net_device *net, struct ethtool_cmd *cmd)
{
struct usbnet *dev = netdev_priv(net);
if (!dev->mii.mdio_read)
return -EOPNOTSUPP;
return mii_ethtool_gset(&dev->mii, cmd);
}
static int et_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
END_DEVICE *ei_local = netdev_priv(dev);
#else
END_DEVICE *ei_local = dev->priv;
#endif
mii_ethtool_gset(&ei_local->mii_info, cmd);
return 0;
}
static int et_virt_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
PSEUDO_ADAPTER *pseudo = netdev_priv(dev);
#else
PSEUDO_ADAPTER *pseudo = dev->priv;
#endif
mii_ethtool_gset(&pseudo->mii_info, cmd);
return 0;
}
static int gp_get_settings(struct net_device *dev,
struct ethtool_cmd *cmd)
{
struct gt64240_private *gp = netdev_priv(dev);
int rc;
spin_lock_irq(&gp->lock);
rc = mii_ethtool_gset(&gp->mii_if, cmd);
spin_unlock_irq(&gp->lock);
return rc;
}
static int cvm_oct_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
struct octeon_ethernet *priv = netdev_priv(dev);
int ret;
down(&mdio_sem);
ret = mii_ethtool_gset(&priv->mii_info, cmd);
up(&mdio_sem);
return ret;
}
static int fs_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
struct fs_enet_private *fep = netdev_priv(dev);
unsigned long flags;
int rc;
spin_lock_irqsave(&fep->lock, flags);
rc = mii_ethtool_gset(&fep->mii_if, cmd);
spin_unlock_irqrestore(&fep->lock, flags);
return rc;
}
/*
* ethtool callbacks
*/
static int enet_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
struct tangox_enet_priv *priv;
int ret;
priv = netdev_priv(dev);
spin_lock_bh(&priv->mii_lock);
ret = mii_ethtool_gset(&priv->mii, cmd);
spin_unlock_bh(&priv->mii_lock);
return ret;
}
static int pch_gbe_get_settings(struct net_device *netdev,
struct ethtool_cmd *ecmd)
{
struct pch_gbe_adapter *adapter = netdev_priv(netdev);
int ret;
ret = mii_ethtool_gset(&adapter->mii, ecmd);
ecmd->supported &= ~(SUPPORTED_TP | SUPPORTED_1000baseT_Half);
ecmd->advertising &= ~(ADVERTISED_TP | ADVERTISED_1000baseT_Half);
if (!netif_carrier_ok(adapter->netdev))
ethtool_cmd_speed_set(ecmd, -1);
return ret;
}
/******************************************************************************
* mv_eth_tool_get_settings
* Description:
* ethtool get standard port settings
* INPUT:
* netdev Network device structure pointer
* OUTPUT
* cmd command (settings)
* RETURN:
* 0 for success
*
*******************************************************************************/
int mv_eth_tool_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
{
mv_eth_priv *priv = MV_ETH_PRIV(netdev);
struct mii_if_info mii;
int retval;
MV_ETH_PORT_STATUS status;
#ifdef CONFIG_MII
mii.dev = netdev;
mii.phy_id_mask = 0x1F;
mii.reg_num_mask = 0x1F;
mii.mdio_read = mv_eth_tool_read_mdio;
mii.mdio_write = mv_eth_tool_write_mdio;
mii.phy_id = priv->phy_id;
mii.supports_gmii = 1;
/* Get values from PHY */
retval = mii_ethtool_gset(&mii, cmd);
if (retval)
return retval;
#endif
/* Get some values from MAC */
mvEthStatusGet(priv->hal_priv, &status);
switch (status.speed) {
case MV_ETH_SPEED_1000:
cmd->speed = SPEED_1000;
break;
case MV_ETH_SPEED_100:
cmd->speed = SPEED_100;
break;
case MV_ETH_SPEED_10:
cmd->speed = SPEED_10;
break;
default:
return -EINVAL;
}
if (status.duplex == MV_ETH_DUPLEX_FULL)
cmd->duplex = 1;
else
cmd->duplex = 0;
cmd->port = PORT_MII;
cmd->phy_address = priv->phy_id;
return 0;
}
/******************************************************************************
* mv_eth_tool_get_settings
* Description:
* ethtool get standard port settings
* INPUT:
* netdev Network device structure pointer
* OUTPUT
* cmd command (settings)
* RETURN:
* 0 for success
*
*******************************************************************************/
int mv_eth_tool_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
{
struct eth_port *priv = MV_ETH_PRIV(netdev);
int retval;
#ifdef CONFIG_MV_ETH_SWITCH
if (isSwitch(priv))
return -EPERM;
#endif /* CONFIG_MV_ETH_SWITCH */
#ifdef CONFIG_MII
retval = mii_ethtool_gset(&priv->mii, cmd);
if (retval)
return retval;
#endif /* CONFIG_MII */
if (priv) {
MV_ETH_PORT_STATUS status;
mvNetaLinkStatus(priv->port, &status);
switch (status.speed) {
case MV_ETH_SPEED_1000:
cmd->speed = SPEED_1000;
break;
case MV_ETH_SPEED_100:
cmd->speed = SPEED_100;
break;
case MV_ETH_SPEED_10:
cmd->speed = SPEED_10;
break;
default:
return -EINVAL;
}
if (status.duplex == MV_ETH_DUPLEX_FULL)
cmd->duplex = 1;
else
cmd->duplex = 0;
cmd->port = PORT_MII;
cmd->phy_address = mvBoardPhyAddrGet(priv->port);
}
return 0;
}
/*
* 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 int ftmac100_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
{
struct ftmac100 *priv = netdev_priv(netdev);
return mii_ethtool_gset(&priv->mii, cmd);
}
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;
}
/*
* 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");
}
}
static int pegasus_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
{
pegasus_t *pegasus = netdev_priv(dev);
mii_ethtool_gset(&pegasus->mii, ecmd);
return 0;
}
