Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2ec98521 authored by Florian Fainelli's avatar Florian Fainelli Committed by David S. Miller
Browse files

net: mvmdio: enhance driver to support SMI error/done interrupts 



This patch enhances the "mvmdio" to support a SMI error/done interrupt
line which can be used along with a wait queue instead of doing
busy-waiting on the registers. This is a feature which is available in
the mv643xx_eth SMI code and thus reduces again the gap between the two.

Signed-off-by: default avatarFlorian Fainelli <florian@openwrt.org>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 3712b717

Documentation/devicetree/bindings/net/marvell-orion-mdio.txt

+3 −0
Original line number Original line Diff line number Diff line
@@ -9,6 +9,9 @@ Required properties: 
- compatible: "marvell,orion-mdio"

- compatible: "marvell,orion-mdio"

- reg: address and length of the SMI register

- reg: address and length of the SMI register





Optional properties:

- interrupts: interrupt line number for the SMI error/done interrupt



The child nodes of the MDIO driver are the individual PHY devices

The child nodes of the MDIO driver are the individual PHY devices

connected to this MDIO bus. They must have a "reg" property given the

connected to this MDIO bus. They must have a "reg" property given the

PHY address on the MDIO bus.

PHY address on the MDIO bus.

drivers/net/ethernet/marvell/mvmdio.c

+80 −18
Original line number Original line Diff line number Diff line
@@ -24,10 +24,13 @@ 
#include <linux/module.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/mutex.h>

#include <linux/phy.h>

#include <linux/phy.h>

#include <linux/interrupt.h>

#include <linux/platform_device.h>

#include <linux/platform_device.h>

#include <linux/delay.h>

#include <linux/delay.h>

#include <linux/io.h>

#include <linux/io.h>

#include <linux/of_mdio.h>

#include <linux/of_mdio.h>

#include <linux/sched.h>

#include <linux/wait.h>





#define MVMDIO_SMI_DATA_SHIFT              0

#define MVMDIO_SMI_DATA_SHIFT              0

#define MVMDIO_SMI_PHY_ADDR_SHIFT          16

#define MVMDIO_SMI_PHY_ADDR_SHIFT          16
@@ -36,34 +39,59 @@ 
#define MVMDIO_SMI_WRITE_OPERATION         0

#define MVMDIO_SMI_WRITE_OPERATION         0

#define MVMDIO_SMI_READ_VALID              BIT(27)

#define MVMDIO_SMI_READ_VALID              BIT(27)

#define MVMDIO_SMI_BUSY                    BIT(28)

#define MVMDIO_SMI_BUSY                    BIT(28)

#define MVMDIO_ERR_INT_CAUSE		   0x007C

#define  MVMDIO_ERR_INT_SMI_DONE	   0x00000010

#define MVMDIO_ERR_INT_MASK		   0x0080





struct orion_mdio_dev {

struct orion_mdio_dev {

	struct mutex lock;

	struct mutex lock;

	void __iomem *regs;

	void __iomem *regs;

	/*

	 * If we have access to the error interrupt pin (which is

	 * somewhat misnamed as it not only reflects internal errors

	 * but also reflects SMI completion), use that to wait for

	 * SMI access completion instead of polling the SMI busy bit.

	 */

	int err_interrupt;

	wait_queue_head_t smi_busy_wait;

};

};





static int orion_mdio_smi_is_done(struct orion_mdio_dev *dev)

{

	return !(readl(dev->regs) & MVMDIO_SMI_BUSY);

}



/* Wait for the SMI unit to be ready for another operation

/* Wait for the SMI unit to be ready for another operation

 */

 */

static int orion_mdio_wait_ready(struct mii_bus *bus)

static int orion_mdio_wait_ready(struct mii_bus *bus)

{

{

	struct orion_mdio_dev *dev = bus->priv;

	struct orion_mdio_dev *dev = bus->priv;

	int count;

	int count;

	u32 val;





	if (dev->err_interrupt <= 0) {

		count = 0;

		count = 0;

		while (1) {

		while (1) {

		val = readl(dev->regs);

			if (orion_mdio_smi_is_done(dev))

		if (!(val & MVMDIO_SMI_BUSY))

				break;

				break;





			if (count > 100) {

			if (count > 100) {

			dev_err(bus->parent, "Timeout: SMI busy for too long\n");

				dev_err(bus->parent,

					"Timeout: SMI busy for too long\n");

				return -ETIMEDOUT;

				return -ETIMEDOUT;

			}

			}





			udelay(10);

			udelay(10);

			count++;

			count++;

		}

		}

	} else {

		if (!orion_mdio_smi_is_done(dev)) {

			wait_event_timeout(dev->smi_busy_wait,

				orion_mdio_smi_is_done(dev),

				msecs_to_jiffies(100));

			if (!orion_mdio_smi_is_done(dev))

				return -ETIMEDOUT;

		}

	}





	return 0;

	return 0;

}

}
@@ -141,6 +169,21 @@ static int orion_mdio_reset(struct mii_bus *bus) 
	return 0;

	return 0;

}

}





static irqreturn_t orion_mdio_err_irq(int irq, void *dev_id)

{

	struct orion_mdio_dev *dev = dev_id;



	if (readl(dev->regs + MVMDIO_ERR_INT_CAUSE) &

			MVMDIO_ERR_INT_SMI_DONE) {

		writel(~MVMDIO_ERR_INT_SMI_DONE,

				dev->regs + MVMDIO_ERR_INT_CAUSE);

		wake_up(&dev->smi_busy_wait);

		return IRQ_HANDLED;

	}



	return IRQ_NONE;

}



static int orion_mdio_probe(struct platform_device *pdev)

static int orion_mdio_probe(struct platform_device *pdev)

{

{

	struct resource *r;

	struct resource *r;
@@ -181,9 +224,22 @@ static int orion_mdio_probe(struct platform_device *pdev) 
	dev->regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));

	dev->regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));

	if (!dev->regs) {

	if (!dev->regs) {

		dev_err(&pdev->dev, "Unable to remap SMI register\n");

		dev_err(&pdev->dev, "Unable to remap SMI register\n");

		kfree(bus->irq);

		ret = -ENODEV;

		mdiobus_free(bus);

		goto out_mdio;

		return -ENODEV;

	}



	init_waitqueue_head(&dev->smi_busy_wait);



	dev->err_interrupt = platform_get_irq(pdev, 0);

	if (dev->err_interrupt != -ENXIO) {

		ret = devm_request_irq(&pdev->dev, dev->err_interrupt,

					orion_mdio_err_irq,

					IRQF_SHARED, pdev->name, dev);

		if (ret)

			goto out_mdio;



		writel(MVMDIO_ERR_INT_SMI_DONE,

			dev->regs + MVMDIO_ERR_INT_MASK);

	}

	}





	mutex_init(&dev->lock);

	mutex_init(&dev->lock);
@@ -194,19 +250,25 @@ static int orion_mdio_probe(struct platform_device *pdev) 
		ret = mdiobus_register(bus);

		ret = mdiobus_register(bus);

	if (ret < 0) {

	if (ret < 0) {

		dev_err(&pdev->dev, "Cannot register MDIO bus (%d)\n", ret);

		dev_err(&pdev->dev, "Cannot register MDIO bus (%d)\n", ret);

		kfree(bus->irq);

		goto out_mdio;

		mdiobus_free(bus);

		return ret;

	}

	}





	platform_set_drvdata(pdev, bus);

	platform_set_drvdata(pdev, bus);





	return 0;

	return 0;



out_mdio:

	kfree(bus->irq);

	mdiobus_free(bus);

	return ret;

}

}





static int orion_mdio_remove(struct platform_device *pdev)

static int orion_mdio_remove(struct platform_device *pdev)

{

{

	struct mii_bus *bus = platform_get_drvdata(pdev);

	struct mii_bus *bus = platform_get_drvdata(pdev);

	struct orion_mdio_dev *dev = bus->priv;



	writel(0, dev->regs + MVMDIO_ERR_INT_MASK);

	mdiobus_unregister(bus);

	mdiobus_unregister(bus);

	kfree(bus->irq);

	kfree(bus->irq);

	mdiobus_free(bus);

	mdiobus_free(bus);