ra8_ether_phy.c

Go to the documentation of this file.

 
#include "ra8_ether_phy.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"

static const char* s_tag = "EPHY";
 
typedef enum : uint8_t {
  k_ra8_ether_phy_reg_max        = 31U, 
  k_ra8_ether_phy_reset_poll_max = 32U, 
} ra8_ether_phy_priv_t;
 
typedef enum : uint16_t {
  k_ra8_ether_phy_bmcr_reset       = 0x8000U, 
  k_ra8_ether_phy_bmcr_an_enable   = 0x1000U, 
  k_ra8_ether_phy_bmcr_an_restart  = 0x0200U, 
  k_ra8_ether_phy_bmsr_link_up     = 0x0004U, 
  k_ra8_ether_phy_bmsr_an_complete = 0x0020U, 
  k_ra8_ether_phy_anar_100full     = 0x0100U, 
  k_ra8_ether_phy_anar_100half     = 0x0080U, 
  k_ra8_ether_phy_anar_10full      = 0x0040U, 
  k_ra8_ether_phy_anar_10half      = 0x0020U, 
} ra8_ether_phy_bits_t;
 
typedef struct {
  bool                opened;        
  uint8_t             phy_address;   
  ra8_ether_phy_mii_t mii_type;      
  uint16_t            reset_wait_us; 
  ra8_ether_phy_io_t  io;            
  uint16_t            last_bmsr;     
} ra8_ether_phy_internal_t;
 
static ra8_ether_phy_internal_t s_state = {};

RA8_INTERNAL
static ra8_err_t internal_reset_and_wait(void)
{
  ra8_err_t err = s_state.io.write(s_state.io.ctx,
                                   s_state.phy_address,
                                   k_ra8_ether_phy_reg_control,
                                   k_ra8_ether_phy_bmcr_reset);
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint8_t i = 0U; i < k_ra8_ether_phy_reset_poll_max; ++i) {
    uint16_t reg = 0U;
    err = s_state.io.read(s_state.io.ctx, s_state.phy_address, k_ra8_ether_phy_reg_control, &reg);
    if (err != k_ra8_ok) {
      return err;
    }
    if ((reg & k_ra8_ether_phy_bmcr_reset) == 0U) {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_hw_timeout;
}
 
ra8_err_t ra8_ether_phy_open(const ra8_ether_phy_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg must not be nullptr");
  RA8_CHECK_NULL_PTR(cfg->io.read, s_tag, "io.read required");
  RA8_CHECK_NULL_PTR(cfg->io.write, s_tag, "io.write required");
  if (cfg->phy_address > k_ra8_ether_phy_addr_max) {
    return k_ra8_err_invalid_arg;
  }
  if (s_state.opened) {
    return k_ra8_err_exists;
  }
  s_state.opened        = true;
  s_state.phy_address   = cfg->phy_address;
  s_state.mii_type      = cfg->mii_type;
  s_state.reset_wait_us = cfg->reset_wait_us;
  s_state.io            = cfg->io;
  s_state.last_bmsr     = 0U;
 
  /* Issue BMCR reset and poll for self-clear. */
  const ra8_err_t err = internal_reset_and_wait();
  if (err != k_ra8_ok) {
    s_state.opened = false;
    return err;
  }
  ra8_log_info_val(s_tag, "phy ready addr", (uint32_t)cfg->phy_address);
  return k_ra8_ok;
}
 
ra8_err_t ra8_ether_phy_close(void)
{
  if (!s_state.opened) {
    return k_ra8_err_invalid_state;
  }
  s_state.opened = false;
  return k_ra8_ok;
}
 
ra8_err_t ra8_ether_phy_mdio_read(uint8_t reg_addr, uint16_t* out_data)
{
  RA8_CHECK_NULL_PTR(out_data, s_tag, "out_data must not be nullptr");
  if (!s_state.opened) {
    return k_ra8_err_not_initialized;
  }
  if (reg_addr > k_ra8_ether_phy_reg_max) {
    return k_ra8_err_invalid_arg;
  }
  return s_state.io.read(s_state.io.ctx, s_state.phy_address, reg_addr, out_data);
}
 
ra8_err_t ra8_ether_phy_mdio_write(uint8_t reg_addr, uint16_t data)
{
  if (!s_state.opened) {
    return k_ra8_err_not_initialized;
  }
  if (reg_addr > k_ra8_ether_phy_reg_max) {
    return k_ra8_err_invalid_arg;
  }
  return s_state.io.write(s_state.io.ctx, s_state.phy_address, reg_addr, data);
}
 
ra8_err_t ra8_ether_phy_auto_negotiate_start(void)
{
  if (!s_state.opened) {
    return k_ra8_err_not_initialized;
  }
  /* Re-arm AN: enable + restart. */
  const uint16_t bmcr =
    (uint16_t)(k_ra8_ether_phy_bmcr_an_enable | k_ra8_ether_phy_bmcr_an_restart);
  return s_state.io.write(s_state.io.ctx, s_state.phy_address, k_ra8_ether_phy_reg_control, bmcr);
}
 
ra8_err_t ra8_ether_phy_link_status_get(ra8_ether_phy_link_t* out)
{
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  if (!s_state.opened) {
    return k_ra8_err_not_initialized;
  }
  uint16_t  bmsr = 0U;
  ra8_err_t err =
    s_state.io.read(s_state.io.ctx, s_state.phy_address, k_ra8_ether_phy_reg_status, &bmsr);
  if (err != k_ra8_ok) {
    return err;
  }
  s_state.last_bmsr  = bmsr;
  out->bmsr          = bmsr;
  out->link_up       = (uint8_t)(((bmsr & k_ra8_ether_phy_bmsr_link_up) != 0U) ? 1U : 0U);
  out->auto_neg_done = (uint8_t)(((bmsr & k_ra8_ether_phy_bmsr_an_complete) != 0U) ? 1U : 0U);
  out->speed         = k_ra8_ether_phy_speed_no_link;
  if ((out->link_up != 0U) && (out->auto_neg_done != 0U)) {
    /* Inspect partner ability for resolved speed/duplex. */
    uint16_t lpa = 0U;
    err =
      s_state.io.read(s_state.io.ctx, s_state.phy_address, k_ra8_ether_phy_reg_an_partner, &lpa);
    if (err == k_ra8_ok) {
      if ((lpa & k_ra8_ether_phy_anar_100full) != 0U) {
        out->speed = k_ra8_ether_phy_speed_100f;
      } else if ((lpa & k_ra8_ether_phy_anar_100half) != 0U) {
        out->speed = k_ra8_ether_phy_speed_100h;
      } else if ((lpa & k_ra8_ether_phy_anar_10full) != 0U) {
        out->speed = k_ra8_ether_phy_speed_10f;
      } else if ((lpa & k_ra8_ether_phy_anar_10half) != 0U) {
        out->speed = k_ra8_ether_phy_speed_10h;
      }
    }
  }
  return k_ra8_ok;
}