static int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
if (!dev->phydev)
return -EINVAL;
return phy_mii_ioctl(dev->phydev, rq, cmd);
}
static int bgmac_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd)
{
if (!netif_running(net_dev))
return -EINVAL;
return phy_mii_ioctl(net_dev->phydev, ifr, cmd);
}
static int eth_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
{
struct port *port = netdev_priv(dev);
if (!netif_running(dev))
return -EINVAL;
return phy_mii_ioctl(port->phydev, if_mii(req), cmd);
}
/**
* phylink_mii_ioctl() - generic mii ioctl interface
* @pl: a pointer to a &struct phylink returned from phylink_create()
* @ifr: a pointer to a &struct ifreq for socket ioctls
* @cmd: ioctl cmd to execute
*
* Perform the specified MII ioctl on the PHY attached to the phylink instance
* specified by @pl. If no PHY is attached, emulate the presence of the PHY.
*
* Returns: zero on success or negative error code.
*
* %SIOCGMIIPHY:
* read register from the current PHY.
* %SIOCGMIIREG:
* read register from the specified PHY.
* %SIOCSMIIREG:
* set a register on the specified PHY.
*/
int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd)
{
struct mii_ioctl_data *mii = if_mii(ifr);
int ret;
ASSERT_RTNL();
if (pl->phydev) {
/* PHYs only exist for MLO_AN_PHY and SGMII */
switch (cmd) {
case SIOCGMIIPHY:
mii->phy_id = pl->phydev->mdio.addr;
/* fall through */
case SIOCGMIIREG:
ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num);
if (ret >= 0) {
mii->val_out = ret;
ret = 0;
}
break;
case SIOCSMIIREG:
ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num,
mii->val_in);
break;
default:
ret = phy_mii_ioctl(pl->phydev, ifr, cmd);
break;
}
} else {
switch (cmd) {
case SIOCGMIIPHY:
mii->phy_id = 0;
/* fall through */
case SIOCGMIIREG:
ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num);
if (ret >= 0) {
mii->val_out = ret;
ret = 0;
}
break;
case SIOCSMIIREG:
ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num,
mii->val_in);
break;
default:
ret = -EOPNOTSUPP;
break;
}
}
return ret;
}
static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
struct dsa_slave_priv *p = netdev_priv(dev);
if (p->phy != NULL)
return phy_mii_ioctl(p->phy, ifr, cmd);
return -EOPNOTSUPP;
}
static int bgmac_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd)
{
struct bgmac *bgmac = netdev_priv(net_dev);
if (!netif_running(net_dev))
return -EINVAL;
return phy_mii_ioctl(bgmac->phy_dev, ifr, cmd);
}
static int pci_eth_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct pci_eth_private *priv = netdev_priv(dev);
if (!priv->phydev)
return -EINVAL;
return phy_mii_ioctl(priv->phydev, rq, cmd);
}
static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct fs_enet_private *fep = netdev_priv(dev);
if (!netif_running(dev))
return -EINVAL;
return phy_mii_ioctl(fep->phydev, rq, cmd);
}
static int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct r6040_private *lp = netdev_priv(dev);
if (!lp->phydev)
return -EINVAL;
return phy_mii_ioctl(lp->phydev, rq, cmd);
}
static int au1000_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct au1000_private *aup = netdev_priv(dev);
if (!netif_running(dev)) return -EINVAL;
if (!aup->phy_dev) return -EINVAL; // PHY not controllable
return phy_mii_ioctl(aup->phy_dev, if_mii(rq), cmd);
}
static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct fs_enet_private *fep = netdev_priv(dev);
struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&rq->ifr_data;
if (!netif_running(dev))
return -EINVAL;
return phy_mii_ioctl(fep->phydev, mii, cmd);
}
static int ax88172a_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
{
if (!netif_running(net))
return -EINVAL;
if (!net->phydev)
return -ENODEV;
return phy_mii_ioctl(net->phydev, rq, cmd);
}
static int octeon_mgmt_ioctl(struct net_device *netdev,
struct ifreq *rq, int cmd)
{
switch (cmd) {
case SIOCSHWTSTAMP:
return octeon_mgmt_ioctl_hwtstamp(netdev, rq, cmd);
default:
if (netdev->phydev)
return phy_mii_ioctl(netdev->phydev, rq, cmd);
return -EINVAL;
}
}
/**
* cvm_oct_ioctl - IOCTL support for PHY control
* @dev: Device to change
* @rq: the request
* @cmd: the command
*
* Returns Zero on success
*/
int cvm_oct_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct octeon_ethernet *priv = netdev_priv(dev);
if (!netif_running(dev))
return -EINVAL;
if (!priv->phydev)
return -EINVAL;
return phy_mii_ioctl(priv->phydev, rq, cmd);
}
static int emac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct phy_device *phydev = dev->phydev;
if (!netif_running(dev))
return -EINVAL;
if (!phydev)
return -ENODEV;
return phy_mii_ioctl(phydev, rq, cmd);
}
static int hieth_net_ioctl(struct net_device *net_dev, \
struct ifreq *ifreq, int cmd)
{
struct hieth_netdev_local *ld = netdev_priv(net_dev);
if (!netif_running(net_dev))
return -EINVAL;
if (!ld->phy)
return -EINVAL;
return phy_mii_ioctl(ld->phy, ifreq, cmd);
}
static int emac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct emac_board_info *dm = netdev_priv(dev);
struct phy_device *phydev = dm->phy_dev;
if (!netif_running(dev))
return -EINVAL;
if (!phydev)
return -ENODEV;
return phy_mii_ioctl(phydev, rq, cmd);
}
static int octeon_mgmt_ioctl(struct net_device *netdev,
struct ifreq *rq, int cmd)
{
struct octeon_mgmt *p = netdev_priv(netdev);
if (!netif_running(netdev))
return -EINVAL;
if (!p->phydev)
return -EINVAL;
return phy_mii_ioctl(p->phydev, rq, cmd);
}
/* ioctl to device funciotn*/
static int sh_eth_do_ioctl(struct net_device *ndev, struct ifreq *rq,
int cmd)
{
struct sh_eth_private *mdp = netdev_priv(ndev);
struct phy_device *phydev = mdp->phydev;
if (!netif_running(ndev))
return -EINVAL;
if (!phydev)
return -ENODEV;
return phy_mii_ioctl(phydev, if_mii(rq), cmd);
}
static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct fs_enet_private *fep = netdev_priv(dev);
struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&rq->ifr_data;
unsigned long flags;
int rc;
if (!netif_running(dev))
return -EINVAL;
spin_lock_irqsave(&fep->lock, flags);
rc = phy_mii_ioctl(fep->phydev, mii, cmd);
spin_unlock_irqrestore(&fep->lock, flags);
return rc;
}
/**
* stmmac_ioctl - Entry point for the Ioctl
* @dev: Device pointer.
* @rq: An IOCTL specefic structure, that can contain a pointer to
* a proprietary structure used to pass information to the driver.
* @cmd: IOCTL command
* Description:
* Currently there are no special functionality supported in IOCTL, just the
* phy_mii_ioctl(...) can be invoked.
*/
static int stmmac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct stmmac_priv *priv = netdev_priv(dev);
int ret;
if (!netif_running(dev))
return -EINVAL;
if (!priv->phydev)
return -EINVAL;
spin_lock(&priv->lock);
ret = phy_mii_ioctl(priv->phydev, rq, cmd);
spin_unlock(&priv->lock);
return ret;
}
static int ag71xx_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
struct mii_ioctl_data *data = (struct mii_ioctl_data *) &ifr->ifr_data;
struct ag71xx *ag = netdev_priv(dev);
int ret;
switch (cmd) {
case SIOCETHTOOL:
if (ag->phy_dev == NULL)
break;
spin_lock_irq(&ag->lock);
ret = phy_ethtool_ioctl(ag->phy_dev, (void *) ifr->ifr_data);
spin_unlock_irq(&ag->lock);
return ret;
case SIOCSIFHWADDR:
if (copy_from_user
(dev->dev_addr, ifr->ifr_data, sizeof(dev->dev_addr)))
return -EFAULT;
return 0;
case SIOCGIFHWADDR:
if (copy_to_user
(ifr->ifr_data, dev->dev_addr, sizeof(dev->dev_addr)))
return -EFAULT;
return 0;
case SIOCGMIIPHY:
case SIOCGMIIREG:
case SIOCSMIIREG:
if (ag->phy_dev == NULL)
break;
return phy_mii_ioctl(ag->phy_dev, data, cmd);
default:
break;
}
return -EOPNOTSUPP;
}
static int bcm_enet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct bcm_enet_priv *priv;
priv = netdev_priv(dev);
if (priv->has_phy) {
if (!priv->phydev)
return -ENODEV;
return phy_mii_ioctl(priv->phydev, if_mii(rq), cmd);
} else {
struct mii_if_info mii;
mii.dev = dev;
mii.mdio_read = bcm_enet_mdio_read_mii;
mii.mdio_write = bcm_enet_mdio_write_mii;
mii.phy_id = 0;
mii.phy_id_mask = 0x3f;
mii.reg_num_mask = 0x1f;
return generic_mii_ioctl(&mii, if_mii(rq), cmd, NULL);
}
}
/**
* cvm_oct_ioctl - IOCTL support for PHY control
* @dev: Device to change
* @rq: the request
* @cmd: the command
*
* Returns Zero on success
*/
int cvm_oct_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct octeon_ethernet *priv = netdev_priv(dev);
cvmx_srio_tx_message_header_t tx_header;
int ivalue;
switch (cmd) {
case CAVIUM_NET_IOCTL_SETPRIO:
ivalue = rq->ifr_ifru.ifru_ivalue;
if ((ivalue >= 0) && (ivalue < 4)) {
tx_header.u64 = priv->srio_tx_header;
tx_header.s.prio = ivalue;
priv->srio_tx_header = tx_header.u64;
return 0;
}
return -EINVAL;
case CAVIUM_NET_IOCTL_GETPRIO:
tx_header.u64 = priv->srio_tx_header;
rq->ifr_ifru.ifru_ivalue = tx_header.s.prio;
return 0;
case CAVIUM_NET_IOCTL_SETIDSIZE:
ivalue = rq->ifr_ifru.ifru_ivalue;
if ((ivalue >= 0) && (ivalue < 2)) {
tx_header.u64 = priv->srio_tx_header;
tx_header.s.tt = ivalue;
priv->srio_tx_header = tx_header.u64;
return 0;
}
return -EINVAL;
case CAVIUM_NET_IOCTL_GETIDSIZE:
tx_header.u64 = priv->srio_tx_header;
rq->ifr_ifru.ifru_ivalue = tx_header.s.tt;
return 0;
case CAVIUM_NET_IOCTL_SETSRCID:
ivalue = rq->ifr_ifru.ifru_ivalue;
if ((ivalue >= 0) && (ivalue < 2)) {
tx_header.u64 = priv->srio_tx_header;
tx_header.s.sis = ivalue;
priv->srio_tx_header = tx_header.u64;
return 0;
}
return -EINVAL;
case CAVIUM_NET_IOCTL_GETSRCID:
tx_header.u64 = priv->srio_tx_header;
rq->ifr_ifru.ifru_ivalue = tx_header.s.sis;
return 0;
case CAVIUM_NET_IOCTL_SETLETTER:
ivalue = rq->ifr_ifru.ifru_ivalue;
if ((ivalue >= -1) && (ivalue < 4)) {
tx_header.u64 = priv->srio_tx_header;
tx_header.s.lns = (ivalue == -1);
if (tx_header.s.lns)
tx_header.s.letter = 0;
else
tx_header.s.letter = ivalue;
priv->srio_tx_header = tx_header.u64;
return 0;
}
return -EINVAL;
case CAVIUM_NET_IOCTL_GETLETTER:
tx_header.u64 = priv->srio_tx_header;
if (tx_header.s.lns)
rq->ifr_ifru.ifru_ivalue = -1;
else
rq->ifr_ifru.ifru_ivalue = tx_header.s.letter;
return 0;
case SIOCSHWTSTAMP:
return cvm_oct_ioctl_hwtstamp(dev, rq, cmd);
default:
if (priv->phydev)
return phy_mii_ioctl(priv->phydev, if_mii(rq), cmd);
return -EINVAL;
}
}