drivers/net/ethernet/freescale/enetc/enetc_mdio.c

   1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2 /* Copyright 2019 NXP */
   3
   4 #include <linux/fsl/enetc_mdio.h>
   5 #include <linux/mdio.h>
   6 #include <linux/of_mdio.h>
   7 #include <linux/iopoll.h>
   8 #include <linux/of.h>
   9
  10 #include "enetc_pf.h"
  11
  12 #define ENETC_MDIO_CFG  0x0     /* MDIO configuration and status */
  13 #define ENETC_MDIO_CTL  0x4     /* MDIO control */
  14 #define ENETC_MDIO_DATA 0x8     /* MDIO data */
  15 #define ENETC_MDIO_ADDR 0xc     /* MDIO address */
  16
  17 static inline u32 _enetc_mdio_rd(struct enetc_mdio_priv *mdio_priv, int off)
  18 {
  19         return enetc_port_rd(mdio_priv->hw, mdio_priv->mdio_base + off);
  20 }
  21
  22 static inline void _enetc_mdio_wr(struct enetc_mdio_priv *mdio_priv, int off,
  23                                   u32 val)
  24 {
  25         enetc_port_wr(mdio_priv->hw, mdio_priv->mdio_base + off, val);
  26 }
  27
  28 #define enetc_mdio_rd(mdio_priv, off) \
  29         _enetc_mdio_rd(mdio_priv, ENETC_##off)
  30 #define enetc_mdio_wr(mdio_priv, off, val) \
  31         _enetc_mdio_wr(mdio_priv, ENETC_##off, val)
  32 #define enetc_mdio_rd_reg(off)  enetc_mdio_rd(mdio_priv, off)
  33
  34 #define ENETC_MDC_DIV           258
  35
  36 #define MDIO_CFG_CLKDIV(x)      ((((x) >> 1) & 0xff) << 8)
  37 #define MDIO_CFG_BSY            BIT(0)
  38 #define MDIO_CFG_RD_ER          BIT(1)
  39 #define MDIO_CFG_ENC45          BIT(6)
  40  /* external MDIO only - driven on neg MDC edge */
  41 #define MDIO_CFG_NEG            BIT(23)
  42
  43 #define MDIO_CTL_DEV_ADDR(x)    ((x) & 0x1f)
  44 #define MDIO_CTL_PORT_ADDR(x)   (((x) & 0x1f) << 5)
  45 #define MDIO_CTL_READ           BIT(15)
  46 #define MDIO_DATA(x)            ((x) & 0xffff)
  47
  48 #define TIMEOUT 1000
  49 static int enetc_mdio_wait_complete(struct enetc_mdio_priv *mdio_priv)
  50 {
  51         u32 val;
  52
  53         return readx_poll_timeout(enetc_mdio_rd_reg, MDIO_CFG, val,
  54                                   !(val & MDIO_CFG_BSY), 10, 10 * TIMEOUT);
  55 }
  56
  57 int enetc_mdio_write(struct mii_bus *bus, int phy_id, int regnum, u16 value)
  58 {
  59         struct enetc_mdio_priv *mdio_priv = bus->priv;
  60         u32 mdio_ctl, mdio_cfg;
  61         u16 dev_addr;
  62         int ret;
  63
  64         mdio_cfg = MDIO_CFG_CLKDIV(ENETC_MDC_DIV) | MDIO_CFG_NEG;
  65         if (regnum & MII_ADDR_C45) {
  66                 dev_addr = (regnum >> 16) & 0x1f;
  67                 mdio_cfg |= MDIO_CFG_ENC45;
  68         } else {
  69                 /* clause 22 (ie 1G) */
  70                 dev_addr = regnum & 0x1f;
  71                 mdio_cfg &= ~MDIO_CFG_ENC45;
  72         }
  73
  74         enetc_mdio_wr(mdio_priv, MDIO_CFG, mdio_cfg);
  75
  76         ret = enetc_mdio_wait_complete(mdio_priv);
  77         if (ret)
  78                 return ret;
  79
  80         /* set port and dev addr */
  81         mdio_ctl = MDIO_CTL_PORT_ADDR(phy_id) | MDIO_CTL_DEV_ADDR(dev_addr);
  82         enetc_mdio_wr(mdio_priv, MDIO_CTL, mdio_ctl);
  83
  84         /* set the register address */
  85         if (regnum & MII_ADDR_C45) {
  86                 enetc_mdio_wr(mdio_priv, MDIO_ADDR, regnum & 0xffff);
  87
  88                 ret = enetc_mdio_wait_complete(mdio_priv);
  89                 if (ret)
  90                         return ret;
  91         }
  92
  93         /* write the value */
  94         enetc_mdio_wr(mdio_priv, MDIO_DATA, MDIO_DATA(value));
  95
  96         ret = enetc_mdio_wait_complete(mdio_priv);
  97         if (ret)
  98                 return ret;
  99
 100         return 0;
 101 }
 102 EXPORT_SYMBOL_GPL(enetc_mdio_write);
 103
 104 int enetc_mdio_read(struct mii_bus *bus, int phy_id, int regnum)
 105 {
 106         struct enetc_mdio_priv *mdio_priv = bus->priv;
 107         u32 mdio_ctl, mdio_cfg;
 108         u16 dev_addr, value;
 109         int ret;
 110
 111         mdio_cfg = MDIO_CFG_CLKDIV(ENETC_MDC_DIV) | MDIO_CFG_NEG;
 112         if (regnum & MII_ADDR_C45) {
 113                 dev_addr = (regnum >> 16) & 0x1f;
 114                 mdio_cfg |= MDIO_CFG_ENC45;
 115         } else {
 116                 dev_addr = regnum & 0x1f;
 117                 mdio_cfg &= ~MDIO_CFG_ENC45;
 118         }
 119
 120         enetc_mdio_wr(mdio_priv, MDIO_CFG, mdio_cfg);
 121
 122         ret = enetc_mdio_wait_complete(mdio_priv);
 123         if (ret)
 124                 return ret;
 125
 126         /* set port and device addr */
 127         mdio_ctl = MDIO_CTL_PORT_ADDR(phy_id) | MDIO_CTL_DEV_ADDR(dev_addr);
 128         enetc_mdio_wr(mdio_priv, MDIO_CTL, mdio_ctl);
 129
 130         /* set the register address */
 131         if (regnum & MII_ADDR_C45) {
 132                 enetc_mdio_wr(mdio_priv, MDIO_ADDR, regnum & 0xffff);
 133
 134                 ret = enetc_mdio_wait_complete(mdio_priv);
 135                 if (ret)
 136                         return ret;
 137         }
 138
 139         /* initiate the read */
 140         enetc_mdio_wr(mdio_priv, MDIO_CTL, mdio_ctl | MDIO_CTL_READ);
 141
 142         ret = enetc_mdio_wait_complete(mdio_priv);
 143         if (ret)
 144                 return ret;
 145
 146         /* return all Fs if nothing was there */
 147         if (enetc_mdio_rd(mdio_priv, MDIO_CFG) & MDIO_CFG_RD_ER) {
 148                 dev_dbg(&bus->dev,
 149                         "Error while reading PHY%d reg at %d.%hhu\n",
 150                         phy_id, dev_addr, regnum);
 151                 return 0xffff;
 152         }
 153
 154         value = enetc_mdio_rd(mdio_priv, MDIO_DATA) & 0xffff;
 155
 156         return value;
 157 }
 158 EXPORT_SYMBOL_GPL(enetc_mdio_read);
 159
 160 struct enetc_hw *enetc_hw_alloc(struct device *dev, void __iomem *port_regs)
 161 {
 162         struct enetc_hw *hw;
 163
 164         hw = devm_kzalloc(dev, sizeof(*hw), GFP_KERNEL);
 165         if (!hw)
 166                 return ERR_PTR(-ENOMEM);
 167
 168         hw->port = port_regs;
 169
 170         return hw;
 171 }
 172 EXPORT_SYMBOL_GPL(enetc_hw_alloc);