[linux-2.6-block.git] / drivers / net / ethernet / arc / emac_mdio.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2004-2013 Synopsys, Inc. (www.synopsys.com)
 *
 * MDIO implementation for ARC EMAC
 */

#include <linux/delay.h>
#include <linux/of_mdio.h>
#include <linux/platform_device.h>
#include <linux/gpio/consumer.h>

#include "emac.h"

/* Number of seconds we wait for "MDIO complete" flag to appear */
#define ARC_MDIO_COMPLETE_POLL_COUNT	1

/**
 * arc_mdio_complete_wait - Waits until MDIO transaction is completed.
 * @priv:	Pointer to ARC EMAC private data structure.
 *
 * returns:	0 on success, -ETIMEDOUT on a timeout.
 */
static int arc_mdio_complete_wait(struct arc_emac_priv *priv)
{
	unsigned int i;

	for (i = 0; i < ARC_MDIO_COMPLETE_POLL_COUNT * 40; i++) {
		unsigned int status = arc_reg_get(priv, R_STATUS);

		status &= MDIO_MASK;

		if (status) {
			/* Reset "MDIO complete" flag */
			arc_reg_set(priv, R_STATUS, status);
			return 0;
		}

		msleep(25);
	}

	return -ETIMEDOUT;
}

/**
 * arc_mdio_read - MDIO interface read function.
 * @bus:	Pointer to MII bus structure.
 * @phy_addr:	Address of the PHY device.
 * @reg_num:	PHY register to read.
 *
 * returns:	The register contents on success, -ETIMEDOUT on a timeout.
 *
 * Reads the contents of the requested register from the requested PHY
 * address.
 */
static int arc_mdio_read(struct mii_bus *bus, int phy_addr, int reg_num)
{
	struct arc_emac_priv *priv = bus->priv;
	unsigned int value;
	int error;

	arc_reg_set(priv, R_MDIO,
		    0x60020000 | (phy_addr << 23) | (reg_num << 18));

	error = arc_mdio_complete_wait(priv);
	if (error < 0)
		return error;

	value = arc_reg_get(priv, R_MDIO) & 0xffff;

	dev_dbg(priv->dev, "arc_mdio_read(phy_addr=%i, reg_num=%x) = %x\n",
		phy_addr, reg_num, value);

	return value;
}

/**
 * arc_mdio_write - MDIO interface write function.
 * @bus:	Pointer to MII bus structure.
 * @phy_addr:	Address of the PHY device.
 * @reg_num:	PHY register to write to.
 * @value:	Value to be written into the register.
 *
 * returns:	0 on success, -ETIMEDOUT on a timeout.
 *
 * Writes the value to the requested register.
 */
static int arc_mdio_write(struct mii_bus *bus, int phy_addr,
			  int reg_num, u16 value)
{
	struct arc_emac_priv *priv = bus->priv;

	dev_dbg(priv->dev,
		"arc_mdio_write(phy_addr=%i, reg_num=%x, value=%x)\n",
		phy_addr, reg_num, value);

	arc_reg_set(priv, R_MDIO,
		    0x50020000 | (phy_addr << 23) | (reg_num << 18) | value);

	return arc_mdio_complete_wait(priv);
}

/**
 * arc_mdio_reset
 * @bus: points to the mii_bus structure
 * Description: reset the MII bus
 */
static int arc_mdio_reset(struct mii_bus *bus)
{
	struct arc_emac_priv *priv = bus->priv;
	struct arc_emac_mdio_bus_data *data = &priv->bus_data;

	if (data->reset_gpio) {
		gpiod_set_value_cansleep(data->reset_gpio, 1);
		msleep(data->msec);
		gpiod_set_value_cansleep(data->reset_gpio, 0);
	}

	return 0;
}

/**
 * arc_mdio_probe - MDIO probe function.
 * @priv:	Pointer to ARC EMAC private data structure.
 *
 * returns:	0 on success, -ENOMEM when mdiobus_alloc
 * (to allocate memory for MII bus structure) fails.
 *
 * Sets up and registers the MDIO interface.
 */
int arc_mdio_probe(struct arc_emac_priv *priv)
{
	struct arc_emac_mdio_bus_data *data = &priv->bus_data;
	struct device_node *np = priv->dev->of_node;
	const char *name = "Synopsys MII Bus";
	struct mii_bus *bus;
	int error;

	bus = mdiobus_alloc();
	if (!bus)
		return -ENOMEM;

	priv->bus = bus;
	bus->priv = priv;
	bus->parent = priv->dev;
	bus->name = name;
	bus->read = &arc_mdio_read;
	bus->write = &arc_mdio_write;
	bus->reset = &arc_mdio_reset;

	/* optional reset-related properties */
	data->reset_gpio = devm_gpiod_get_optional(priv->dev, "phy-reset",
						   GPIOD_OUT_LOW);
	if (IS_ERR(data->reset_gpio)) {
		mdiobus_free(bus);
		return dev_err_probe(priv->dev, PTR_ERR(data->reset_gpio),
				     "Failed to request gpio\n");
	}

	of_property_read_u32(np, "phy-reset-duration", &data->msec);
	/* A sane reset duration should not be longer than 1s */
	if (data->msec > 1000)
		data->msec = 1;

	snprintf(bus->id, MII_BUS_ID_SIZE, "%s", bus->name);

	error = of_mdiobus_register(bus, priv->dev->of_node);
	if (error) {
		mdiobus_free(bus);
		return dev_err_probe(priv->dev, error,
				     "cannot register MDIO bus %s\n", name);
	}

	return 0;
}

/**
 * arc_mdio_remove - MDIO remove function.
 * @priv:	Pointer to ARC EMAC private data structure.
 *
 * Unregisters the MDIO and frees any associate memory for MII bus.
 */
int arc_mdio_remove(struct arc_emac_priv *priv)
{
	mdiobus_unregister(priv->bus);
	mdiobus_free(priv->bus);
	priv->bus = NULL;

	return 0;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
e4f2379d AB	2	/*
	3	* Copyright (C) 2004-2013 Synopsys, Inc. (www.synopsys.com)
	4	*
	5	* MDIO implementation for ARC EMAC
	6	*/
	7
	8	#include <linux/delay.h>
	9	#include <linux/of_mdio.h>
	10	#include <linux/platform_device.h>
1bddd96c	11	#include <linux/gpio/consumer.h>
e4f2379d AB	12
	13	#include "emac.h"
	14
	15	/* Number of seconds we wait for "MDIO complete" flag to appear */
	16	#define ARC_MDIO_COMPLETE_POLL_COUNT 1
	17
	18	/**
	19	* arc_mdio_complete_wait - Waits until MDIO transaction is completed.
	20	* @priv: Pointer to ARC EMAC private data structure.
	21	*
	22	* returns: 0 on success, -ETIMEDOUT on a timeout.
	23	*/
	24	static int arc_mdio_complete_wait(struct arc_emac_priv *priv)
	25	{
	26	unsigned int i;
	27
	28	for (i = 0; i < ARC_MDIO_COMPLETE_POLL_COUNT * 40; i++) {
	29	unsigned int status = arc_reg_get(priv, R_STATUS);
	30
	31	status &= MDIO_MASK;
	32
	33	if (status) {
	34	/* Reset "MDIO complete" flag */
	35	arc_reg_set(priv, R_STATUS, status);
	36	return 0;
	37	}
	38
	39	msleep(25);
	40	}
	41
	42	return -ETIMEDOUT;
	43	}
	44
	45	/**
	46	* arc_mdio_read - MDIO interface read function.
	47	* @bus: Pointer to MII bus structure.
	48	* @phy_addr: Address of the PHY device.
	49	* @reg_num: PHY register to read.
	50	*
	51	* returns: The register contents on success, -ETIMEDOUT on a timeout.
	52	*
	53	* Reads the contents of the requested register from the requested PHY
	54	* address.
	55	*/
	56	static int arc_mdio_read(struct mii_bus *bus, int phy_addr, int reg_num)
	57	{
	58	struct arc_emac_priv *priv = bus->priv;
	59	unsigned int value;
	60	int error;
	61
	62	arc_reg_set(priv, R_MDIO,
	63	0x60020000 \| (phy_addr << 23) \| (reg_num << 18));
	64
	65	error = arc_mdio_complete_wait(priv);
	66	if (error < 0)
	67	return error;
	68
	69	value = arc_reg_get(priv, R_MDIO) & 0xffff;
	70
	71	dev_dbg(priv->dev, "arc_mdio_read(phy_addr=%i, reg_num=%x) = %x\n",
	72	phy_addr, reg_num, value);
	73
	74	return value;
	75	}
76
77	/**
78	* arc_mdio_write - MDIO interface write function.
79	* @bus: Pointer to MII bus structure.
80	* @phy_addr: Address of the PHY device.
81	* @reg_num: PHY register to write to.
82	* @value: Value to be written into the register.
83	*
84	* returns: 0 on success, -ETIMEDOUT on a timeout.
85	*
86	* Writes the value to the requested register.
87	*/
88	static int arc_mdio_write(struct mii_bus *bus, int phy_addr,
89	int reg_num, u16 value)
90	{
91	struct arc_emac_priv *priv = bus->priv;
92
93	dev_dbg(priv->dev,
94	"arc_mdio_write(phy_addr=%i, reg_num=%x, value=%x)\n",
95	phy_addr, reg_num, value);
96
97	arc_reg_set(priv, R_MDIO,
663713eb	98	0x50020000 \| (phy_addr << 23) \| (reg_num << 18) \| value);
e4f2379d AB	99
	100	return arc_mdio_complete_wait(priv);
	101	}
	102
1bddd96c CW	103	/**
	104	* arc_mdio_reset
	105	* @bus: points to the mii_bus structure
	106	* Description: reset the MII bus
	107	*/
3f591997	108	static int arc_mdio_reset(struct mii_bus *bus)
1bddd96c CW	109	{
	110	struct arc_emac_priv *priv = bus->priv;
	111	struct arc_emac_mdio_bus_data *data = &priv->bus_data;
	112
	113	if (data->reset_gpio) {
	114	gpiod_set_value_cansleep(data->reset_gpio, 1);
	115	msleep(data->msec);
	116	gpiod_set_value_cansleep(data->reset_gpio, 0);
	117	}
	118
	119	return 0;
	120	}
	121
e4f2379d AB	122	/**
e4f2379d AB	123	* arc_mdio_probe - MDIO probe function.
e4f2379d AB	124	* @priv: Pointer to ARC EMAC private data structure.
	125	*
	126	* returns: 0 on success, -ENOMEM when mdiobus_alloc
	127	* (to allocate memory for MII bus structure) fails.
	128	*
	129	* Sets up and registers the MDIO interface.
	130	*/
93e91b3d	131	int arc_mdio_probe(struct arc_emac_priv *priv)
e4f2379d	132	{
1bddd96c CW	133	struct arc_emac_mdio_bus_data *data = &priv->bus_data;
1bddd96c CW	134	struct device_node *np = priv->dev->of_node;
bc0e610a	135	const char *name = "Synopsys MII Bus";
e4f2379d AB	136	struct mii_bus *bus;
	137	int error;
	138
	139	bus = mdiobus_alloc();
	140	if (!bus)
	141	return -ENOMEM;
	142
	143	priv->bus = bus;
	144	bus->priv = priv;
	145	bus->parent = priv->dev;
bc0e610a	146	bus->name = name;
e4f2379d AB	147	bus->read = &arc_mdio_read;
e4f2379d AB	148	bus->write = &arc_mdio_write;
1bddd96c CW	149	bus->reset = &arc_mdio_reset;
	150
	151	/* optional reset-related properties */
	152	data->reset_gpio = devm_gpiod_get_optional(priv->dev, "phy-reset",
	153	GPIOD_OUT_LOW);
	154	if (IS_ERR(data->reset_gpio)) {
e2d79cd8	155	mdiobus_free(bus);
95b5fc03 CH	156	return dev_err_probe(priv->dev, PTR_ERR(data->reset_gpio),
95b5fc03 CH	157	"Failed to request gpio\n");
1bddd96c CW	158	}
	159
	160	of_property_read_u32(np, "phy-reset-duration", &data->msec);
	161	/* A sane reset duration should not be longer than 1s */
	162	if (data->msec > 1000)
	163	data->msec = 1;
e4f2379d	164
93e91b3d	165	snprintf(bus->id, MII_BUS_ID_SIZE, "%s", bus->name);
e4f2379d	166
93e91b3d	167	error = of_mdiobus_register(bus, priv->dev->of_node);
e4f2379d	168	if (error) {
e4f2379d	169	mdiobus_free(bus);
95b5fc03	170	return dev_err_probe(priv->dev, error,
bc0e610a	171	"cannot register MDIO bus %s\n", name);
e4f2379d AB	172	}
	173
	174	return 0;
	175	}
	176
	177	/**
	178	* arc_mdio_remove - MDIO remove function.
	179	* @priv: Pointer to ARC EMAC private data structure.
	180	*
	181	* Unregisters the MDIO and frees any associate memory for MII bus.
	182	*/
	183	int arc_mdio_remove(struct arc_emac_priv *priv)
	184	{
	185	mdiobus_unregister(priv->bus);
	186	mdiobus_free(priv->bus);
	187	priv->bus = NULL;
	188
	189	return 0;
	190	}