Commit ec403d88 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'add-TJA1102-support' 



Oleksij Rempel says:

====================
add TJA1102 support

changes v5:
- rename __of_mdiobus_register_phy() to of_mdiobus_phy_device_register()

changes v4:
- remove unused phy_id variable

changes v3:
- export part of of_mdiobus_register_phy() and reuse it in tja11xx
  driver
- coding style fixes

changes v2:
- use .match_phy_device
- add irq support
- add add delayed registration for PHY1
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents d0f0c55e 6a64d3cd

Documentation/devicetree/bindings/net/nxp,tja11xx.yaml

0 → 100644
+61 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0+

%YAML 1.2

---

$id: http://devicetree.org/schemas/net/nxp,tja11xx.yaml#

$schema: http://devicetree.org/meta-schemas/core.yaml#



title: NXP TJA11xx PHY



maintainers:

  - Andrew Lunn <andrew@lunn.ch>

  - Florian Fainelli <f.fainelli@gmail.com>

  - Heiner Kallweit <hkallweit1@gmail.com>



description:

  Bindings for NXP TJA11xx automotive PHYs



allOf:

  - $ref: ethernet-phy.yaml#



patternProperties:

  "^ethernet-phy@[0-9a-f]+$":

    type: object

    description: |

      Some packages have multiple PHYs. Secondary PHY should be defines as

      subnode of the first (parent) PHY.



    properties:

      reg:

        minimum: 0

        maximum: 31

        description:

          The ID number for the child PHY. Should be +1 of parent PHY.



    required:

      - reg



examples:

  - |

    mdio {

        #address-cells = <1>;

        #size-cells = <0>;



        tja1101_phy0: ethernet-phy@4 {

            reg = <0x4>;

        };

    };

  - |

    mdio {

        #address-cells = <1>;

        #size-cells = <0>;



        tja1102_phy0: ethernet-phy@4 {

            reg = <0x4>;

            #address-cells = <1>;

            #size-cells = <0>;



            tja1102_phy1: ethernet-phy@5 {

                reg = <0x5>;

            };

        };

    };

drivers/net/phy/nxp-tja11xx.c

+195 −6
Original line number Diff line number Diff line
@@ -6,15 +6,19 @@ 
#include <linux/delay.h>

#include <linux/ethtool.h>

#include <linux/kernel.h>

#include <linux/mdio.h>

#include <linux/mii.h>

#include <linux/module.h>

#include <linux/phy.h>

#include <linux/hwmon.h>

#include <linux/bitfield.h>

#include <linux/of_mdio.h>

#include <linux/of_irq.h>



#define PHY_ID_MASK			0xfffffff0

#define PHY_ID_TJA1100			0x0180dc40

#define PHY_ID_TJA1101			0x0180dd00

#define PHY_ID_TJA1102			0x0180dc80



#define MII_ECTRL			17

#define MII_ECTRL_LINK_CONTROL		BIT(15)
@@ -40,6 +44,10 @@ 
#define MII_INTSRC_TEMP_ERR		BIT(1)

#define MII_INTSRC_UV_ERR		BIT(3)



#define MII_INTEN			22

#define MII_INTEN_LINK_FAIL		BIT(10)

#define MII_INTEN_LINK_UP		BIT(9)



#define MII_COMMSTAT			23

#define MII_COMMSTAT_LINK_UP		BIT(15)
@@ -52,6 +60,8 @@ 
struct tja11xx_priv {

	char		*hwmon_name;

	struct device	*hwmon_dev;

	struct phy_device *phydev;

	struct work_struct phy_register_work;

};



struct tja11xx_phy_stats {
@@ -180,6 +190,7 @@ static int tja11xx_config_init(struct phy_device *phydev) 
			return ret;

		break;

	case PHY_ID_TJA1101:

	case PHY_ID_TJA1102:

		ret = phy_set_bits(phydev, MII_COMMCFG, MII_COMMCFG_AUTO_OP);

		if (ret)

			return ret;
@@ -317,16 +328,12 @@ static const struct hwmon_chip_info tja11xx_hwmon_chip_info = { 
	.info		= tja11xx_hwmon_info,

};



static int tja11xx_probe(struct phy_device *phydev)

static int tja11xx_hwmon_register(struct phy_device *phydev,

				  struct tja11xx_priv *priv)

{

	struct device *dev = &phydev->mdio.dev;

	struct tja11xx_priv *priv;

	int i;



	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;



	priv->hwmon_name = devm_kstrdup(dev, dev_name(dev), GFP_KERNEL);

	if (!priv->hwmon_name)

		return -ENOMEM;
@@ -344,6 +351,152 @@ static int tja11xx_probe(struct phy_device *phydev) 
	return PTR_ERR_OR_ZERO(priv->hwmon_dev);

}



static int tja11xx_probe(struct phy_device *phydev)

{

	struct device *dev = &phydev->mdio.dev;

	struct tja11xx_priv *priv;



	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;



	priv->phydev = phydev;



	return tja11xx_hwmon_register(phydev, priv);

}



static void tja1102_p1_register(struct work_struct *work)

{

	struct tja11xx_priv *priv = container_of(work, struct tja11xx_priv,

						 phy_register_work);

	struct phy_device *phydev_phy0 = priv->phydev;

	struct mii_bus *bus = phydev_phy0->mdio.bus;

	struct device *dev = &phydev_phy0->mdio.dev;

	struct device_node *np = dev->of_node;

	struct device_node *child;

	int ret;



	for_each_available_child_of_node(np, child) {

		struct phy_device *phy;

		int addr;



		addr = of_mdio_parse_addr(dev, child);

		if (addr < 0) {

			dev_err(dev, "Can't parse addr\n");

			continue;

		} else if (addr != phydev_phy0->mdio.addr + 1) {

			/* Currently we care only about double PHY chip TJA1102.

			 * If some day NXP will decide to bring chips with more

			 * PHYs, this logic should be reworked.

			 */

			dev_err(dev, "Unexpected address. Should be: %i\n",

				phydev_phy0->mdio.addr + 1);

			continue;

		}



		if (mdiobus_is_registered_device(bus, addr)) {

			dev_err(dev, "device is already registered\n");

			continue;

		}



		/* Real PHY ID of Port 1 is 0 */

		phy = phy_device_create(bus, addr, PHY_ID_TJA1102, false, NULL);

		if (IS_ERR(phy)) {

			dev_err(dev, "Can't create PHY device for Port 1: %i\n",

				addr);

			continue;

		}



		/* Overwrite parent device. phy_device_create() set parent to

		 * the mii_bus->dev, which is not correct in case.

		 */

		phy->mdio.dev.parent = dev;



		ret = of_mdiobus_phy_device_register(bus, phy, child, addr);

		if (ret) {

			/* All resources needed for Port 1 should be already

			 * available for Port 0. Both ports use the same

			 * interrupt line, so -EPROBE_DEFER would make no sense

			 * here.

			 */

			dev_err(dev, "Can't register Port 1. Unexpected error: %i\n",

				ret);

			phy_device_free(phy);

		}

	}

}



static int tja1102_p0_probe(struct phy_device *phydev)

{

	struct device *dev = &phydev->mdio.dev;

	struct tja11xx_priv *priv;

	int ret;



	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;



	priv->phydev = phydev;

	INIT_WORK(&priv->phy_register_work, tja1102_p1_register);



	ret = tja11xx_hwmon_register(phydev, priv);

	if (ret)

		return ret;



	schedule_work(&priv->phy_register_work);



	return 0;

}



static int tja1102_match_phy_device(struct phy_device *phydev, bool port0)

{

	int ret;



	if ((phydev->phy_id & PHY_ID_MASK) != PHY_ID_TJA1102)

		return 0;



	ret = phy_read(phydev, MII_PHYSID2);

	if (ret < 0)

		return ret;



	/* TJA1102 Port 1 has phyid 0 and doesn't support temperature

	 * and undervoltage alarms.

	 */

	if (port0)

		return ret ? 1 : 0;



	return !ret;

}



static int tja1102_p0_match_phy_device(struct phy_device *phydev)

{

	return tja1102_match_phy_device(phydev, true);

}



static int tja1102_p1_match_phy_device(struct phy_device *phydev)

{

	return tja1102_match_phy_device(phydev, false);

}



static int tja11xx_ack_interrupt(struct phy_device *phydev)

{

	int ret;



	ret = phy_read(phydev, MII_INTSRC);



	return (ret < 0) ? ret : 0;

}



static int tja11xx_config_intr(struct phy_device *phydev)

{

	int value = 0;



	if (phydev->interrupts == PHY_INTERRUPT_ENABLED)

		value = MII_INTEN_LINK_FAIL | MII_INTEN_LINK_UP;



	return phy_write(phydev, MII_INTEN, value);

}



static struct phy_driver tja11xx_driver[] = {

	{

		PHY_ID_MATCH_MODEL(PHY_ID_TJA1100),
@@ -375,6 +528,41 @@ static struct phy_driver tja11xx_driver[] = { 
		.get_sset_count = tja11xx_get_sset_count,

		.get_strings	= tja11xx_get_strings,

		.get_stats	= tja11xx_get_stats,

	}, {

		.name		= "NXP TJA1102 Port 0",

		.features       = PHY_BASIC_T1_FEATURES,

		.probe		= tja1102_p0_probe,

		.soft_reset	= tja11xx_soft_reset,

		.config_init	= tja11xx_config_init,

		.read_status	= tja11xx_read_status,

		.match_phy_device = tja1102_p0_match_phy_device,

		.suspend	= genphy_suspend,

		.resume		= genphy_resume,

		.set_loopback   = genphy_loopback,

		/* Statistics */

		.get_sset_count = tja11xx_get_sset_count,

		.get_strings	= tja11xx_get_strings,

		.get_stats	= tja11xx_get_stats,

		.ack_interrupt	= tja11xx_ack_interrupt,

		.config_intr	= tja11xx_config_intr,



	}, {

		.name		= "NXP TJA1102 Port 1",

		.features       = PHY_BASIC_T1_FEATURES,

		/* currently no probe for Port 1 is need */

		.soft_reset	= tja11xx_soft_reset,

		.config_init	= tja11xx_config_init,

		.read_status	= tja11xx_read_status,

		.match_phy_device = tja1102_p1_match_phy_device,

		.suspend	= genphy_suspend,

		.resume		= genphy_resume,

		.set_loopback   = genphy_loopback,

		/* Statistics */

		.get_sset_count = tja11xx_get_sset_count,

		.get_strings	= tja11xx_get_strings,

		.get_stats	= tja11xx_get_stats,

		.ack_interrupt	= tja11xx_ack_interrupt,

		.config_intr	= tja11xx_config_intr,

	}

};
@@ -383,6 +571,7 @@ module_phy_driver(tja11xx_driver); 
static struct mdio_device_id __maybe_unused tja11xx_tbl[] = {

	{ PHY_ID_MATCH_MODEL(PHY_ID_TJA1100) },

	{ PHY_ID_MATCH_MODEL(PHY_ID_TJA1101) },

	{ PHY_ID_MATCH_MODEL(PHY_ID_TJA1102) },

	{ }

};

drivers/of/of_mdio.c

+42 −31
Original line number Diff line number Diff line
@@ -60,39 +60,15 @@ static struct mii_timestamper *of_find_mii_timestamper(struct device_node *node) 
	return register_mii_timestamper(arg.np, arg.args[0]);

}



static int of_mdiobus_register_phy(struct mii_bus *mdio,

int of_mdiobus_phy_device_register(struct mii_bus *mdio, struct phy_device *phy,

			      struct device_node *child, u32 addr)

{

	struct mii_timestamper *mii_ts;

	struct phy_device *phy;

	bool is_c45;

	int rc;

	u32 phy_id;



	mii_ts = of_find_mii_timestamper(child);

	if (IS_ERR(mii_ts))

		return PTR_ERR(mii_ts);



	is_c45 = of_device_is_compatible(child,

					 "ethernet-phy-ieee802.3-c45");



	if (!is_c45 && !of_get_phy_id(child, &phy_id))

		phy = phy_device_create(mdio, addr, phy_id, 0, NULL);

	else

		phy = get_phy_device(mdio, addr, is_c45);

	if (IS_ERR(phy)) {

		if (mii_ts)

			unregister_mii_timestamper(mii_ts);

		return PTR_ERR(phy);

	}



	rc = of_irq_get(child, 0);

	if (rc == -EPROBE_DEFER) {

		if (mii_ts)

			unregister_mii_timestamper(mii_ts);

		phy_device_free(phy);

	if (rc == -EPROBE_DEFER)

		return rc;

	}



	if (rc > 0) {

		phy->irq = rc;

		mdio->irq[addr] = rc;
@@ -117,11 +93,48 @@ static int of_mdiobus_register_phy(struct mii_bus *mdio, 
	/* All data is now stored in the phy struct;

	 * register it */

	rc = phy_device_register(phy);

	if (rc) {

		of_node_put(child);

		return rc;

	}



	dev_dbg(&mdio->dev, "registered phy %pOFn at address %i\n",

		child, addr);

	return 0;

}

EXPORT_SYMBOL(of_mdiobus_phy_device_register);



static int of_mdiobus_register_phy(struct mii_bus *mdio,

				    struct device_node *child, u32 addr)

{

	struct mii_timestamper *mii_ts;

	struct phy_device *phy;

	bool is_c45;

	int rc;

	u32 phy_id;



	mii_ts = of_find_mii_timestamper(child);

	if (IS_ERR(mii_ts))

		return PTR_ERR(mii_ts);



	is_c45 = of_device_is_compatible(child,

					 "ethernet-phy-ieee802.3-c45");



	if (!is_c45 && !of_get_phy_id(child, &phy_id))

		phy = phy_device_create(mdio, addr, phy_id, 0, NULL);

	else

		phy = get_phy_device(mdio, addr, is_c45);

	if (IS_ERR(phy)) {

		if (mii_ts)

			unregister_mii_timestamper(mii_ts);

		return PTR_ERR(phy);

	}



	rc = of_mdiobus_phy_device_register(mdio, phy, child, addr);

	if (rc) {

		if (mii_ts)

			unregister_mii_timestamper(mii_ts);

		phy_device_free(phy);

		of_node_put(child);

		return rc;

	}
@@ -132,8 +145,6 @@ static int of_mdiobus_register_phy(struct mii_bus *mdio, 
	if (mii_ts)

		phy->mii_ts = mii_ts;



	dev_dbg(&mdio->dev, "registered phy %pOFn at address %i\n",

		child, addr);

	return 0;

}

include/linux/of_mdio.h

+10 −1
Original line number Diff line number Diff line
@@ -30,7 +30,9 @@ extern struct mii_bus *of_mdio_find_bus(struct device_node *mdio_np); 
extern int of_phy_register_fixed_link(struct device_node *np);

extern void of_phy_deregister_fixed_link(struct device_node *np);

extern bool of_phy_is_fixed_link(struct device_node *np);



extern int of_mdiobus_phy_device_register(struct mii_bus *mdio,

				     struct phy_device *phy,

				     struct device_node *child, u32 addr);



static inline int of_mdio_parse_addr(struct device *dev,

				     const struct device_node *np)
@@ -118,6 +120,13 @@ static inline bool of_phy_is_fixed_link(struct device_node *np) 
{

	return false;

}



static inline int of_mdiobus_phy_device_register(struct mii_bus *mdio,

					    struct phy_device *phy,

					    struct device_node *child, u32 addr)

{

	return -ENOSYS;

}

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE