drivers/net/axgbe/axgbe_i2c.c

   1 /*   SPDX-License-Identifier: BSD-3-Clause
   2  *   Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved.
   3  *   Copyright(c) 2018 Synopsys, Inc. All rights reserved.
   4  */
   5
   6 #include "axgbe_ethdev.h"
   7 #include "axgbe_common.h"
   8
   9 #define AXGBE_ABORT_COUNT       500
  10 #define AXGBE_DISABLE_COUNT     1000
  11
  12 #define AXGBE_STD_SPEED         1
  13
  14 #define AXGBE_INTR_RX_FULL      BIT(IC_RAW_INTR_STAT_RX_FULL_INDEX)
  15 #define AXGBE_INTR_TX_EMPTY     BIT(IC_RAW_INTR_STAT_TX_EMPTY_INDEX)
  16 #define AXGBE_INTR_TX_ABRT      BIT(IC_RAW_INTR_STAT_TX_ABRT_INDEX)
  17 #define AXGBE_INTR_STOP_DET     BIT(IC_RAW_INTR_STAT_STOP_DET_INDEX)
  18 #define AXGBE_DEFAULT_INT_MASK  (AXGBE_INTR_RX_FULL  |  \
  19                                  AXGBE_INTR_TX_EMPTY |  \
  20                                  AXGBE_INTR_TX_ABRT  |  \
  21                                  AXGBE_INTR_STOP_DET)
  22
  23 #define AXGBE_I2C_READ          BIT(8)
  24 #define AXGBE_I2C_STOP          BIT(9)
  25
  26 static int axgbe_i2c_abort(struct axgbe_port *pdata)
  27 {
  28         unsigned int wait = AXGBE_ABORT_COUNT;
  29
  30         /* Must be enabled to recognize the abort request */
  31         XI2C_IOWRITE_BITS(pdata, IC_ENABLE, EN, 1);
  32
  33         /* Issue the abort */
  34         XI2C_IOWRITE_BITS(pdata, IC_ENABLE, ABORT, 1);
  35
  36         while (wait--) {
  37                 if (!XI2C_IOREAD_BITS(pdata, IC_ENABLE, ABORT))
  38                         return 0;
  39                 rte_delay_us(500);
  40         }
  41
  42         return -EBUSY;
  43 }
  44
  45 static int axgbe_i2c_set_enable(struct axgbe_port *pdata, bool enable)
  46 {
  47         unsigned int wait = AXGBE_DISABLE_COUNT;
  48         unsigned int mode = enable ? 1 : 0;
  49
  50         while (wait--) {
  51                 XI2C_IOWRITE_BITS(pdata, IC_ENABLE, EN, mode);
  52                 if (XI2C_IOREAD_BITS(pdata, IC_ENABLE_STATUS, EN) == mode)
  53                         return 0;
  54
  55                 rte_delay_us(100);
  56         }
  57
  58         return -EBUSY;
  59 }
  60
  61 static int axgbe_i2c_disable(struct axgbe_port *pdata)
  62 {
  63         unsigned int ret;
  64
  65         ret = axgbe_i2c_set_enable(pdata, false);
  66         if (ret) {
  67                 /* Disable failed, try an abort */
  68                 ret = axgbe_i2c_abort(pdata);
  69                 if (ret)
  70                         return ret;
  71
  72                 /* Abort succeeded, try to disable again */
  73                 ret = axgbe_i2c_set_enable(pdata, false);
  74         }
  75
  76         return ret;
  77 }
  78
  79 static int axgbe_i2c_enable(struct axgbe_port *pdata)
  80 {
  81         return axgbe_i2c_set_enable(pdata, true);
  82 }
  83
  84 static void axgbe_i2c_clear_all_interrupts(struct axgbe_port *pdata)
  85 {
  86         XI2C_IOREAD(pdata, IC_CLR_INTR);
  87 }
  88
  89 static void axgbe_i2c_disable_interrupts(struct axgbe_port *pdata)
  90 {
  91         XI2C_IOWRITE(pdata, IC_INTR_MASK, 0);
  92 }
  93
  94 static void axgbe_i2c_enable_interrupts(struct axgbe_port *pdata)
  95 {
  96         XI2C_IOWRITE(pdata, IC_INTR_MASK, AXGBE_DEFAULT_INT_MASK);
  97 }
  98
  99 static void axgbe_i2c_write(struct axgbe_port *pdata)
 100 {
 101         struct axgbe_i2c_op_state *state = &pdata->i2c.op_state;
 102         unsigned int tx_slots;
 103         unsigned int cmd;
 104
 105         /* Configured to never receive Rx overflows, so fill up Tx fifo */
 106         tx_slots = pdata->i2c.tx_fifo_size - XI2C_IOREAD(pdata, IC_TXFLR);
 107         while (tx_slots && state->tx_len) {
 108                 if (state->op->cmd == AXGBE_I2C_CMD_READ)
 109                         cmd = AXGBE_I2C_READ;
 110                 else
 111                         cmd = *state->tx_buf++;
 112
 113                 if (state->tx_len == 1)
 114                         XI2C_SET_BITS(cmd, IC_DATA_CMD, STOP, 1);
 115
 116                 XI2C_IOWRITE(pdata, IC_DATA_CMD, cmd);
 117
 118                 tx_slots--;
 119                 state->tx_len--;
 120         }
 121
 122         /* No more Tx operations, so ignore TX_EMPTY and return */
 123         if (!state->tx_len)
 124                 XI2C_IOWRITE_BITS(pdata, IC_INTR_MASK, TX_EMPTY, 0);
 125 }
 126
 127 static void axgbe_i2c_read(struct axgbe_port *pdata)
 128 {
 129         struct axgbe_i2c_op_state *state = &pdata->i2c.op_state;
 130         unsigned int rx_slots;
 131
 132         /* Anything to be read? */
 133         if (state->op->cmd != AXGBE_I2C_CMD_READ)
 134                 return;
 135
 136         rx_slots = XI2C_IOREAD(pdata, IC_RXFLR);
 137         while (rx_slots && state->rx_len) {
 138                 *state->rx_buf++ = XI2C_IOREAD(pdata, IC_DATA_CMD);
 139                 state->rx_len--;
 140                 rx_slots--;
 141         }
 142 }
 143
 144 static void axgbe_i2c_clear_isr_interrupts(struct axgbe_port *pdata,
 145                                           unsigned int isr)
 146 {
 147         struct axgbe_i2c_op_state *state = &pdata->i2c.op_state;
 148
 149         if (isr & AXGBE_INTR_TX_ABRT) {
 150                 state->tx_abort_source = XI2C_IOREAD(pdata, IC_TX_ABRT_SOURCE);
 151                 XI2C_IOREAD(pdata, IC_CLR_TX_ABRT);
 152         }
 153
 154         if (isr & AXGBE_INTR_STOP_DET)
 155                 XI2C_IOREAD(pdata, IC_CLR_STOP_DET);
 156 }
 157
 158 static int axgbe_i2c_isr(struct axgbe_port *pdata)
 159 {
 160         struct axgbe_i2c_op_state *state = &pdata->i2c.op_state;
 161         unsigned int isr;
 162
 163         isr = XI2C_IOREAD(pdata, IC_RAW_INTR_STAT);
 164
 165         axgbe_i2c_clear_isr_interrupts(pdata, isr);
 166
 167         if (isr & AXGBE_INTR_TX_ABRT) {
 168                 axgbe_i2c_disable_interrupts(pdata);
 169
 170                 state->ret = -EIO;
 171                 goto out;
 172         }
 173
 174         /* Check for data in the Rx fifo */
 175         axgbe_i2c_read(pdata);
 176
 177         /* Fill up the Tx fifo next */
 178         axgbe_i2c_write(pdata);
 179
 180 out:
 181         /* Complete on an error or STOP condition */
 182         if (state->ret || XI2C_GET_BITS(isr, IC_RAW_INTR_STAT, STOP_DET))
 183                 return 1;
 184
 185         return 0;
 186 }
 187
 188 static void axgbe_i2c_set_mode(struct axgbe_port *pdata)
 189 {
 190         unsigned int reg;
 191
 192         reg = XI2C_IOREAD(pdata, IC_CON);
 193         XI2C_SET_BITS(reg, IC_CON, MASTER_MODE, 1);
 194         XI2C_SET_BITS(reg, IC_CON, SLAVE_DISABLE, 1);
 195         XI2C_SET_BITS(reg, IC_CON, RESTART_EN, 1);
 196         XI2C_SET_BITS(reg, IC_CON, SPEED, AXGBE_STD_SPEED);
 197         XI2C_SET_BITS(reg, IC_CON, RX_FIFO_FULL_HOLD, 1);
 198         XI2C_IOWRITE(pdata, IC_CON, reg);
 199 }
 200
 201 static void axgbe_i2c_get_features(struct axgbe_port *pdata)
 202 {
 203         struct axgbe_i2c *i2c = &pdata->i2c;
 204         unsigned int reg;
 205
 206         reg = XI2C_IOREAD(pdata, IC_COMP_PARAM_1);
 207         i2c->max_speed_mode = XI2C_GET_BITS(reg, IC_COMP_PARAM_1,
 208                                             MAX_SPEED_MODE);
 209         i2c->rx_fifo_size = XI2C_GET_BITS(reg, IC_COMP_PARAM_1,
 210                                           RX_BUFFER_DEPTH);
 211         i2c->tx_fifo_size = XI2C_GET_BITS(reg, IC_COMP_PARAM_1,
 212                                           TX_BUFFER_DEPTH);
 213 }
 214
 215 static void axgbe_i2c_set_target(struct axgbe_port *pdata, unsigned int addr)
 216 {
 217         XI2C_IOWRITE(pdata, IC_TAR, addr);
 218 }
 219
 220 static int axgbe_i2c_xfer(struct axgbe_port *pdata, struct axgbe_i2c_op *op)
 221 {
 222         struct axgbe_i2c_op_state *state = &pdata->i2c.op_state;
 223         int ret;
 224         uint64_t timeout;
 225
 226         pthread_mutex_lock(&pdata->i2c_mutex);
 227         ret = axgbe_i2c_disable(pdata);
 228         if (ret) {
 229                 PMD_DRV_LOG(ERR, "failed to disable i2c master\n");
 230                 return ret;
 231         }
 232
 233         axgbe_i2c_set_target(pdata, op->target);
 234
 235         memset(state, 0, sizeof(*state));
 236         state->op = op;
 237         state->tx_len = op->len;
 238         state->tx_buf = (unsigned char *)op->buf;
 239         state->rx_len = op->len;
 240         state->rx_buf = (unsigned char *)op->buf;
 241
 242         axgbe_i2c_clear_all_interrupts(pdata);
 243         ret = axgbe_i2c_enable(pdata);
 244         if (ret) {
 245                 PMD_DRV_LOG(ERR, "failed to enable i2c master\n");
 246                 return ret;
 247         }
 248
 249         /* Enabling the interrupts will cause the TX FIFO empty interrupt to
 250          * fire and begin to process the command via the ISR.
 251          */
 252         axgbe_i2c_enable_interrupts(pdata);
 253         timeout = rte_get_timer_cycles() + rte_get_timer_hz();
 254
 255         while (time_before(rte_get_timer_cycles(), timeout)) {
 256                 rte_delay_us(100);
 257                 if (XI2C_IOREAD(pdata, IC_RAW_INTR_STAT)) {
 258                         if (axgbe_i2c_isr(pdata))
 259                                 goto success;
 260                 }
 261         }
 262
 263         PMD_DRV_LOG(ERR, "i2c operation timed out\n");
 264         axgbe_i2c_disable_interrupts(pdata);
 265         axgbe_i2c_disable(pdata);
 266         ret = -ETIMEDOUT;
 267         goto unlock;
 268
 269 success:
 270         ret = state->ret;
 271         if (ret) {
 272                 if (state->tx_abort_source & IC_TX_ABRT_7B_ADDR_NOACK)
 273                         ret = -ENOTCONN;
 274                 else if (state->tx_abort_source & IC_TX_ABRT_ARB_LOST)
 275                         ret = -EAGAIN;
 276         }
 277
 278 unlock:
 279         pthread_mutex_unlock(&pdata->i2c_mutex);
 280         return ret;
 281 }
 282
 283 static void axgbe_i2c_stop(struct axgbe_port *pdata)
 284 {
 285         if (!pdata->i2c.started)
 286                 return;
 287
 288         pdata->i2c.started = 0;
 289         axgbe_i2c_disable_interrupts(pdata);
 290         axgbe_i2c_disable(pdata);
 291         axgbe_i2c_clear_all_interrupts(pdata);
 292 }
 293
 294 static int axgbe_i2c_start(struct axgbe_port *pdata)
 295 {
 296         if (pdata->i2c.started)
 297                 return 0;
 298
 299         pdata->i2c.started = 1;
 300
 301         return 0;
 302 }
 303
 304 static int axgbe_i2c_init(struct axgbe_port *pdata)
 305 {
 306         int ret;
 307
 308         axgbe_i2c_disable_interrupts(pdata);
 309
 310         ret = axgbe_i2c_disable(pdata);
 311         if (ret) {
 312                 PMD_DRV_LOG(ERR, "failed to disable i2c master\n");
 313                 return ret;
 314         }
 315
 316         axgbe_i2c_get_features(pdata);
 317
 318         axgbe_i2c_set_mode(pdata);
 319
 320         axgbe_i2c_clear_all_interrupts(pdata);
 321
 322         return 0;
 323 }
 324
 325 void axgbe_init_function_ptrs_i2c(struct axgbe_i2c_if *i2c_if)
 326 {
 327         i2c_if->i2c_init                = axgbe_i2c_init;
 328         i2c_if->i2c_start               = axgbe_i2c_start;
 329         i2c_if->i2c_stop                = axgbe_i2c_stop;
 330         i2c_if->i2c_xfer                = axgbe_i2c_xfer;
 331 }