Google Git
Sign in
apache / nuttx / refs/heads/cmake / . / arch / xtensa / src / esp32 / esp32_i2c.c
blob: 0a8313f9d19944122a559acd4c8930014f34aae7 [file] [log] [blame]
/****************************************************************************
* arch/xtensa/src/esp32/esp32_i2c.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#ifdef CONFIG_ESP32_I2C
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <time.h>
#include <sys/time.h>
#include <nuttx/arch.h>
#include <nuttx/irq.h>
#include <nuttx/clock.h>
#include <nuttx/mutex.h>
#include <nuttx/semaphore.h>
#include <nuttx/i2c/i2c_master.h>
#include <arch/board/board.h>
#include "esp32_i2c.h"
#include "esp32_gpio.h"
#include "esp32_irq.h"
#include "xtensa.h"
#include "hardware/esp32_gpio_sigmap.h"
#include "hardware/esp32_dport.h"
#include "hardware/esp32_i2c.h"
#include "hardware/esp32_soc.h"
/****************************************************************************
* Private Functions
****************************************************************************/
/* Command format */
#define I2C_BASE_CMD(_cmd, _check_ack) (((_cmd) << 11) + \
((_check_ack) << 8))
#define I2C_SEND_CMD(_cmd, _check_ack, _bytes) (((_cmd) << 11) + \
((_check_ack) << 8) + \
(_bytes))
#define I2C_RECV_CMD(_cmd, _ack_val, _bytes) (((_cmd) << 11) + \
((_ack_val) << 10) + \
(_bytes))
/* Helper */
#ifdef CONFIG_I2C_POLLED
#define TIMESPEC_TO_US(sec, nano) ((sec * USEC_PER_SEC) + (nano / NSEC_PER_USEC))
#endif
#define ESP32_I2CTIMEOTICKS \
(SEC2TICK(CONFIG_ESP32_I2CTIMEOSEC) + MSEC2TICK(CONFIG_ESP32_I2CTIMEOMS))
/* Default option */
#define I2C_FIFO_SIZE (32)
#define I2C_FILTER_CYC_NUM_DEF (7)
#define I2C_CLK_FREQ_DEF (100 * 1000)
#define I2C_INT_ERR_EN_BITS (I2C_ACK_ERR_INT_ENA | \
I2C_TIME_OUT_INT_ENA | \
I2C_ARBITRATION_LOST_INT_ENA | \
I2C_RXFIFO_OVF_INT_ENA)
#define I2C_SCL_CYC_NUM_DEF 9
/* I2C event trace logic.
* NOTE: trace uses the internal, non-standard, low-level debug interface
* syslog() but does not require that any other debug is enabled.
*/
#ifndef CONFIG_I2C_TRACE
# define esp32_i2c_tracereset(p)
# define esp32_i2c_tracenew(p,s)
# define esp32_i2c_traceevent(p,e,a,s)
# define esp32_i2c_tracedump(p)
#endif
#ifndef CONFIG_I2C_NTRACE
# define CONFIG_I2C_NTRACE 32
#endif
/* I2C state */
enum esp32_i2cstate_e
{
I2CSTATE_IDLE = 0,
I2CSTATE_PROC,
I2CSTATE_STOP,
#ifndef CONFIG_I2C_POLLED
I2CSTATE_FINISH
#endif
};
/* I2C hardware command */
enum i2c_opmode_e
{
I2C_CMD_RESTART = 0, /* I2C restart command */
I2C_CMD_WRITE, /* I2C write command */
I2C_CMD_READ, /* I2C read command */
I2C_CMD_STOP, /* I2C stop command */
I2C_CMD_END /* I2C end command */
};
#ifdef CONFIG_I2C_TRACE
/* Trace events */
enum esp32_trace_e
{
I2CEVENT_NONE = 0, /* No events have occurred with this status */
I2CEVENT_SENDADDR, /* Start/Master bit set and address sent, param = addr */
I2CEVENT_SENDBYTE, /* Send byte, param = bytes */
I2CEVENT_RCVMODEEN, /* Receive mode enabled, param = 0 */
I2CEVENT_RCVBYTE, /* Read more dta, param = bytes */
I2CEVENT_STOP, /* Last byte sten, send stop, param = length */
I2CEVENT_ERROR /* Error occurred, param = 0 */
};
/* Trace data */
struct esp32_trace_s
{
uint32_t status; /* I2C 32-bit SR status */
uint32_t count; /* Interrupt count when status change */
enum esp32_i2cstate_e event; /* Last event that occurred with this status */
uint32_t parm; /* Parameter associated with the event */
clock_t time; /* First of event or first status */
};
#endif /* CONFIG_I2C_TRACE */
/* I2C Device hardware configuration */
struct esp32_i2c_config_s
{
uint32_t reg_base; /* I2C register base address */
uint32_t clk_freq; /* Clock frequency */
uint8_t scl_pin; /* GPIO configuration for SCL as SCL */
uint8_t sda_pin; /* GPIO configuration for SDA as SDA */
#ifndef CONFIG_I2C_POLLED
uint8_t periph; /* Peripheral ID */
uint8_t irq; /* Interrupt ID */
#endif
uint32_t clk_bit; /* Clock enable bit */
uint32_t rst_bit; /* I2C reset bit */
uint32_t scl_insig; /* I2C SCL input signal index */
uint32_t scl_outsig; /* I2C SCL output signal index */
uint32_t sda_insig; /* I2C SDA input signal index */
uint32_t sda_outsig; /* I2C SDA output signal index */
};
/* I2C Device Private Data */
struct esp32_i2c_priv_s
{
const struct i2c_ops_s *ops; /* Standard I2C operations */
/* Port configuration */
const struct esp32_i2c_config_s *config;
int refs; /* Reference count */
mutex_t lock; /* Mutual exclusion mutex */
#ifndef CONFIG_I2C_POLLED
sem_t sem_isr; /* Interrupt wait semaphore */
int cpuint; /* CPU interrupt assigned to this I2C */
uint8_t cpu; /* CPU ID */
#endif
/* I2C work state (see enum esp32_i2cstate_e) */
volatile enum esp32_i2cstate_e i2cstate;
struct i2c_msg_s *msgv; /* Message list */
uint8_t msgid; /* Current message ID */
ssize_t bytes; /* Processed data bytes */
uint32_t error; /* I2C transform error */
bool ready_read; /* If I2C has read data */
uint32_t clk_freq; /* Current I2C Clock frequency */
/* I2C trace support */
#ifdef CONFIG_I2C_TRACE
int tndx; /* Trace array index */
clock_t start_time; /* Time when the trace was started */
/* The actual trace data */
struct esp32_trace_s trace[CONFIG_I2C_NTRACE];
#endif
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static void esp32_i2c_init_clock(struct esp32_i2c_priv_s *priv,
uint32_t clock);
static void esp32_i2c_init(struct esp32_i2c_priv_s *priv);
static void esp32_i2c_deinit(struct esp32_i2c_priv_s *priv);
static int esp32_i2c_transfer(struct i2c_master_s *dev,
struct i2c_msg_s *msgs,
int count);
static inline void esp32_i2c_process(struct esp32_i2c_priv_s *priv,
uint32_t status);
#ifdef CONFIG_I2C_POLLED
static int esp32_i2c_polling_waitdone(struct esp32_i2c_priv_s *priv);
#endif
#ifdef CONFIG_I2C_RESET
static int esp32_i2c_reset(struct i2c_master_s *dev);
#endif
#ifdef CONFIG_I2C_TRACE
static void esp32_i2c_tracereset(struct esp32_i2c_priv_s *priv);
static void esp32_i2c_tracenew(struct esp32_i2c_priv_s *priv,
uint32_t status);
static void esp32_i2c_traceevent(struct esp32_i2c_priv_s *priv,
enum esp32_trace_e event,
uint32_t parm,
uint32_t status);
static void esp32_i2c_tracedump(struct esp32_i2c_priv_s *priv);
#endif /* CONFIG_I2C_TRACE */
/****************************************************************************
* Private Data
****************************************************************************/
/* I2C interface */
static const struct i2c_ops_s esp32_i2c_ops =
{
.transfer = esp32_i2c_transfer
#ifdef CONFIG_I2C_RESET
, .reset = esp32_i2c_reset
#endif
};
/* I2C device structures */
#ifdef CONFIG_ESP32_I2C0
static const struct esp32_i2c_config_s esp32_i2c0_config =
{
.reg_base = REG_I2C_BASE(0),
.clk_freq = I2C_CLK_FREQ_DEF,
.scl_pin = CONFIG_ESP32_I2C0_SCLPIN,
.sda_pin = CONFIG_ESP32_I2C0_SDAPIN,
#ifndef CONFIG_I2C_POLLED
.periph = ESP32_PERIPH_I2C_EXT0,
.irq = ESP32_IRQ_I2C_EXT0,
#endif
.clk_bit = DPORT_I2C_EXT0_CLK_EN,
.rst_bit = DPORT_I2C_EXT0_RST,
.scl_insig = I2CEXT0_SCL_IN_IDX,
.scl_outsig = I2CEXT0_SCL_OUT_IDX,
.sda_insig = I2CEXT0_SDA_IN_IDX,
.sda_outsig = I2CEXT0_SDA_OUT_IDX
};
static struct esp32_i2c_priv_s esp32_i2c0_priv =
{
.ops = &esp32_i2c_ops,
.config = &esp32_i2c0_config,
.refs = 0,
.lock = NXMUTEX_INITIALIZER,
#ifndef CONFIG_I2C_POLLED
.sem_isr = SEM_INITIALIZER(0),
#endif
.i2cstate = I2CSTATE_IDLE,
.msgv = NULL,
.msgid = 0,
.bytes = 0,
.ready_read = 0
};
#endif /* CONFIG_ESP32_I2C1 */
#ifdef CONFIG_ESP32_I2C1
static const struct esp32_i2c_config_s esp32_i2c1_config =
{
.reg_base = REG_I2C_BASE(1),
.clk_freq = I2C_CLK_FREQ_DEF,
.scl_pin = CONFIG_ESP32_I2C1_SCLPIN,
.sda_pin = CONFIG_ESP32_I2C1_SDAPIN,
#ifndef CONFIG_I2C_POLLED
.periph = ESP32_PERIPH_I2C_EXT1,
.irq = ESP32_IRQ_I2C_EXT1,
#endif
.clk_bit = DPORT_I2C_EXT1_CLK_EN,
.rst_bit = DPORT_I2C_EXT1_RST,
.scl_insig = I2CEXT1_SCL_IN_IDX,
.scl_outsig = I2CEXT1_SCL_OUT_IDX,
.sda_insig = I2CEXT1_SDA_IN_IDX,
.sda_outsig = I2CEXT1_SDA_OUT_IDX
};
static struct esp32_i2c_priv_s esp32_i2c1_priv =
{
.ops = &esp32_i2c_ops,
.config = &esp32_i2c1_config,
.refs = 0,
.lock = NXMUTEX_INITIALIZER,
#ifndef CONFIG_I2C_POLLED
.sem_isr = SEM_INITIALIZER(0),
#endif
.i2cstate = I2CSTATE_IDLE,
.msgv = NULL,
.msgid = 0,
.bytes = 0,
.ready_read = 0
};
#endif /* CONFIG_ESP32_I2C1 */
/* Trace events strings */
#ifdef CONFIG_I2C_TRACE
static const char *g_trace_names[] =
{
"NONE ",
"SENDADDR ",
"SENDBYTE ",
"RCVMODEEN ",
"RCVBYTE ",
"STOP ",
"ERROR "
};
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: esp32_i2c_set_reg
****************************************************************************/
static inline void esp32_i2c_set_reg(struct esp32_i2c_priv_s *priv,
int offset,
uint32_t value)
{
putreg32(value, priv->config->reg_base + offset);
}
/****************************************************************************
* Name: esp32_i2c_get_reg
****************************************************************************/
static inline uint32_t esp32_i2c_get_reg(struct esp32_i2c_priv_s *priv,
int offset)
{
return getreg32(priv->config->reg_base + offset);
}
/****************************************************************************
* Name: esp32_i2c_set_reg_bits
****************************************************************************/
static inline void esp32_i2c_set_reg_bits(struct esp32_i2c_priv_s *priv,
int offset,
uint32_t bits)
{
uint32_t tmp = getreg32(priv->config->reg_base + offset);
putreg32(tmp | bits, priv->config->reg_base + offset);
}
/****************************************************************************
* Name: esp32_i2c_reset_reg_bits
****************************************************************************/
static inline void esp32_i2c_reset_reg_bits(struct esp32_i2c_priv_s *priv,
int offset,
uint32_t bits)
{
uint32_t tmp = getreg32(priv->config->reg_base + offset);
putreg32(tmp & (~bits), priv->config->reg_base + offset);
}
/****************************************************************************
* Name: esp32_i2c_reset_fifo
*
* Description:
* Reset I2C RX and TX hardware FiFO
*
****************************************************************************/
static void esp32_i2c_reset_fifo(struct esp32_i2c_priv_s *priv)
{
esp32_i2c_set_reg_bits(priv, I2C_FIFO_CONF_OFFSET, I2C_TX_FIFO_RST);
esp32_i2c_reset_reg_bits(priv, I2C_FIFO_CONF_OFFSET, I2C_TX_FIFO_RST);
esp32_i2c_set_reg_bits(priv, I2C_FIFO_CONF_OFFSET, I2C_RX_FIFO_RST);
esp32_i2c_reset_reg_bits(priv, I2C_FIFO_CONF_OFFSET, I2C_RX_FIFO_RST);
}
/****************************************************************************
* Name: esp32_i2c_sendstart
*
* Description:
* Send I2C start signal
*
****************************************************************************/
static void esp32_i2c_sendstart(struct esp32_i2c_priv_s *priv)
{
struct i2c_msg_s *msg = &priv->msgv[priv->msgid];
/* Load a start cmd, write and end in controller. */
esp32_i2c_set_reg(priv, I2C_COMD0_OFFSET,
I2C_BASE_CMD(I2C_CMD_RESTART, 0));
esp32_i2c_set_reg(priv, I2C_COMD1_OFFSET,
I2C_SEND_CMD(I2C_CMD_WRITE, 1, 1));
esp32_i2c_set_reg(priv, I2C_COMD2_OFFSET,
I2C_BASE_CMD(I2C_CMD_END, 0));
/* Load the slave address and the flags to the FIFO. */
esp32_i2c_set_reg(priv, I2C_DATA_OFFSET, (msg->addr << 1) |
(msg->flags & I2C_M_READ));
/* Enable interrupts to detect the execution of an end cmd and
* multiple errors.
*/
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, I2C_END_DETECT_INT_ENA |
I2C_INT_ERR_EN_BITS);
/* Start sending the slave address and hold line. */
esp32_i2c_set_reg_bits(priv, I2C_CTR_OFFSET, I2C_TRANS_START_M);
}
/****************************************************************************
* Name: esp32_i2c_senddata
*
* Description:
* Send I2C data
*
****************************************************************************/
static void esp32_i2c_senddata(struct esp32_i2c_priv_s *priv)
{
int i;
struct i2c_msg_s *msg = &priv->msgv[priv->msgid];
int n = msg->length - priv->bytes;
n = n < I2C_FIFO_SIZE ? n : I2C_FIFO_SIZE;
/* Load a write operation */
esp32_i2c_set_reg(priv, I2C_COMD0_OFFSET,
I2C_SEND_CMD(I2C_CMD_WRITE, 1, n));
esp32_i2c_set_reg(priv, I2C_COMD1_OFFSET,
I2C_BASE_CMD(I2C_CMD_END, 0));
/* Transfer the data from the msg buffer to the TX FIFO */
for (i = 0; i < n; i++)
{
esp32_i2c_set_reg(priv, I2C_DATA_OFFSET,
msg->buffer[priv->bytes + i]);
}
priv->bytes += n;
/* Enable interrupts to detect the execution of an end cmd and
* multiple errors.
*/
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, I2C_END_DETECT_INT_ENA |
I2C_INT_ERR_EN_BITS);
esp32_i2c_set_reg_bits(priv, I2C_CTR_OFFSET, I2C_TRANS_START_M);
}
/****************************************************************************
* Name: esp32_i2c_recvdata
*
* Description:
* Transfer the received data from the RX FIFO to the message buffer.
*
****************************************************************************/
static void esp32_i2c_recvdata(struct esp32_i2c_priv_s *priv)
{
int i;
struct i2c_msg_s *msg = &priv->msgv[priv->msgid];
uint32_t cmd = esp32_i2c_get_reg(priv, I2C_COMD0_OFFSET);
uint8_t n = cmd & 0xff;
for (i = 0; i < n; i++)
{
msg->buffer[priv->bytes + i] = esp32_i2c_get_reg(priv,
I2C_DATA_OFFSET);
}
priv->bytes += n;
}
/****************************************************************************
* Name: esp32_i2c_startrecv
*
* Description:
* Configure I2C to prepare receiving data and it will enable an interrupt
* to detect the end of the receiving operation and to load the content
* into the RX buffer.
*
****************************************************************************/
static void esp32_i2c_startrecv(struct esp32_i2c_priv_s *priv)
{
int ack_value;
struct i2c_msg_s *msg = &priv->msgv[priv->msgid];
int n = msg->length - priv->bytes;
if (n > 1)
{
n -= 1;
n = n < I2C_FIFO_SIZE ? n : I2C_FIFO_SIZE;
ack_value = 0;
}
else
{
ack_value = 1;
}
/* Load read and end cmds */
esp32_i2c_set_reg(priv, I2C_COMD0_OFFSET,
I2C_RECV_CMD(I2C_CMD_READ, ack_value, n));
esp32_i2c_set_reg(priv, I2C_COMD1_OFFSET,
I2C_BASE_CMD(I2C_CMD_END, 0));
/* Enable interrupts to detect the execution of an end cmd and
* multiple errors.
*/
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, I2C_END_DETECT_INT_ENA |
I2C_INT_ERR_EN_BITS);
esp32_i2c_set_reg_bits(priv, I2C_CTR_OFFSET, I2C_TRANS_START_M);
}
/****************************************************************************
* Name: esp32_i2c_sendstop
*
* Description:
* Send I2C STOP signal
*
****************************************************************************/
static void esp32_i2c_sendstop(struct esp32_i2c_priv_s *priv)
{
/* Load a stop cmd and enable the interrupts that indicate end of a stop
* cmd or error.
*/
esp32_i2c_set_reg(priv, I2C_COMD0_OFFSET, I2C_BASE_CMD(I2C_CMD_STOP, 0));
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, I2C_TRANS_COMPLETE_INT_ENA |
I2C_INT_ERR_EN_BITS);
esp32_i2c_set_reg_bits(priv, I2C_CTR_OFFSET, I2C_TRANS_START_M);
}
/****************************************************************************
* Name: esp32_i2c_init_clock
*
* Description:
* Initialize I2C hardware clock
*
****************************************************************************/
static void esp32_i2c_init_clock(struct esp32_i2c_priv_s *priv,
uint32_t clk_freq)
{
uint32_t half_cycles = APB_CLK_FREQ / clk_freq / 2;
uint32_t timeout_cycles = half_cycles * 20;
if (clk_freq == priv->clk_freq)
{
return ;
}
esp32_i2c_set_reg(priv, I2C_SCL_LOW_PERIOD_OFFSET, half_cycles);
esp32_i2c_set_reg(priv, I2C_SCL_HIGH_PERIOD_OFFSET, half_cycles);
esp32_i2c_set_reg(priv, I2C_SDA_HOLD_OFFSET, half_cycles / 2);
esp32_i2c_set_reg(priv, I2C_SDA_SAMPLE_OFFSET, half_cycles / 2);
esp32_i2c_set_reg(priv, I2C_SCL_RSTART_SETUP_OFFSET, half_cycles);
esp32_i2c_set_reg(priv, I2C_SCL_STOP_SETUP_OFFSET, half_cycles);
esp32_i2c_set_reg(priv, I2C_SCL_START_HOLD_OFFSET, half_cycles);
esp32_i2c_set_reg(priv, I2C_SCL_STOP_HOLD_OFFSET, half_cycles);
esp32_i2c_set_reg(priv, I2C_TO_OFFSET, timeout_cycles);
priv->clk_freq = clk_freq;
}
/****************************************************************************
* Name: esp32_i2c_init
*
* Description:
* Initialize I2C hardware
*
****************************************************************************/
static void esp32_i2c_init(struct esp32_i2c_priv_s *priv)
{
const struct esp32_i2c_config_s *config = priv->config;
esp32_gpiowrite(config->scl_pin, 1);
esp32_gpiowrite(config->sda_pin, 1);
esp32_configgpio(config->scl_pin, INPUT |
OUTPUT |
OPEN_DRAIN |
FUNCTION_3);
esp32_gpio_matrix_out(config->scl_pin, config->scl_outsig, 0, 0);
esp32_gpio_matrix_in(config->scl_pin, config->scl_insig, 0);
esp32_configgpio(config->sda_pin, INPUT |
OUTPUT |
OPEN_DRAIN |
FUNCTION_3);
esp32_gpio_matrix_out(config->sda_pin, config->sda_outsig, 0, 0);
esp32_gpio_matrix_in(config->sda_pin, config->sda_insig, 0);
modifyreg32(DPORT_PERIP_CLK_EN_REG, 0, config->clk_bit);
modifyreg32(DPORT_PERIP_RST_EN_REG, config->rst_bit, 0);
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, 0);
esp32_i2c_set_reg(priv, I2C_INT_CLR_OFFSET, UINT32_MAX);
esp32_i2c_set_reg(priv, I2C_CTR_OFFSET, I2C_MS_MODE |
I2C_SCL_FORCE_OUT |
I2C_SDA_FORCE_OUT);
esp32_i2c_reset_reg_bits(priv, I2C_FIFO_CONF_OFFSET,
I2C_NONFIFO_EN_M);
esp32_i2c_reset_fifo(priv);
esp32_i2c_set_reg(priv, I2C_SCL_FILTER_CFG_OFFSET, I2C_SCL_FILTER_EN_M |
I2C_FILTER_CYC_NUM_DEF);
esp32_i2c_set_reg(priv, I2C_SDA_FILTER_CFG_OFFSET, I2C_SDA_FILTER_EN_M |
I2C_FILTER_CYC_NUM_DEF);
esp32_i2c_init_clock(priv, config->clk_freq);
}
/****************************************************************************
* Name: esp32_i2c_deinit
*
* Description:
* Disable I2C hardware
*
****************************************************************************/
static void esp32_i2c_deinit(struct esp32_i2c_priv_s *priv)
{
const struct esp32_i2c_config_s *config = priv->config;
priv->clk_freq = 0;
modifyreg32(DPORT_PERIP_RST_EN_REG, 0, config->rst_bit);
modifyreg32(DPORT_PERIP_CLK_EN_REG, config->clk_bit, 0);
}
/****************************************************************************
* Name: esp32_i2c_reset_fsmc
*
* Description:
* Reset I2C hardware state machine and registers
*
****************************************************************************/
static void esp32_i2c_reset_fsmc(struct esp32_i2c_priv_s *priv)
{
esp32_i2c_deinit(priv);
esp32_i2c_init(priv);
}
/****************************************************************************
* Name: esp32_i2c_sem_waitdone
*
* Description:
* Wait for a transfer to complete using an interruptible semaphore which
* in unlocked from within the ISR context. This function is only used in
* interrupt driven mode.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
****************************************************************************/
#ifndef CONFIG_I2C_POLLED
static int esp32_i2c_sem_waitdone(struct esp32_i2c_priv_s *priv)
{
/* Wait on ISR semaphore */
return nxsem_tickwait_uninterruptible(&priv->sem_isr, ESP32_I2CTIMEOTICKS);
}
#endif
/****************************************************************************
* Name: esp32_i2c_polling_waitdone
*
* Description:
* Wait for a transfer to complete by polling status interrupt registers,
* which indicates the status of the I2C operations. This function is only
* used in polling driven mode.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
*
* Returned Values:
* Zero (OK) is returned on successfull transfer. -ETIMEDOUT is returned
* in case a transfer didn't finish within the timeout interval. And ERROR
* is returned in case of any I2C error during the transfer has happened.
*
****************************************************************************/
#ifdef CONFIG_I2C_POLLED
static int esp32_i2c_polling_waitdone(struct esp32_i2c_priv_s *priv)
{
int ret;
clock_t current;
clock_t timeout;
uint32_t status = 0;
/* Get the current absolute time and add an offset as timeout.
* Preferable to use monotonic, so in case the time changes,
* the time reference is kept, i.e., current time can't jump
* forward and backwards.
*/
current = clock_systime_ticks();
timeout = current + SEC2TICK(10);
/* Loop while a transfer is in progress
* and an error didn't occur within the timeout
*/
while ((current < timeout) && (priv->error == 0))
{
/* Check if any interrupt triggered, clear them
* process the operation.
*/
status = esp32_i2c_get_reg(priv, I2C_INT_STATUS_OFFSET);
if (status != 0)
{
/* Check if the stop operation ended. Don't use
* I2CSTATE_FINISH, because it is set before the stop
* signal really ends. This works for interrupts because
* the i2c_state is checked in the next interrupt when
* stop signal has concluded. This is not the case of
* polling.
*/
if (status & I2C_TRANS_COMPLETE_INT_ST_M)
{
esp32_i2c_set_reg(priv, I2C_INT_CLR_OFFSET, status);
break;
}
esp32_i2c_set_reg(priv, I2C_INT_CLR_OFFSET, status);
esp32_i2c_process(priv, status);
}
/* Update current time */
current = clock_systime_ticks();
}
/* Return a negated value in case of timeout, and in the other scenarios
* return a positive value.
* The transfer function will check the status of priv to check the other
* scenarios.
*/
if (current >= timeout)
{
ret = -ETIMEDOUT;
}
else if (priv->error)
{
ret = ERROR;
}
else
{
ret = OK;
}
/* Disable all interrupts */
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, 0);
return ret;
}
#endif
/****************************************************************************
* Device Driver Operations
****************************************************************************/
/****************************************************************************
* Name: esp32_i2c_transfer
*
* Description:
* Generic I2C transfer function
*
****************************************************************************/
static int esp32_i2c_transfer(struct i2c_master_s *dev,
struct i2c_msg_s *msgs,
int count)
{
int i;
int ret = OK;
struct esp32_i2c_priv_s *priv = (struct esp32_i2c_priv_s *)dev;
DEBUGASSERT(count > 0);
ret = nxmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* If previous state is different than idle,
* reset the fsmc to the idle state.
*/
if (priv->i2cstate != I2CSTATE_IDLE)
{
esp32_i2c_reset_fsmc(priv);
priv->i2cstate = I2CSTATE_IDLE;
}
/* Transfer the messages to the internal struct
* and loop count times to make all transfers.
*/
priv->msgv = msgs;
for (i = 0; i < count; i++)
{
/* Clear TX and RX FIFOs. */
esp32_i2c_reset_fifo(priv);
priv->bytes = 0;
priv->msgid = i;
priv->ready_read = 0;
priv->error = 0;
priv->i2cstate = I2CSTATE_PROC;
/* Set the SCLK frequency for the current msg. */
esp32_i2c_init_clock(priv, msgs[i].frequency);
if ((msgs[i].flags & I2C_M_NOSTART) != 0)
{
esp32_i2c_traceevent(priv, I2CEVENT_SENDBYTE, priv->bytes,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
esp32_i2c_senddata(priv);
if (priv->bytes == msgs[i].length)
{
if ((msgs[i].flags & I2C_M_NOSTOP) == 0)
{
priv->i2cstate = I2CSTATE_STOP;
}
#ifndef CONFIG_I2C_POLLED
else
{
priv->i2cstate = I2CSTATE_FINISH;
}
#endif
}
}
else
{
/* Reset I2C trace logic */
esp32_i2c_tracereset(priv);
esp32_i2c_traceevent(priv, I2CEVENT_SENDADDR, msgs[i].addr,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
/* Send the start cmd */
esp32_i2c_sendstart(priv);
}
#ifndef CONFIG_I2C_POLLED
if (esp32_i2c_sem_waitdone(priv) < 0)
{
/* Timed out - transfer was not completed within the timeout */
ret = -ETIMEDOUT;
break;
}
else
{
if (priv->error)
{
/* An error occurred */
ret = -EIO;
break;
}
else
{
/* Successful transfer, update the I2C state to idle */
priv->i2cstate = I2CSTATE_IDLE;
ret = OK;
}
}
#else
ret = esp32_i2c_polling_waitdone(priv);
if (ret < 0)
{
if (ret == -ETIMEDOUT)
{
break;
}
else
{
ret = -EIO;
break;
}
}
else
{
/* Successful transfer, update the I2C state to idle */
priv->i2cstate = I2CSTATE_IDLE;
ret = OK;
}
#endif
}
/* Dump the trace result */
esp32_i2c_tracedump(priv);
nxmutex_unlock(&priv->lock);
return ret;
}
/****************************************************************************
* Name: esp32_i2c_clear_bus
*
* Description:
* Clear I2C bus, when the slave is stuck in a deadlock and keeps pulling
* the bus low, master can control the SCL bus to generate 9 CLKs.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
*
****************************************************************************/
#ifdef CONFIG_I2C_RESET
static int esp32_i2c_clear_bus(struct esp32_i2c_priv_s *priv)
{
uint32_t clock_count;
uint32_t stretch_count;
int ret;
const struct esp32_i2c_config_s *config = priv->config;
/* Use GPIO configuration to un-wedge the bus */
esp32_configgpio(config->scl_pin, INPUT_PULLUP | OUTPUT_OPEN_DRAIN);
esp32_gpio_matrix_out(config->scl_pin, SIG_GPIO_OUT_IDX, 0, 0);
esp32_configgpio(config->sda_pin, INPUT_PULLUP | OUTPUT_OPEN_DRAIN);
esp32_gpio_matrix_out(config->sda_pin, SIG_GPIO_OUT_IDX, 0, 0);
/* Set SDA to high */
esp32_gpiowrite(config->sda_pin, 1);
/* Clock the bus until any slaves currently driving it let it go. */
clock_count = 0;
while (!esp32_gpioread(config->sda_pin))
{
/* Give up if we have tried too hard */
if (clock_count++ >= I2C_SCL_CYC_NUM_DEF)
{
ret = -EIO;
goto out;
}
/* Sniff to make sure that clock stretching has finished.
*
* If the bus never relaxes, the reset has failed.
*/
stretch_count = 0;
while (!esp32_gpioread(config->scl_pin))
{
/* Give up if we have tried too hard */
if (stretch_count++ > 10)
{
ret = -EIO;
goto out;
}
up_udelay(10);
}
/* Drive SCL low */
esp32_gpiowrite(config->scl_pin, 0);
up_udelay(10);
/* Drive SCL high again */
esp32_gpiowrite(config->scl_pin, 1);
up_udelay(10);
}
/* Generate a start followed by a stop to reset slave
* state machines.
*/
esp32_gpiowrite(config->sda_pin, 0);
up_udelay(10);
esp32_gpiowrite(config->scl_pin, 0);
up_udelay(10);
esp32_gpiowrite(config->scl_pin, 1);
up_udelay(10);
esp32_gpiowrite(config->sda_pin, 1);
up_udelay(10);
ret = OK;
out:
return ret;
}
#endif
/****************************************************************************
* Name: esp32_i2c_reset
*
* Description:
* Perform an I2C bus reset in an attempt to break loose stuck I2C devices.
*
* Input Parameters:
* dev - Device-specific state data
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
****************************************************************************/
#ifdef CONFIG_I2C_RESET
static int esp32_i2c_reset(struct i2c_master_s *dev)
{
struct esp32_i2c_priv_s *priv = (struct esp32_i2c_priv_s *)dev;
DEBUGASSERT(dev);
DEBUGASSERT(priv->refs > 0);
nxmutex_lock(&priv->lock);
esp32_i2c_deinit(priv);
esp32_i2c_clear_bus(priv);
esp32_i2c_init(priv);
priv->i2cstate = I2CSTATE_IDLE;
priv->msgid = 0;
priv->bytes = 0;
priv->ready_read = 0;
nxmutex_unlock(&priv->lock);
return OK;
}
#endif
/****************************************************************************
* Name: esp32_i2c_traceclear
*
* Description:
* Set I2C trace fields to default value.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
*
****************************************************************************/
#ifdef CONFIG_I2C_TRACE
static void esp32_i2c_traceclear(struct esp32_i2c_priv_s *priv)
{
struct esp32_trace_s *trace = &priv->trace[priv->tndx];
trace->status = 0;
trace->count = 0;
trace->event = I2CEVENT_NONE;
trace->parm = 0;
trace->time = 0;
}
#endif /* CONFIG_I2C_TRACE */
/****************************************************************************
* Name: esp32_i2c_tracereset
*
* Description:
* Reset the trace info for a new data collection.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
*
****************************************************************************/
#ifdef CONFIG_I2C_TRACE
static void esp32_i2c_tracereset(struct esp32_i2c_priv_s *priv)
{
priv->tndx = 0;
priv->start_time = clock_systime_ticks();
esp32_i2c_traceclear(priv);
}
#endif /* CONFIG_I2C_TRACE */
/****************************************************************************
* Name: esp32_i2c_tracenew
*
* Description:
* Create a new trace entry.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
* status - Current value of I2C status register.
*
****************************************************************************/
#ifdef CONFIG_I2C_TRACE
static void esp32_i2c_tracenew(struct esp32_i2c_priv_s *priv,
uint32_t status)
{
struct esp32_trace_s *trace = &priv->trace[priv->tndx];
/* Check if the current entry is already initialized or if its status had
* already changed
*/
if (trace->count == 0 || status != trace->status)
{
/* Check whether the status changed */
if (trace->count != 0)
{
/* Bump up the trace index (unless we are out of trace entries) */
if (priv->tndx >= (CONFIG_I2C_NTRACE - 1))
{
i2cerr("ERROR: Trace table overflow\n");
return;
}
priv->tndx++;
trace = &priv->trace[priv->tndx];
}
/* Initialize the new trace entry */
esp32_i2c_traceclear(priv);
trace->status = status;
trace->count = 1;
trace->time = clock_systime_ticks();
}
else
{
/* Just increment the count of times that we have seen this status */
trace->count++;
}
}
#endif /* CONFIG_I2C_TRACE */
/****************************************************************************
* Name: esp32_i2c_traceevent
*
* Description:
* Record a new trace event.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
* event - Event to be recorded on the trace.
* parm - Parameter associated with the event.
* status - Current value of I2C status register.
*
****************************************************************************/
#ifdef CONFIG_I2C_TRACE
static void esp32_i2c_traceevent(struct esp32_i2c_priv_s *priv,
enum esp32_trace_e event,
uint32_t parm,
uint32_t status)
{
/* Check for new trace setup */
esp32_i2c_tracenew(priv, status);
if (event != I2CEVENT_NONE)
{
struct esp32_trace_s *trace = &priv->trace[priv->tndx];
/* Initialize the new trace entry */
trace->event = event;
trace->parm = parm;
/* Bump up the trace index (unless we are out of trace entries) */
if (priv->tndx >= (CONFIG_I2C_NTRACE - 1))
{
i2cerr("ERROR: Trace table overflow\n");
return;
}
priv->tndx++;
esp32_i2c_traceclear(priv);
}
}
#endif /* CONFIG_I2C_TRACE */
/****************************************************************************
* Name: esp32_i2c_tracedump
*
* Description:
* Dump the trace results.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
*
****************************************************************************/
#ifdef CONFIG_I2C_TRACE
static void esp32_i2c_tracedump(struct esp32_i2c_priv_s *priv)
{
struct esp32_trace_s *trace;
int i;
syslog(LOG_DEBUG, "Elapsed time: %" PRIu32 "\n",
(clock_systime_ticks() - priv->start_time));
for (i = 0; i < priv->tndx; i++)
{
trace = &priv->trace[i];
syslog(LOG_DEBUG,
"%2d. STATUS: %08" PRIx32 " COUNT: %3" PRIu32 " EVENT: %s(%2d)"
" PARM: %08" PRIx32 " TIME: %" PRIu32 "\n",
i + 1, trace->status, trace->count, g_trace_names[trace->event],
trace->event, trace->parm, trace->time - priv->start_time);
}
}
#endif /* CONFIG_I2C_TRACE */
/****************************************************************************
* Name: esp32_i2c_irq
*
* Description:
* This is the common I2C interrupt handler. It will be invoked
* when an interrupt received on the device.
*
****************************************************************************/
#ifndef CONFIG_I2C_POLLED
static int esp32_i2c_irq(int cpuint, void *context, void *arg)
{
struct esp32_i2c_priv_s *priv = (struct esp32_i2c_priv_s *)arg;
/* Get the interrupt status and clear the interrupts that
* triggered.
*/
uint32_t status = esp32_i2c_get_reg(priv, I2C_INT_STATUS_OFFSET);
esp32_i2c_set_reg(priv, I2C_INT_CLR_OFFSET, status);
esp32_i2c_process(priv, status);
return OK;
}
#endif
/****************************************************************************
* Name: esp32_i2c_process
*
* Description:
* This routine manages the transfer. It's called after some specific
* commands from the I2C controller are executed or in case of errors.
* It's responsible for writing/reading operations and transferring data
* from/to FIFO.
* It's called in the interrupt and polled driven mode.
*
* Parameters:
* priv - Pointer to the internal driver state structure.
* status - The current interrupt status register.
*
****************************************************************************/
static inline void esp32_i2c_process(struct esp32_i2c_priv_s *priv,
uint32_t status)
{
struct i2c_msg_s *msg = &priv->msgv[priv->msgid];
/* Check for any errors */
if (I2C_INT_ERR_EN_BITS & status)
{
/* Save the errors, register the error event, disable interrupts
* and release the semaphore to conclude the transfer.
*/
priv->error = status & I2C_INT_ERR_EN_BITS;
esp32_i2c_traceevent(priv, I2CEVENT_ERROR, priv->error,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, 0);
#ifndef CONFIG_I2C_POLLED
nxsem_post(&priv->sem_isr);
#endif
}
else /* If no error */
{
/* If a transfer has just initialized */
if (priv->i2cstate == I2CSTATE_PROC)
{
/* Check the flags to perform a read or write operation */
if (msg->flags & I2C_M_READ)
{
/* RX FIFO has available data */
if (priv->ready_read)
{
esp32_i2c_traceevent(priv, I2CEVENT_RCVBYTE, priv->bytes,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
esp32_i2c_recvdata(priv);
priv->ready_read = 0;
}
/* Received all data. Finish the transaction
* and update the state I2C state.
*/
if (priv->bytes == msg->length)
{
esp32_i2c_traceevent(priv, I2CEVENT_STOP, msg->length,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
esp32_i2c_sendstop(priv);
#ifndef CONFIG_I2C_POLLED
priv->i2cstate = I2CSTATE_FINISH;
#endif
}
else /* Start a receive operation */
{
esp32_i2c_traceevent(priv, I2CEVENT_RCVMODEEN, 0,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
esp32_i2c_startrecv(priv);
priv->ready_read = 1;
}
}
else /* Write operation */
{
esp32_i2c_traceevent(priv, I2CEVENT_SENDBYTE, priv->bytes,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
esp32_i2c_senddata(priv);
/* Finally sent the entire message. Update the I2C state to
* send a stop signal in the next interrupt.
*/
if (priv->bytes == msg->length)
{
if ((msg->flags & I2C_M_NOSTOP) == 0)
{
priv->i2cstate = I2CSTATE_STOP;
}
#ifndef CONFIG_I2C_POLLED
else
{
priv->i2cstate = I2CSTATE_FINISH;
}
#endif
}
}
}
else if (priv->i2cstate == I2CSTATE_STOP)
{
/* Transmitted all data. Finish the transaction sending a stop
* and update the state I2C state.
*/
esp32_i2c_traceevent(priv, I2CEVENT_STOP, msg->length,
esp32_i2c_get_reg(priv, I2C_SR_OFFSET));
esp32_i2c_sendstop(priv);
#ifndef CONFIG_I2C_POLLED
priv->i2cstate = I2CSTATE_FINISH;
#endif
}
#ifndef CONFIG_I2C_POLLED
else if (priv->i2cstate == I2CSTATE_FINISH)
{
/* Disable all interrupts and release the semaphore */
esp32_i2c_set_reg(priv, I2C_INT_ENA_OFFSET, 0);
nxsem_post(&priv->sem_isr);
}
#endif
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: esp32_i2cbus_initialize
*
* Description:
* Initialize one I2C bus
*
****************************************************************************/
struct i2c_master_s *esp32_i2cbus_initialize(int port)
{
struct esp32_i2c_priv_s *priv;
#ifndef CONFIG_I2C_POLLED
const struct esp32_i2c_config_s *config;
int ret;
#endif
switch (port)
{
#ifdef CONFIG_ESP32_I2C0
case 0:
priv = &esp32_i2c0_priv;
break;
#endif
#ifdef CONFIG_ESP32_I2C1
case 1:
priv = &esp32_i2c1_priv;
break;
#endif
default:
return NULL;
}
nxmutex_lock(&priv->lock);
if (priv->refs++ != 0)
{
nxmutex_unlock(&priv->lock);
return (struct i2c_master_s *)priv;
}
#ifndef CONFIG_I2C_POLLED
config = priv->config;
/* Set up to receive peripheral interrupts on the current CPU */
priv->cpu = up_cpu_index();
priv->cpuint = esp32_setup_irq(priv->cpu, config->periph,
1, ESP32_CPUINT_LEVEL);
if (priv->cpuint < 0)
{
/* Failed to allocate a CPU interrupt of this type */
priv->refs--;
nxmutex_unlock(&priv->lock);
return NULL;
}
ret = irq_attach(config->irq, esp32_i2c_irq, priv);
if (ret != OK)
{
esp32_teardown_irq(priv->cpu, config->periph, priv->cpuint);
priv->refs--;
nxmutex_unlock(&priv->lock);
return NULL;
}
up_enable_irq(config->irq);
#endif
esp32_i2c_init(priv);
nxmutex_unlock(&priv->lock);
return (struct i2c_master_s *)priv;
}
/****************************************************************************
* Name: esp32_i2cbus_uninitialize
*
* Description:
* Uninitialize an I2C bus
*
****************************************************************************/
int esp32_i2cbus_uninitialize(struct i2c_master_s *dev)
{
struct esp32_i2c_priv_s *priv = (struct esp32_i2c_priv_s *)dev;
DEBUGASSERT(dev);
if (priv->refs == 0)
{
return ERROR;
}
nxmutex_lock(&priv->lock);
if (--priv->refs)
{
nxmutex_unlock(&priv->lock);
return OK;
}
#ifndef CONFIG_I2C_POLLED
up_disable_irq(priv->config->irq);
esp32_teardown_irq(priv->cpu, priv->config->periph, priv->cpuint);
#endif
esp32_i2c_deinit(priv);
nxmutex_unlock(&priv->lock);
return OK;
}
#endif /* CONFIG_ESP32_I2C */