This is an automated email from the ASF dual-hosted git repository.

xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git

commit 5f955a14a98f2d2f476441561ab12fb2db56b607
Author: zhangkai25 <[email protected]>
AuthorDate: Thu Jun 25 19:54:37 2026 +0800

    net/mdio: extend MDIO bus with Clause 45 access and reset level control
    
    Extend the upper-half MDIO bus driver to support the needs of PHYLIB:
    
    - Add mdio_c45_read()/mdio_c45_write() for Clause 45 MMD register access,
      using the lower-half native C45 ops when available and falling back to
      indirect access over Clause 22 registers 13/14 otherwise.
    - Change the reset op to a level control (assert/deassert by value).  A
      single MDIO bus may host several PHYs at different addresses, so any
      idempotency (skipping a redundant assert/deassert for a given phyaddr)
      is left to the lower-half driver, which owns the real pin state.
    
    This is a self-contained MDIO bus change; the PHYLIB framework that builds
    on it is added in a following commit.
    
    Signed-off-by: zhangkai25 <[email protected]>
---
 drivers/net/mdio.c       | 185 +++++++++++++++++++++++++++++++++++++++++++----
 include/nuttx/net/mdio.h |  78 ++++++++++++++++++--
 2 files changed, 240 insertions(+), 23 deletions(-)

diff --git a/drivers/net/mdio.c b/drivers/net/mdio.c
index 6111fa36e87..b7f1c507e7f 100644
--- a/drivers/net/mdio.c
+++ b/drivers/net/mdio.c
@@ -26,6 +26,7 @@
 #include <nuttx/kmalloc.h>
 #include <nuttx/mutex.h>
 #include <nuttx/net/mdio.h>
+#include <nuttx/net/mii.h>
 #include <nuttx/debug.h>
 
 /****************************************************************************
@@ -36,7 +37,7 @@
 
 #define MDIO_WRITE(d,a,r,v) d->lower->ops->write(d->lower, a, r, v);
 
-#define MDIO_RESET(d,a) d->lower->ops->reset(d->lower, a);
+#define MDIO_RESET(d,a,v) d->lower->ops->reset(d->lower, a, v);
 
 /****************************************************************************
  * Private Types
@@ -211,43 +212,195 @@ int mdio_write(FAR struct mdio_bus_s *dev, uint8_t 
phyaddr, uint8_t regaddr,
  * Name: mdio_reset
  *
  * Description:
- *   Reset a PHY on the MDIO bus.
+ *   Control the hardware reset line of a PHY on the MDIO bus.
  *
  * Input Parameters:
  *   dev     - The MDIO bus handle.
  *   phyaddr - The PHY address (0-31) to reset.
+ *   value   - Non-zero to assert reset, zero to deassert.
  *
  * Returned Value:
- *   Zero (OK) on success; a negated errno value on failure.
+ *   Zero (OK) on success; -ENOSYS if no reset op is provided; a negated
+ *   errno value on failure.
  *
  ****************************************************************************/
 
-int mdio_reset(FAR struct mdio_bus_s *dev, uint8_t phyaddr)
+int mdio_reset(FAR struct mdio_bus_s *dev, uint8_t phyaddr, int value)
 {
-  int ret = -ENOSYS;
+  int ret;
 
   DEBUGASSERT(dev != NULL && dev->lower != NULL);
 
-  /* Check if the reset method is provided by the lower-half */
+  /* No reset line wired / no lower-half op: nothing to do. */
+
+  if (dev->lower->ops->reset == NULL)
+    {
+      return -ENOSYS;
+    }
+
+  ret = nxmutex_lock(&dev->lock);
+  if (ret < 0)
+    {
+      return ret;
+    }
+
+  /* Call the lowerhalf driver's reset method (it performs the
+   * datasheet-mandated assert/deassert settle delay internally).  Any
+   * idempotency (skipping a redundant assert/deassert) is the lower
+   * half's responsibility, since only it knows the real pin state and a
+   * single MDIO bus may host several PHYs at different addresses.
+   */
+
+  ret = MDIO_RESET(dev, phyaddr, value);
+
+  nxmutex_unlock(&dev->lock);
+  return ret;
+}
+
+#ifdef CONFIG_MDIO_CLAUSE_45
+
+/****************************************************************************
+ * Name: mdio_c45_read
+ *
+ * Description:
+ *   Read a Clause 45 MMD register.  Uses the lower-half native C45 read
+ *   when available; otherwise performs indirect access over Clause 22
+ *   registers 13 (MMD control) and 14 (MMD address/data).
+ *
+ * Input Parameters:
+ *   dev     - The MDIO bus handle.
+ *   phyaddr - The PHY address (0-31).
+ *   devad   - The MMD device address.
+ *   regaddr - The 16-bit MMD register address.
+ *   value   - A pointer to the location to store the read value.
+ *
+ * Returned Value:
+ *   Zero (OK) on success; a negated errno value on failure.
+ *
+ ****************************************************************************/
+
+int mdio_c45_read(FAR struct mdio_bus_s *dev, uint8_t phyaddr,
+                  uint8_t devad, uint16_t regaddr, FAR uint16_t *value)
+{
+  int ret;
+
+  DEBUGASSERT(dev != NULL && dev->lower != NULL && value != NULL);
+
+  ret = nxmutex_lock(&dev->lock);
+  if (ret < 0)
+    {
+      return ret;
+    }
+
+  /* Native C45 path (single set of transactions in the lower half) */
+
+  if (dev->lower->ops->read_c45 != NULL)
+    {
+      ret = dev->lower->ops->read_c45(dev->lower, phyaddr, devad,
+                                      regaddr, value);
+      nxmutex_unlock(&dev->lock);
+      return ret;
+    }
+
+  /* Fallback: indirect access over Clause 22 (reg 13/14) */
+
+  ret = dev->lower->ops->write(dev->lower, phyaddr, MII_MMDCONTROL, devad);
+  if (ret < 0)
+    {
+      goto out;
+    }
+
+  ret = dev->lower->ops->write(dev->lower, phyaddr, MII_MMDADDRDATA,
+                               regaddr);
+  if (ret < 0)
+    {
+      goto out;
+    }
 
-  if (dev->lower->ops->reset)
+  ret = dev->lower->ops->write(dev->lower, phyaddr, MII_MMDCONTROL,
+                               devad | MII_MMDCONTROL_FUNC_NOINCR);
+  if (ret < 0)
     {
-      /* Take the mutex */
+      goto out;
+    }
+
+  ret = dev->lower->ops->read(dev->lower, phyaddr, MII_MMDADDRDATA, value);
+
+out:
+  nxmutex_unlock(&dev->lock);
+  return ret;
+}
+
+/****************************************************************************
+ * Name: mdio_c45_write
+ *
+ * Description:
+ *   Write a Clause 45 MMD register.  Uses the lower-half native C45 write
+ *   when available; otherwise performs indirect access over Clause 22
+ *   registers 13 (MMD control) and 14 (MMD address/data).
+ *
+ * Input Parameters:
+ *   dev     - The MDIO bus handle.
+ *   phyaddr - The PHY address (0-31).
+ *   devad   - The MMD device address.
+ *   regaddr - The 16-bit MMD register address.
+ *   value   - The value to write.
+ *
+ * Returned Value:
+ *   Zero (OK) on success; a negated errno value on failure.
+ *
+ ****************************************************************************/
 
-      ret = nxmutex_lock(&dev->lock);
-      if (ret < 0)
-        {
-          return ret;
-        }
+int mdio_c45_write(FAR struct mdio_bus_s *dev, uint8_t phyaddr,
+                   uint8_t devad, uint16_t regaddr, uint16_t value)
+{
+  int ret;
 
-      /* Call the lowerhalf driver's reset method */
+  DEBUGASSERT(dev != NULL && dev->lower != NULL);
 
-      ret = MDIO_RESET(dev, phyaddr);
+  ret = nxmutex_lock(&dev->lock);
+  if (ret < 0)
+    {
+      return ret;
+    }
 
-      /* Release the mutex */
+  /* Native C45 path */
 
+  if (dev->lower->ops->write_c45 != NULL)
+    {
+      ret = dev->lower->ops->write_c45(dev->lower, phyaddr, devad,
+                                       regaddr, value);
       nxmutex_unlock(&dev->lock);
+      return ret;
+    }
+
+  /* Fallback: indirect access over Clause 22 (reg 13/14) */
+
+  ret = dev->lower->ops->write(dev->lower, phyaddr, MII_MMDCONTROL, devad);
+  if (ret < 0)
+    {
+      goto out;
     }
 
+  ret = dev->lower->ops->write(dev->lower, phyaddr, MII_MMDADDRDATA,
+                               regaddr);
+  if (ret < 0)
+    {
+      goto out;
+    }
+
+  ret = dev->lower->ops->write(dev->lower, phyaddr, MII_MMDCONTROL,
+                               devad | MII_MMDCONTROL_FUNC_NOINCR);
+  if (ret < 0)
+    {
+      goto out;
+    }
+
+  ret = dev->lower->ops->write(dev->lower, phyaddr, MII_MMDADDRDATA, value);
+
+out:
+  nxmutex_unlock(&dev->lock);
   return ret;
 }
+
+#endif /* CONFIG_MDIO_CLAUSE_45 */
diff --git a/include/nuttx/net/mdio.h b/include/nuttx/net/mdio.h
index 1da0c8cbe48..71c20dc58ba 100644
--- a/include/nuttx/net/mdio.h
+++ b/include/nuttx/net/mdio.h
@@ -60,12 +60,37 @@ struct mdio_ops_s
   int (*write)(FAR struct mdio_lowerhalf_s *lower, uint8_t phyaddr,
                uint8_t regaddr, uint16_t value);
 
-  #ifdef CONFIG_MDIO_CLAUSE_45
-  #endif
+#ifdef CONFIG_MDIO_CLAUSE_45
+  /* Native Clause 45 MDIO read.  Optional: when NULL, mdio_c45_read()
+   * falls back to indirect access via Clause 22 registers 13/14.
+   */
+
+  int (*read_c45)(FAR struct mdio_lowerhalf_s *lower, uint8_t phyaddr,
+                  uint8_t devad, uint16_t regaddr, FAR uint16_t *value);
+
+  /* Native Clause 45 MDIO write.  Optional: when NULL, mdio_c45_write()
+   * falls back to indirect access via Clause 22 registers 13/14.
+   */
 
-  /* PHY Reset. Optional. */
+  int (*write_c45)(FAR struct mdio_lowerhalf_s *lower, uint8_t phyaddr,
+                   uint8_t devad, uint16_t regaddr, uint16_t value);
+#endif
+
+  /* PHY hardware reset line control. Optional.
+   *
+   * controls the PHY's RESET_N line by
+   * logical value rather than performing a one-shot pulse:
+   *   value != 0 -> assert reset  (drive the PHY into reset)
+   *   value == 0 -> deassert reset (release the PHY)
+   * The lower half owns pin polarity (active-low RESET_N is handled inside),
+   * and may sleep for the datasheet-mandated assert/deassert settle time
+   * before returning.  A single MDIO bus may host several PHYs at different
+   * addresses, so any idempotency (skipping a redundant assert/deassert for
+   * a given phyaddr) is the lower half's responsibility.
+   */
 
-  int (*reset)(FAR struct mdio_lowerhalf_s *lower, uint8_t phyaddr);
+  int (*reset)(FAR struct mdio_lowerhalf_s *lower, uint8_t phyaddr,
+               int value);
 };
 
 /* This structure defines the state of the MDIO lower-half driver.
@@ -164,22 +189,61 @@ int mdio_read(FAR struct mdio_bus_s *dev, uint8_t 
phyaddr, uint8_t regaddr,
 int mdio_write(FAR struct mdio_bus_s *dev, uint8_t phyaddr, uint8_t regaddr,
                uint16_t value);
 
+/****************************************************************************
+ * Name: mdio_c45_read / mdio_c45_write
+ *
+ * Description:
+ *   Clause 45 MMD register access.  Uses the lower-half native C45 ops if
+ *   provided; otherwise falls back to indirect access over Clause 22
+ *   registers 13/14.  Only available when CONFIG_MDIO_CLAUSE_45 is set.
+ *
+ * Input Parameters:
+ *   dev     - The MDIO bus handle.
+ *   phyaddr - The PHY address (0-31).
+ *   devad   - The MMD device address.
+ *   regaddr - The 16-bit MMD register address.
+ *   value   - Read: pointer to store the value.  Write: value to write.
+ *
+ * Returned Value:
+ *   Zero (OK) on success; a negated errno value on failure.
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_MDIO_CLAUSE_45
+int mdio_c45_read(FAR struct mdio_bus_s *dev, uint8_t phyaddr,
+                  uint8_t devad, uint16_t regaddr, FAR uint16_t *value);
+
+int mdio_c45_write(FAR struct mdio_bus_s *dev, uint8_t phyaddr,
+                   uint8_t devad, uint16_t regaddr, uint16_t value);
+#endif
+
 /****************************************************************************
  * Name: mdio_reset
  *
  * Description:
- *   Reset a PHY on the MDIO bus.
+ *   Control the hardware reset line of a PHY on the MDIO bus. This is a
+ *   level control, not a one-shot pulse.  Callers assert then deassert
+ *   to perform a full reset:
+ *
+ *     mdio_reset(dev, phyaddr, 1);   // assert (into reset)
+ *     mdio_reset(dev, phyaddr, 0);   // deassert (release)
+ *
+ *   The request is always forwarded to the lower-half driver, which owns
+ *   the per-PHY assert/deassert settle delay and any idempotency (a single
+ *   MDIO bus may host several PHYs at different addresses).
  *
  * Input Parameters:
  *   dev     - The MDIO bus handle.
  *   phyaddr - The PHY address (0-31) to reset.
+ *   value   - Reset line state: 1 to assert reset, 0 to deassert.
  *
  * Returned Value:
- *   Zero (OK) on success; a negated errno value on failure.
+ *   Zero (OK) on success; -ENOSYS if no reset op is provided; a negated
+ *   errno value on failure.
  *
  ****************************************************************************/
 
-int mdio_reset(FAR struct mdio_bus_s *dev, uint8_t phyaddr);
+int mdio_reset(FAR struct mdio_bus_s *dev, uint8_t phyaddr, int value);
 
 #ifdef __cplusplus
 }

Reply via email to