// SPDX-License-Identifier: GPL-2.0+ /* * (C) Copyright 2019 * Alex Marginean, NXP */ #include #include #include #include #include #include #include #include #include /* DT node properties for MAC-PHY interface */ #define PHY_MODE_STR_CNT 2 static const char *phy_mode_str[PHY_MODE_STR_CNT] = { "phy-mode", "phy-connection-type" }; /* DT node properties that reference a PHY node */ #define PHY_HANDLE_STR_CNT 3 const char *phy_handle_str[PHY_HANDLE_STR_CNT] = { "phy-handle", "phy", "phy-device" }; void dm_mdio_probe_devices(void) { struct udevice *it; struct uclass *uc; uclass_get(UCLASS_MDIO, &uc); uclass_foreach_dev(it, uc) { device_probe(it); } } static int dm_mdio_post_bind(struct udevice *dev) { const char *dt_name; /* set a custom name for the MDIO device, if present in DT */ if (ofnode_valid(dev->node)) { dt_name = ofnode_read_string(dev->node, "device-name"); if (dt_name) { debug("renaming dev %s to %s\n", dev->name, dt_name); device_set_name(dev, dt_name); } } /* * MDIO command doesn't like spaces in names, don't allow them to keep * it happy */ if (strchr(dev->name, ' ')) { debug("\nError: MDIO device name \"%s\" has a space!\n", dev->name); return -EINVAL; } return 0; } /* * Following read/write/reset functions are registered with legacy MII code. * These are called for PHY operations by upper layers and we further call the * DM MDIO driver functions. */ static int mdio_read(struct mii_dev *mii_bus, int addr, int devad, int reg) { struct udevice *dev = mii_bus->priv; return mdio_get_ops(dev)->read(dev, addr, devad, reg); } static int mdio_write(struct mii_dev *mii_bus, int addr, int devad, int reg, u16 val) { struct udevice *dev = mii_bus->priv; return mdio_get_ops(dev)->write(dev, addr, devad, reg, val); } static int mdio_reset(struct mii_dev *mii_bus) { struct udevice *dev = mii_bus->priv; if (mdio_get_ops(dev)->reset) return mdio_get_ops(dev)->reset(dev); else return 0; } static int dm_mdio_post_probe(struct udevice *dev) { struct mdio_perdev_priv *pdata = dev_get_uclass_priv(dev); pdata->mii_bus = mdio_alloc(); pdata->mii_bus->read = mdio_read; pdata->mii_bus->write = mdio_write; pdata->mii_bus->reset = mdio_reset; pdata->mii_bus->priv = dev; strncpy(pdata->mii_bus->name, dev->name, MDIO_NAME_LEN - 1); return mdio_register(pdata->mii_bus); } static int dm_mdio_pre_remove(struct udevice *dev) { struct mdio_perdev_priv *pdata = dev_get_uclass_priv(dev); struct mdio_ops *ops = mdio_get_ops(dev); if (ops->reset) ops->reset(dev); mdio_unregister(pdata->mii_bus); mdio_free(pdata->mii_bus); return 0; } struct phy_device *dm_mdio_phy_connect(struct udevice *mdiodev, int phyaddr, struct udevice *ethdev, phy_interface_t interface) { struct mdio_perdev_priv *pdata = dev_get_uclass_priv(mdiodev); if (device_probe(mdiodev)) return NULL; return phy_connect(pdata->mii_bus, phyaddr, ethdev, interface); } static struct phy_device *dm_eth_connect_phy_handle(struct udevice *ethdev, phy_interface_t interface) { u32 phy_addr; struct udevice *mdiodev; struct phy_device *phy; struct ofnode_phandle_args phandle = {.node = ofnode_null()}; int i; for (i = 0; i < PHY_HANDLE_STR_CNT; i++) if (!dev_read_phandle_with_args(ethdev, phy_handle_str[i], NULL, 0, 0, &phandle)) break; if (!ofnode_valid(phandle.node)) { dev_dbg(ethdev, "can't find PHY node\n"); return NULL; } /* * reading 'reg' directly should be fine. This is a PHY node, the * address is always size 1 and requires no translation */ if (ofnode_read_u32(phandle.node, "reg", &phy_addr)) { dev_dbg(ethdev, "missing reg property in phy node\n"); return NULL; } if (uclass_get_device_by_ofnode(UCLASS_MDIO, ofnode_get_parent(phandle.node), &mdiodev)) { dev_dbg(ethdev, "can't find MDIO bus for node %s\n", ofnode_get_name(ofnode_get_parent(phandle.node))); return NULL; } phy = dm_mdio_phy_connect(mdiodev, phy_addr, ethdev, interface); if (phy) phy->node = phandle.node; return phy; } /* Connect to a PHY linked in eth DT node */ struct phy_device *dm_eth_phy_connect(struct udevice *ethdev) { const char *if_str; phy_interface_t interface; struct phy_device *phy; int i; if (!ofnode_valid(ethdev->node)) { debug("%s: supplied eth dev has no DT node!\n", ethdev->name); return NULL; } interface = PHY_INTERFACE_MODE_NONE; for (i = 0; i < PHY_MODE_STR_CNT; i++) { if_str = ofnode_read_string(ethdev->node, phy_mode_str[i]); if (if_str) { interface = phy_get_interface_by_name(if_str); break; } } if (interface < 0) interface = PHY_INTERFACE_MODE_NONE; if (interface == PHY_INTERFACE_MODE_NONE) dev_dbg(ethdev, "can't find interface mode, default to NONE\n"); phy = dm_eth_connect_phy_handle(ethdev, interface); if (!phy) return NULL; phy->interface = interface; return phy; } UCLASS_DRIVER(mdio) = { .id = UCLASS_MDIO, .name = "mdio", .post_bind = dm_mdio_post_bind, .post_probe = dm_mdio_post_probe, .pre_remove = dm_mdio_pre_remove, .per_device_auto_alloc_size = sizeof(struct mdio_perdev_priv), };