static int xgmiitorgmii_probe(struct mdio_device *mdiodev) { struct device *dev = &mdiodev->dev; struct device_node *np = dev->of_node, *phy_node; struct gmii2rgmii *priv; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; phy_node = of_parse_phandle(np, "phy-handle", 0); if (!phy_node) { dev_err(dev, "Couldn't parse phy-handle\n"); return -ENODEV; } priv->phy_dev = of_phy_find_device(phy_node); of_node_put(phy_node); if (!priv->phy_dev) { dev_info(dev, "Couldn't find phydev\n"); return -EPROBE_DEFER; } priv->addr = mdiodev->addr; priv->phy_drv = priv->phy_dev->drv; memcpy(&priv->conv_phy_drv, priv->phy_dev->drv, sizeof(struct phy_driver)); priv->conv_phy_drv.read_status = xgmiitorgmii_read_status; priv->phy_dev->priv = priv; priv->phy_dev->drv = &priv->conv_phy_drv; return 0; }
struct phy_device *of_phy_connect(struct net_device *dev, struct device_node *phy_np, void (*hndlr)(struct net_device *), u32 flags, phy_interface_t iface) { struct phy_device *phy = of_phy_find_device(phy_np); if (!phy) return NULL; return phy_connect_direct(dev, phy, hndlr, flags, iface) ? NULL : phy; }
static int bcmgenet_mii_of_init(struct bcmgenet_priv *priv) { struct device_node *dn = priv->pdev->dev.of_node; struct device *kdev = &priv->pdev->dev; struct phy_device *phydev; int phy_mode; int ret; /* Fetch the PHY phandle */ priv->phy_dn = of_parse_phandle(dn, "phy-handle", 0); /* In the case of a fixed PHY, the DT node associated * to the PHY is the Ethernet MAC DT node. */ if (!priv->phy_dn && of_phy_is_fixed_link(dn)) { ret = of_phy_register_fixed_link(dn); if (ret) return ret; priv->phy_dn = of_node_get(dn); } /* Get the link mode */ phy_mode = of_get_phy_mode(dn); if (phy_mode < 0) { dev_err(kdev, "invalid PHY mode property\n"); return phy_mode; } priv->phy_interface = phy_mode; /* We need to specifically look up whether this PHY interface is internal * or not *before* we even try to probe the PHY driver over MDIO as we * may have shut down the internal PHY for power saving purposes. */ if (priv->phy_interface == PHY_INTERFACE_MODE_INTERNAL) priv->internal_phy = true; /* Make sure we initialize MoCA PHYs with a link down */ if (phy_mode == PHY_INTERFACE_MODE_MOCA) { phydev = of_phy_find_device(dn); if (phydev) { phydev->link = 0; put_device(&phydev->mdio.dev); } } return 0; }
/* Configure the MDIO bus and connect the external PHY */ int emac_phy_config(struct platform_device *pdev, struct emac_adapter *adpt) { struct device_node *np = pdev->dev.of_node; struct mii_bus *mii_bus; int ret; /* Create the mii_bus object for talking to the MDIO bus */ adpt->mii_bus = mii_bus = devm_mdiobus_alloc(&pdev->dev); if (!mii_bus) return -ENOMEM; mii_bus->name = "emac-mdio"; snprintf(mii_bus->id, MII_BUS_ID_SIZE, "%s", pdev->name); mii_bus->read = emac_mdio_read; mii_bus->write = emac_mdio_write; mii_bus->parent = &pdev->dev; mii_bus->priv = adpt; if (has_acpi_companion(&pdev->dev)) { u32 phy_addr; ret = mdiobus_register(mii_bus); if (ret) { dev_err(&pdev->dev, "could not register mdio bus\n"); return ret; } ret = device_property_read_u32(&pdev->dev, "phy-channel", &phy_addr); if (ret) /* If we can't read a valid phy address, then assume * that there is only one phy on this mdio bus. */ adpt->phydev = phy_find_first(mii_bus); else adpt->phydev = mdiobus_get_phy(mii_bus, phy_addr); /* of_phy_find_device() claims a reference to the phydev, * so we do that here manually as well. When the driver * later unloads, it can unilaterally drop the reference * without worrying about ACPI vs DT. */ if (adpt->phydev) get_device(&adpt->phydev->mdio.dev); } else { struct device_node *phy_np; ret = of_mdiobus_register(mii_bus, np); if (ret) { dev_err(&pdev->dev, "could not register mdio bus\n"); return ret; } phy_np = of_parse_phandle(np, "phy-handle", 0); adpt->phydev = of_phy_find_device(phy_np); of_node_put(phy_np); } if (!adpt->phydev) { dev_err(&pdev->dev, "could not find external phy\n"); mdiobus_unregister(mii_bus); return -ENODEV; } return 0; }
int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br) { struct dsa_notifier_bridge_info info = { .sw_index = dp->ds->index, .port = dp->index, .br = br, }; int err; /* Here the port is already bridged. Reflect the current configuration * so that drivers can program their chips accordingly. */ dp->bridge_dev = br; err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_JOIN, &info); /* The bridging is rolled back on error */ if (err) dp->bridge_dev = NULL; return err; } void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br) { struct dsa_notifier_bridge_info info = { .sw_index = dp->ds->index, .port = dp->index, .br = br, }; int err; /* Here the port is already unbridged. Reflect the current configuration * so that drivers can program their chips accordingly. */ dp->bridge_dev = NULL; err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_LEAVE, &info); if (err) pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n"); /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer, * so allow it to be in BR_STATE_FORWARDING to be kept functional */ dsa_port_set_state_now(dp, BR_STATE_FORWARDING); } int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering, struct switchdev_trans *trans) { struct dsa_switch *ds = dp->ds; /* bridge skips -EOPNOTSUPP, so skip the prepare phase */ if (switchdev_trans_ph_prepare(trans)) return 0; if (ds->ops->port_vlan_filtering) return ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering); return 0; } int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock, struct switchdev_trans *trans) { unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock); unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies); struct dsa_notifier_ageing_time_info info = { .ageing_time = ageing_time, .trans = trans, }; if (switchdev_trans_ph_prepare(trans)) return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); dp->ageing_time = ageing_time; return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); } int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr, u16 vid) { struct dsa_notifier_fdb_info info = { .sw_index = dp->ds->index, .port = dp->index, .addr = addr, .vid = vid, }; return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info); } int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr, u16 vid) { struct dsa_notifier_fdb_info info = { .sw_index = dp->ds->index, .port = dp->index, .addr = addr, .vid = vid, }; return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info); } int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data) { struct dsa_switch *ds = dp->ds; int port = dp->index; if (!ds->ops->port_fdb_dump) return -EOPNOTSUPP; return ds->ops->port_fdb_dump(ds, port, cb, data); } int dsa_port_mdb_add(const struct dsa_port *dp, const struct switchdev_obj_port_mdb *mdb, struct switchdev_trans *trans) { struct dsa_notifier_mdb_info info = { .sw_index = dp->ds->index, .port = dp->index, .trans = trans, .mdb = mdb, }; return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info); } int dsa_port_mdb_del(const struct dsa_port *dp, const struct switchdev_obj_port_mdb *mdb) { struct dsa_notifier_mdb_info info = { .sw_index = dp->ds->index, .port = dp->index, .mdb = mdb, }; return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info); } int dsa_port_vlan_add(struct dsa_port *dp, const struct switchdev_obj_port_vlan *vlan, struct switchdev_trans *trans) { struct dsa_notifier_vlan_info info = { .sw_index = dp->ds->index, .port = dp->index, .trans = trans, .vlan = vlan, }; if (netif_is_bridge_master(vlan->obj.orig_dev)) return -EOPNOTSUPP; if (br_vlan_enabled(dp->bridge_dev)) return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info); return 0; } int dsa_port_vlan_del(struct dsa_port *dp, const struct switchdev_obj_port_vlan *vlan) { struct dsa_notifier_vlan_info info = { .sw_index = dp->ds->index, .port = dp->index, .vlan = vlan, }; if (netif_is_bridge_master(vlan->obj.orig_dev)) return -EOPNOTSUPP; if (br_vlan_enabled(dp->bridge_dev)) return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); return 0; } static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp) { struct device_node *phy_dn; struct phy_device *phydev; phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0); if (!phy_dn) return NULL; phydev = of_phy_find_device(phy_dn); if (!phydev) { of_node_put(phy_dn); return ERR_PTR(-EPROBE_DEFER); } return phydev; } static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable) { struct dsa_switch *ds = dp->ds; struct phy_device *phydev; int port = dp->index; int err = 0; phydev = dsa_port_get_phy_device(dp); if (!phydev) return 0; if (IS_ERR(phydev)) return PTR_ERR(phydev); if (enable) { err = genphy_config_init(phydev); if (err < 0) goto err_put_dev; err = genphy_resume(phydev); if (err < 0) goto err_put_dev; err = genphy_read_status(phydev); if (err < 0) goto err_put_dev; } else { err = genphy_suspend(phydev); if (err < 0) goto err_put_dev; } if (ds->ops->adjust_link) ds->ops->adjust_link(ds, port, phydev); dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); err_put_dev: put_device(&phydev->mdio.dev); return err; } static int dsa_port_fixed_link_register_of(struct dsa_port *dp) { struct device_node *dn = dp->dn; struct dsa_switch *ds = dp->ds; struct phy_device *phydev; int port = dp->index; int mode; int err; err = of_phy_register_fixed_link(dn); if (err) { dev_err(ds->dev, "failed to register the fixed PHY of port %d\n", port); return err; } phydev = of_phy_find_device(dn); mode = of_get_phy_mode(dn); if (mode < 0) mode = PHY_INTERFACE_MODE_NA; phydev->interface = mode; genphy_config_init(phydev); genphy_read_status(phydev); if (ds->ops->adjust_link) ds->ops->adjust_link(ds, port, phydev); put_device(&phydev->mdio.dev); return 0; } int dsa_port_link_register_of(struct dsa_port *dp) { if (of_phy_is_fixed_link(dp->dn)) return dsa_port_fixed_link_register_of(dp); else return dsa_port_setup_phy_of(dp, true); } void dsa_port_link_unregister_of(struct dsa_port *dp) { if (of_phy_is_fixed_link(dp->dn)) of_phy_deregister_fixed_link(dp->dn); else dsa_port_setup_phy_of(dp, false); } int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data) { struct phy_device *phydev; int ret = -EOPNOTSUPP; if (of_phy_is_fixed_link(dp->dn)) return ret; phydev = dsa_port_get_phy_device(dp); if (IS_ERR_OR_NULL(phydev)) return ret; ret = phy_ethtool_get_strings(phydev, data); put_device(&phydev->mdio.dev); return ret; } EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings); int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data) { struct phy_device *phydev; int ret = -EOPNOTSUPP; if (of_phy_is_fixed_link(dp->dn)) return ret; phydev = dsa_port_get_phy_device(dp); if (IS_ERR_OR_NULL(phydev)) return ret; ret = phy_ethtool_get_stats(phydev, NULL, data); put_device(&phydev->mdio.dev); return ret; } EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats); int dsa_port_get_phy_sset_count(struct dsa_port *dp) { struct phy_device *phydev; int ret = -EOPNOTSUPP; if (of_phy_is_fixed_link(dp->dn)) return ret; phydev = dsa_port_get_phy_device(dp); if (IS_ERR_OR_NULL(phydev)) return ret; ret = phy_ethtool_get_sset_count(phydev); put_device(&phydev->mdio.dev); return ret; } EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);