drivers/net/mdio/mdio-airoha.c

// SPDX-License-Identifier: GPL-2.0
/* Airoha AN7583 MDIO interface driver
 *
 * Copyright (C) 2025 Christian Marangi <ansuelsmth@gmail.com>
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/of_mdio.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/reset.h>

/* MII address register definitions */
#define   AN7583_MII_BUSY			BIT(31)
#define   AN7583_MII_RDY			BIT(30) /* RO signal BUS is ready */
#define   AN7583_MII_CL22_REG_ADDR		GENMASK(29, 25)
#define   AN7583_MII_CL45_DEV_ADDR		AN7583_MII_CL22_REG_ADDR
#define   AN7583_MII_PHY_ADDR			GENMASK(24, 20)
#define   AN7583_MII_CMD			GENMASK(19, 18)
#define   AN7583_MII_CMD_CL22_WRITE		FIELD_PREP_CONST(AN7583_MII_CMD, 0x1)
#define   AN7583_MII_CMD_CL22_READ		FIELD_PREP_CONST(AN7583_MII_CMD, 0x2)
#define   AN7583_MII_CMD_CL45_ADDR		FIELD_PREP_CONST(AN7583_MII_CMD, 0x0)
#define   AN7583_MII_CMD_CL45_WRITE		FIELD_PREP_CONST(AN7583_MII_CMD, 0x1)
#define   AN7583_MII_CMD_CL45_POSTREAD_INCADDR	FIELD_PREP_CONST(AN7583_MII_CMD, 0x2)
#define   AN7583_MII_CMD_CL45_READ		FIELD_PREP_CONST(AN7583_MII_CMD, 0x3)
#define   AN7583_MII_ST				GENMASK(17, 16)
#define   AN7583_MII_ST_CL45			FIELD_PREP_CONST(AN7583_MII_ST, 0x0)
#define   AN7583_MII_ST_CL22			FIELD_PREP_CONST(AN7583_MII_ST, 0x1)
#define   AN7583_MII_RWDATA			GENMASK(15, 0)
#define   AN7583_MII_CL45_REG_ADDR		AN7583_MII_RWDATA

#define AN7583_MII_MDIO_DELAY_USEC		100
#define AN7583_MII_MDIO_RETRY_MSEC		100

struct airoha_mdio_data {
	u32 base_addr;
	struct regmap *regmap;
	struct clk *clk;
	struct reset_control *reset;
};

static int airoha_mdio_wait_busy(struct airoha_mdio_data *priv)
{
	u32 busy;

	return regmap_read_poll_timeout(priv->regmap, priv->base_addr, busy,
					!(busy & AN7583_MII_BUSY),
					AN7583_MII_MDIO_DELAY_USEC,
					AN7583_MII_MDIO_RETRY_MSEC * USEC_PER_MSEC);
}

static void airoha_mdio_reset(struct airoha_mdio_data *priv)
{
	/* There seems to be Hardware bug where AN7583_MII_RWDATA
	 * is not wiped in the context of unconnected PHY and the
	 * previous read value is returned.
	 *
	 * Example: (only one PHY on the BUS at 0x1f)
	 *  - read at 0x1f report at 0x2 0x7500
	 *  - read at 0x0 report 0x7500 on every address
	 *
	 * To workaround this, we reset the Mdio BUS at every read
	 * to have consistent values on read operation.
	 */
	reset_control_assert(priv->reset);
	reset_control_deassert(priv->reset);
}

static int airoha_mdio_read(struct mii_bus *bus, int addr, int regnum)
{
	struct airoha_mdio_data *priv = bus->priv;
	u32 val;
	int ret;

	airoha_mdio_reset(priv);

	val = AN7583_MII_BUSY | AN7583_MII_ST_CL22 |
	      AN7583_MII_CMD_CL22_READ;
	val |= FIELD_PREP(AN7583_MII_PHY_ADDR, addr);
	val |= FIELD_PREP(AN7583_MII_CL22_REG_ADDR, regnum);

	ret = regmap_write(priv->regmap, priv->base_addr, val);
	if (ret)
		return ret;

	ret = airoha_mdio_wait_busy(priv);
	if (ret)
		return ret;

	ret = regmap_read(priv->regmap, priv->base_addr, &val);
	if (ret)
		return ret;

	return FIELD_GET(AN7583_MII_RWDATA, val);
}

static int airoha_mdio_write(struct mii_bus *bus, int addr, int regnum,
			     u16 value)
{
	struct airoha_mdio_data *priv = bus->priv;
	u32 val;
	int ret;

	val = AN7583_MII_BUSY | AN7583_MII_ST_CL22 |
	      AN7583_MII_CMD_CL22_WRITE;
	val |= FIELD_PREP(AN7583_MII_PHY_ADDR, addr);
	val |= FIELD_PREP(AN7583_MII_CL22_REG_ADDR, regnum);
	val |= FIELD_PREP(AN7583_MII_RWDATA, value);

	ret = regmap_write(priv->regmap, priv->base_addr, val);
	if (ret)
		return ret;

	ret = airoha_mdio_wait_busy(priv);

	return ret;
}

static int airoha_mdio_cl45_read(struct mii_bus *bus, int addr, int devnum,
				 int regnum)
{
	struct airoha_mdio_data *priv = bus->priv;
	u32 val;
	int ret;

	airoha_mdio_reset(priv);

	val = AN7583_MII_BUSY | AN7583_MII_ST_CL45 |
	      AN7583_MII_CMD_CL45_ADDR;
	val |= FIELD_PREP(AN7583_MII_PHY_ADDR, addr);
	val |= FIELD_PREP(AN7583_MII_CL45_DEV_ADDR, devnum);
	val |= FIELD_PREP(AN7583_MII_CL45_REG_ADDR, regnum);

	ret = regmap_write(priv->regmap, priv->base_addr, val);
	if (ret)
		return ret;

	ret = airoha_mdio_wait_busy(priv);
	if (ret)
		return ret;

	val = AN7583_MII_BUSY | AN7583_MII_ST_CL45 |
	      AN7583_MII_CMD_CL45_READ;
	val |= FIELD_PREP(AN7583_MII_PHY_ADDR, addr);
	val |= FIELD_PREP(AN7583_MII_CL45_DEV_ADDR, devnum);

	ret = regmap_write(priv->regmap, priv->base_addr, val);
	if (ret)
		return ret;

	ret = airoha_mdio_wait_busy(priv);
	if (ret)
		return ret;

	ret = regmap_read(priv->regmap, priv->base_addr, &val);
	if (ret)
		return ret;

	return FIELD_GET(AN7583_MII_RWDATA, val);
}

static int airoha_mdio_cl45_write(struct mii_bus *bus, int addr, int devnum,
				  int regnum, u16 value)
{
	struct airoha_mdio_data *priv = bus->priv;
	u32 val;
	int ret;

	val = AN7583_MII_BUSY | AN7583_MII_ST_CL45 |
	      AN7583_MII_CMD_CL45_ADDR;
	val |= FIELD_PREP(AN7583_MII_PHY_ADDR, addr);
	val |= FIELD_PREP(AN7583_MII_CL45_DEV_ADDR, devnum);
	val |= FIELD_PREP(AN7583_MII_CL45_REG_ADDR, regnum);

	ret = regmap_write(priv->regmap, priv->base_addr, val);
	if (ret)
		return ret;

	ret = airoha_mdio_wait_busy(priv);
	if (ret)
		return ret;

	val = AN7583_MII_BUSY | AN7583_MII_ST_CL45 |
	      AN7583_MII_CMD_CL45_WRITE;
	val |= FIELD_PREP(AN7583_MII_PHY_ADDR, addr);
	val |= FIELD_PREP(AN7583_MII_CL45_DEV_ADDR, devnum);
	val |= FIELD_PREP(AN7583_MII_RWDATA, value);

	ret = regmap_write(priv->regmap, priv->base_addr, val);
	if (ret)
		return ret;

	ret = airoha_mdio_wait_busy(priv);

	return ret;
}

static int airoha_mdio_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct airoha_mdio_data *priv;
	struct mii_bus *bus;
	u32 addr, freq;
	int ret;

	ret = of_property_read_u32(dev->of_node, "reg", &addr);
	if (ret)
		return ret;

	bus = devm_mdiobus_alloc_size(dev, sizeof(*priv));
	if (!bus)
		return -ENOMEM;

	priv = bus->priv;
	priv->base_addr = addr;
	priv->regmap = device_node_to_regmap(dev->parent->of_node);
	if (IS_ERR(priv->regmap))
		return PTR_ERR(priv->regmap);

	priv->clk = devm_clk_get_enabled(dev, NULL);
	if (IS_ERR(priv->clk))
		return PTR_ERR(priv->clk);

	priv->reset = devm_reset_control_get_exclusive(dev, NULL);
	if (IS_ERR(priv->reset))
		return PTR_ERR(priv->reset);

	reset_control_deassert(priv->reset);

	bus->name = "airoha_mdio_bus";
	snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(dev));
	bus->parent = dev;
	bus->read = airoha_mdio_read;
	bus->write = airoha_mdio_write;
	bus->read_c45 = airoha_mdio_cl45_read;
	bus->write_c45 = airoha_mdio_cl45_write;

	/* Check if a custom frequency is defined in DT or default to 2.5 MHz */
	if (of_property_read_u32(dev->of_node, "clock-frequency", &freq))
		freq = 2500000;

	ret = clk_set_rate(priv->clk, freq);
	if (ret)
		return ret;

	ret = devm_of_mdiobus_register(dev, bus, dev->of_node);
	if (ret) {
		reset_control_assert(priv->reset);
		return ret;
	}

	return 0;
}

static const struct of_device_id airoha_mdio_dt_ids[] = {
	{ .compatible = "airoha,an7583-mdio" },
	{ }
};
MODULE_DEVICE_TABLE(of, airoha_mdio_dt_ids);

static struct platform_driver airoha_mdio_driver = {
	.probe = airoha_mdio_probe,
	.driver = {
		.name = "airoha-mdio",
		.of_match_table = airoha_mdio_dt_ids,
	},
};

module_platform_driver(airoha_mdio_driver);

MODULE_DESCRIPTION("Airoha AN7583 MDIO interface driver");
MODULE_AUTHOR("Christian Marangi <ansuelsmth@gmail.com>");
MODULE_LICENSE("GPL");