ra8_eth_link.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_eth.h"
#include "ra8_eth_internal.h"
#include "ra8_etha.h"
#include "ra8_log.h"
#include "ra8_rmac.h"
#include "ra8_time.h"

static const char* s_tag = "ETH";

volatile uint16_t g_ra8_eth_phy_bmsr_after_wait;

volatile uint16_t g_ra8_eth_anlpar;

volatile uint16_t g_ra8_eth_gbsr;

volatile uint32_t g_ra8_eth_resync_speed_lsc;

volatile uint32_t g_ra8_eth_resync_duplex;

RA8_INTERNAL
static void internal_pick_negotiated_speed(uint16_t           anlpar,
                                           uint16_t           gbsr,
                                           ra8_rmac_lsc_t*    out_speed,
                                           ra8_rmac_duplex_t* out_duplex)
{
  /* Default: lowest tier. */
  *out_speed  = k_ra8_rmac_lsc_10mbit;
  *out_duplex = k_ra8_rmac_duplex_half;
  if ((anlpar & (uint16_t)k_ra8_eth_phy_anlpar_10h) != 0U) {
    *out_speed  = k_ra8_rmac_lsc_10mbit;
    *out_duplex = k_ra8_rmac_duplex_half;
  }
  if ((anlpar & (uint16_t)k_ra8_eth_phy_anlpar_10f) != 0U) {
    *out_speed  = k_ra8_rmac_lsc_10mbit;
    *out_duplex = k_ra8_rmac_duplex_full;
  }
  if ((anlpar & (uint16_t)k_ra8_eth_phy_anlpar_100h) != 0U) {
    *out_speed  = k_ra8_rmac_lsc_100mbit;
    *out_duplex = k_ra8_rmac_duplex_half;
  }
  if ((anlpar & (uint16_t)k_ra8_eth_phy_anlpar_100f) != 0U) {
    *out_speed  = k_ra8_rmac_lsc_100mbit;
    *out_duplex = k_ra8_rmac_duplex_full;
  }
  if ((gbsr & (uint16_t)k_ra8_eth_phy_gbsr_1000h) != 0U) {
    *out_speed  = k_ra8_rmac_lsc_1000mbit;
    *out_duplex = k_ra8_rmac_duplex_half;
  }
  if ((gbsr & (uint16_t)k_ra8_eth_phy_gbsr_1000f) != 0U) {
    *out_speed  = k_ra8_rmac_lsc_1000mbit;
    *out_duplex = k_ra8_rmac_duplex_full;
  }
}

typedef enum : uint32_t {
  k_ra8_eth_an_poll_period_ms = 50U, 
  k_ra8_eth_an_poll_max_iters = 80U, 
} ra8_eth_an_poll_t;

RA8_INTERNAL
static void internal_wait_for_autoneg(ra8_rmac_port_t port)
{
  uint16_t bmsr = 0U;
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_eth_an_poll_max_iters; ++i) {
    if (ra8_rmac_mdio_c22_read(port,
                               (uint8_t)k_ra8_eth_phy_addr_default,
                               (uint8_t)k_ra8_eth_phy_reg_bmsr,
                               &bmsr) != k_ra8_ok) {
      g_ra8_eth_phy_bmsr_after_wait = bmsr;
      return;
    }
    if ((bmsr & (uint16_t)k_ra8_eth_phy_bmsr_an_done) != 0U) {
      g_ra8_eth_phy_bmsr_after_wait = bmsr;
      return;
    }
    ra8_delay_ms((uint32_t)k_ra8_eth_an_poll_period_ms);
  }
  g_ra8_eth_phy_bmsr_after_wait = bmsr;
}

RA8_INTERNAL
static ra8_err_t internal_query_negotiated_speed(ra8_rmac_port_t    port,
                                                 ra8_rmac_lsc_t*    out_speed,
                                                 ra8_rmac_duplex_t* out_duplex)
{
  uint16_t anlpar = 0U;
  /* HUM Ch 33.4.1.1 "MPSM : PHY Station Management Register" p 1707 */
  const ra8_err_t anlpar_err = ra8_rmac_mdio_c22_read(port,
                                                      (uint8_t)k_ra8_eth_phy_addr_default,
                                                      (uint8_t)k_ra8_eth_phy_reg_anlpar,
                                                      &anlpar);
  if (anlpar_err != k_ra8_ok) {
    return anlpar_err;
  }
  uint16_t        gbsr     = 0U;
  const ra8_err_t gbsr_err = ra8_rmac_mdio_c22_read(port,
                                                    (uint8_t)k_ra8_eth_phy_addr_default,
                                                    (uint8_t)k_ra8_eth_phy_reg_gbsr,
                                                    &gbsr);
  if (gbsr_err != k_ra8_ok) {
    return gbsr_err;
  }
  g_ra8_eth_anlpar = anlpar;
  g_ra8_eth_gbsr   = gbsr;
  internal_pick_negotiated_speed(anlpar, gbsr, out_speed, out_duplex);
  g_ra8_eth_resync_speed_lsc = (uint32_t)*out_speed;
  g_ra8_eth_resync_duplex    = (uint32_t)*out_duplex;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_program_mpic(ra8_rmac_port_t port, ra8_rmac_lsc_t speed, ra8_rmac_duplex_t duplex)
{
  const ra8_etha_port_t etha_port = (port == k_ra8_rmac_port_0)
                                      ? (ra8_etha_port_t)k_ra8_etha_port_0
                                      : (ra8_etha_port_t)k_ra8_etha_port_1;
  ra8_err_t             err       = ra8_etha_set_mode(etha_port, k_ra8_etha_opc_disable);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_etha_set_mode(etha_port, k_ra8_etha_opc_config);
  if (err != k_ra8_ok) {
    return err;
  }
  /* HUM Table 29.11: MPIC.PIS tracks link speed, not the external
   * RGMII-ness -- GMII for 1 Gbps, MII for 10/100 Mbps. The ESWM
   * MIICR1.MIISEL field (programmed once by the board) is what
   * actually selects external RGMII. */
  ra8_rmac_pis_t pis = k_ra8_rmac_pis_mii;
  if (speed == k_ra8_rmac_lsc_1000mbit) {
    pis = k_ra8_rmac_pis_gmii;
  }
  const ra8_err_t set_err = ra8_rmac_set_link(port, pis, speed, duplex);
  const ra8_err_t dis_err = ra8_etha_set_mode(etha_port, k_ra8_etha_opc_disable);
  const ra8_err_t op_err  = ra8_etha_set_mode(etha_port, k_ra8_etha_opc_operation);
  if (set_err != k_ra8_ok) {
    return set_err;
  }
  if (dis_err != k_ra8_ok) {
    return dis_err;
  }
  return op_err;
}

RA8_INTERNAL
static ra8_err_t internal_resync_mac_speed(ra8_rmac_port_t port, uint16_t bmcr)
{
  (void)bmcr;
  internal_wait_for_autoneg(port);
  ra8_rmac_lsc_t    speed  = k_ra8_rmac_lsc_10mbit;
  ra8_rmac_duplex_t duplex = k_ra8_rmac_duplex_half;
  const ra8_err_t   q_err  = internal_query_negotiated_speed(port, &speed, &duplex);
  if (q_err != k_ra8_ok) {
    return q_err;
  }
  const ra8_err_t mpic_err = internal_program_mpic(port, speed, duplex);
  if (mpic_err != k_ra8_ok) {
    return mpic_err;
  }
  g_eth_mac_speed_resynced = true;
  ra8_log_info(s_tag, "link_status: MPIC resynced to PHY speed/duplex");
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_phy_read_link(ra8_rmac_port_t port, ra8_eth_link_t* out_status, uint16_t* out_bmcr)
{
  uint16_t bmsr = 0U;
  /* HUM Ch 33.4.1.1 "MPSM : PHY Station Management Register" p 1707 */
  const ra8_err_t bmsr_err = ra8_rmac_mdio_c22_read(port,
                                                    (uint8_t)k_ra8_eth_phy_addr_default,
                                                    (uint8_t)k_ra8_eth_phy_reg_bmsr,
                                                    &bmsr);
  RA8_RETURN_ON_ERROR(bmsr_err, s_tag, "link_status: bmsr read");
 
  uint16_t bmcr = 0U;
  /* HUM Ch 33.4.1.1 "MPSM : PHY Station Management Register" p 1707 */
  const ra8_err_t bmcr_err = ra8_rmac_mdio_c22_read(port,
                                                    (uint8_t)k_ra8_eth_phy_addr_default,
                                                    (uint8_t)k_ra8_eth_phy_reg_bmcr,
                                                    &bmcr);
  RA8_RETURN_ON_ERROR(bmcr_err, s_tag, "link_status: bmcr read");
 
  out_status->bmsr        = bmsr;
  out_status->link_up     = ((bmsr & k_ra8_eth_phy_bmsr_link_up) != 0U) ? 1U : 0U;
  out_status->full_duplex = ((bmcr & k_ra8_eth_phy_bmcr_duplex) != 0U) ? 1U : 0U;
  if ((bmcr & k_ra8_eth_phy_bmcr_speed100) != 0U) {
    out_status->speed_mbps = k_ra8_eth_phy_speed_100;
  } else {
    out_status->speed_mbps = k_ra8_eth_phy_speed_10;
  }
  *out_bmcr = bmcr;
  return k_ra8_ok;
}
 
ra8_err_t ra8_eth_link_status(ra8_eth_link_t* out_status)
{
  RA8_CHECK_NULL_PTR(out_status, s_tag, "link_status: out must not be nullptr");
  if (s_eth_state.opened == 0U) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_rmac_port_t port = priv_ra8_eth_channel_to_port(s_eth_state.cfg.channel);
  uint16_t              bmcr = 0U;
  const ra8_err_t       err  = internal_phy_read_link(port, out_status, &bmcr);
  RA8_RETURN_ON_ERROR(err, s_tag, "link_status: phy read");
 
  /* HUM Ch 33.4.1.2 "MPIC : PHY Interfaces Configuration Register"
   * p 1707: on first link-up after open, realign MPIC.LSC with the
   * PHY's negotiated speed. Sequential ifs (no compound boolean
   * operators) so each gate remains MC/DC-clean without a paired
   * test vector matrix. */
  if (out_status->link_up == 0U) {
    return k_ra8_ok;
  }
  if (g_eth_mac_speed_resynced) {
    return k_ra8_ok;
  }
  return internal_resync_mac_speed(port, bmcr);
}