Quelle  nxp-cbtx.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Driver for 100BASE-TX PHY embedded into NXP SJA1110 switch
 *
 * Copyright 2022-2023 NXP
 */

#include <linux/kernel.h>
#include <linux/mii.h>
#include <linux/module.h>
#include <linux/phy.h>

#define PHY_ID_CBTX_SJA1110   0x001bb020

/* Registers */
#define  CBTX_MODE_CTRL_STAT   0x11
#define  CBTX_PDOWN_CTRL   0x18
#define  CBTX_RX_ERR_COUNTER   0x1a
#define  CBTX_IRQ_STAT    0x1d
#define  CBTX_IRQ_ENABLE   0x1e

/* Fields */
#define CBTX_MODE_CTRL_STAT_AUTO_MDIX_EN BIT(7)
#define CBTX_MODE_CTRL_STAT_MDIX_MODE  BIT(6)

#define CBTX_PDOWN_CTL_TRUE_PDOWN  BIT(0)

#define CBTX_IRQ_ENERGYON   BIT(7)
#define CBTX_IRQ_AN_COMPLETE   BIT(6)
#define CBTX_IRQ_REM_FAULT   BIT(5)
#define CBTX_IRQ_LINK_DOWN   BIT(4)
#define CBTX_IRQ_AN_LP_ACK   BIT(3)
#define CBTX_IRQ_PARALLEL_DETECT_FAULT  BIT(2)
#define CBTX_IRQ_AN_PAGE_RECV   BIT(1)

static int cbtx_soft_reset(struct phy_device *phydev)
{
 int ret;

 /* Can't soft reset unless we remove PHY from true power down mode */
 ret = phy_clear_bits(phydev, CBTX_PDOWN_CTRL,
        CBTX_PDOWN_CTL_TRUE_PDOWN);
 if (ret)
  return ret;

 return genphy_soft_reset(phydev);
}

static int cbtx_config_init(struct phy_device *phydev)
{
 /* Wait for cbtx_config_aneg() to kick in and apply this */
 phydev->mdix_ctrl = ETH_TP_MDI_AUTO;

 return 0;
}

static int cbtx_mdix_status(struct phy_device *phydev)
{
 int ret;

 ret = phy_read(phydev, CBTX_MODE_CTRL_STAT);
 if (ret < 0)
  return ret;

 if (ret & CBTX_MODE_CTRL_STAT_MDIX_MODE)
  phydev->mdix = ETH_TP_MDI_X;
 else
  phydev->mdix = ETH_TP_MDI;

 return 0;
}

static int cbtx_read_status(struct phy_device *phydev)
{
 int ret;

 ret = cbtx_mdix_status(phydev);
 if (ret)
  return ret;

 return genphy_read_status(phydev);
}

static int cbtx_mdix_config(struct phy_device *phydev)
{
 int ret;

 switch (phydev->mdix_ctrl) {
 case ETH_TP_MDI_AUTO:
  return phy_set_bits(phydev, CBTX_MODE_CTRL_STAT,
        CBTX_MODE_CTRL_STAT_AUTO_MDIX_EN);
 case ETH_TP_MDI:
  ret = phy_clear_bits(phydev, CBTX_MODE_CTRL_STAT,
         CBTX_MODE_CTRL_STAT_AUTO_MDIX_EN);
  if (ret)
   return ret;

  return phy_clear_bits(phydev, CBTX_MODE_CTRL_STAT,
          CBTX_MODE_CTRL_STAT_MDIX_MODE);
 case ETH_TP_MDI_X:
  ret = phy_clear_bits(phydev, CBTX_MODE_CTRL_STAT,
         CBTX_MODE_CTRL_STAT_AUTO_MDIX_EN);
  if (ret)
   return ret;

  return phy_set_bits(phydev, CBTX_MODE_CTRL_STAT,
        CBTX_MODE_CTRL_STAT_MDIX_MODE);
 }

 return 0;
}

static int cbtx_config_aneg(struct phy_device *phydev)
{
 int ret;

 ret = cbtx_mdix_config(phydev);
 if (ret)
  return ret;

 return genphy_config_aneg(phydev);
}

static int cbtx_ack_interrupts(struct phy_device *phydev)
{
 return phy_read(phydev, CBTX_IRQ_STAT);
}

static int cbtx_config_intr(struct phy_device *phydev)
{
 int ret;

 if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
  ret = cbtx_ack_interrupts(phydev);
  if (ret < 0)
   return ret;

  ret = phy_write(phydev, CBTX_IRQ_ENABLE, CBTX_IRQ_LINK_DOWN |
    CBTX_IRQ_AN_COMPLETE | CBTX_IRQ_ENERGYON);
  if (ret)
   return ret;
 } else {
  ret = phy_write(phydev, CBTX_IRQ_ENABLE, 0);
  if (ret)
   return ret;

  ret = cbtx_ack_interrupts(phydev);
  if (ret < 0)
   return ret;
 }

 return 0;
}

static irqreturn_t cbtx_handle_interrupt(struct phy_device *phydev)
{
 int irq_stat, irq_enabled;

 irq_stat = cbtx_ack_interrupts(phydev);
 if (irq_stat < 0) {
  phy_error(phydev);
  return IRQ_NONE;
 }

 irq_enabled = phy_read(phydev, CBTX_IRQ_ENABLE);
 if (irq_enabled < 0) {
  phy_error(phydev);
  return IRQ_NONE;
 }

 if (!(irq_enabled & irq_stat))
  return IRQ_NONE;

 phy_trigger_machine(phydev);

 return IRQ_HANDLED;
}

static int cbtx_get_sset_count(struct phy_device *phydev)
{
 return 1;
}

static void cbtx_get_strings(struct phy_device *phydev, u8 *data)
{
 ethtool_puts(&data, "100btx_rx_err");
}

static void cbtx_get_stats(struct phy_device *phydev,
      struct ethtool_stats *stats, u64 *data)
{
 int ret;

 ret = phy_read(phydev, CBTX_RX_ERR_COUNTER);
 data[0] = (ret < 0) ? U64_MAX : ret;
}

static struct phy_driver cbtx_driver[] = {
 {
  PHY_ID_MATCH_MODEL(PHY_ID_CBTX_SJA1110),
  .name   = "NXP CBTX (SJA1110)",
  /* PHY_BASIC_FEATURES */
  .soft_reset  = cbtx_soft_reset,
  .config_init  = cbtx_config_init,
  .suspend  = genphy_suspend,
  .resume   = genphy_resume,
  .config_intr  = cbtx_config_intr,
  .handle_interrupt = cbtx_handle_interrupt,
  .read_status  = cbtx_read_status,
  .config_aneg  = cbtx_config_aneg,
  .get_sset_count  = cbtx_get_sset_count,
  .get_strings  = cbtx_get_strings,
  .get_stats  = cbtx_get_stats,
 },
};

module_phy_driver(cbtx_driver);

static const struct mdio_device_id __maybe_unused cbtx_tbl[] = {
 { PHY_ID_MATCH_MODEL(PHY_ID_CBTX_SJA1110) },
 { },
};

MODULE_DEVICE_TABLE(mdio, cbtx_tbl);

MODULE_AUTHOR("Vladimir Oltean ");
MODULE_DESCRIPTION("NXP CBTX PHY driver");
MODULE_LICENSE("GPL");