rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/platform/hal/hal_i2c.c
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

2424 lines
74 KiB
C
Raw Blame History

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include "hal_i2c.h"
#include "cmsis_nvic.h"
#include "hal_cmu.h"
#include "hal_dma.h"
#include "hal_i2cip.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "plat_addr_map.h"
#include "plat_types.h"
#include "string.h"
#ifdef RTOS
#include "cmsis_os.h"
#endif
#ifdef I2C_DEBUG
#define HAL_I2C_TRACE(attr, str, ...) TRACE(attr, str, ##__VA_ARGS__)
#define HAL_I2C_ERROR(attr, str, ...) TRACE(attr, str, ##__VA_ARGS__)
#else
#define HAL_I2C_TRACE(attr, str, ...) TRACE_DUMMY(attr, str, ##__VA_ARGS__)
#define HAL_I2C_ERROR(attr, str, ...) TRACE(attr, str, ##__VA_ARGS__)
#endif
#ifdef I2C_SENSOR_ENGINE
#ifndef I2C_USE_DMA
#define I2C_USE_DMA
#endif
#endif
#define HAL_I2C_TX_TL I2CIP_TX_TL_QUARTER
#define HAL_I2C_RX_TL I2CIP_RX_TL_THREE_QUARTER
#define HAL_I2C_DMA_TX_TL I2CIP_TX_TL_HALF
#define HAL_I2C_DMA_RX_TL I2CIP_DMA_TX_TL_1_BYTE
#define HAL_I2C_DMA_TX 1
#define HAL_I2C_DMA_RX 0
#define HAL_I2C_RESTART 1
#define HAL_I2C_NO_RESTART 0
#define HAL_I2C_YES 1
#define HAL_I2C_NO 0
/* state machine */
#ifdef I2C_SM_TASK_NUM
#define HAL_I2C_SM_TASK_NUM_MAX I2C_SM_TASK_NUM
#else
#define HAL_I2C_SM_TASK_NUM_MAX 2
#endif
#ifdef I2C_SM_DMA_BUF_SIZE
#define HAL_I2C_SM_DMA_BUF_LEN_MAX I2C_SM_DMA_BUF_SIZE
#else
#define HAL_I2C_SM_DMA_BUF_LEN_MAX 1024
#endif
/* i2c synchronization timeout ms */
#define HAL_I2C_SYNC_TM_MS (2000)
#define HAL_I2C_DLY_MS (1)
#define HAL_I2C_WAIT_ACT_MS (1000)
#define HAL_I2C_WAIT_TFE_MS (1000)
#define HAL_I2C_WAIT_TFNF_MS (1000)
#define HAL_I2C_WAIT_RFNE_MS (1000)
enum HAL_I2C_SM_STATE_T {
HAL_I2C_SM_CLOSED = 0,
HAL_I2C_SM_IDLE,
HAL_I2C_SM_RUNNING,
};
enum HAL_I2C_SM_TASK_ACTION_T {
HAL_I2C_SM_TASK_ACTION_NONE = 0,
HAL_I2C_SM_TASK_ACTION_M_SEND,
HAL_I2C_SM_TASK_ACTION_M_RECV,
};
enum HAL_I2C_SM_TASK_STATE_T {
HAL_I2C_SM_TASK_STATE_START = (1 << 0),
HAL_I2C_SM_TASK_STATE_STOP = (1 << 1),
HAL_I2C_SM_TASK_STATE_TX_ABRT = (1 << 2),
HAL_I2C_SM_TASK_STATE_ACT = (1 << 3),
HAL_I2C_SM_TASK_STATE_FIFO_ERR = (1 << 4),
};
struct HAL_I2C_SM_TASK_T {
/* send or recv buffer */
const uint8_t *tx_buf;
uint8_t *rx_buf;
uint16_t tx_txn_len;
uint16_t rx_txn_len;
uint16_t txn_cnt;
uint16_t tx_pos;
uint16_t rx_pos;
uint16_t rx_cmd_sent;
/* device control */
uint8_t stop;
uint8_t restart_after_write;
uint16_t target_addr;
/* task control */
uint32_t state;
uint32_t action;
/* system control */
/* TODO : os and non os version */
volatile uint32_t lock;
uint32_t transfer_id;
uint32_t errcode;
HAL_I2C_TRANSFER_HANDLER_T handler;
};
struct HAL_I2C_SM_T {
/* device related */
struct HAL_I2C_CONFIG_T cfg;
enum HAL_I2C_SM_STATE_T state;
/* state machine related */
#if defined(I2C_TASK_MODE) || defined(I2C_SENSOR_ENGINE)
uint8_t in_task;
uint8_t out_task;
uint8_t task_count;
struct HAL_I2C_SM_TASK_T task[HAL_I2C_SM_TASK_NUM_MAX];
/* dma related */
#ifdef I2C_USE_DMA
struct HAL_DMA_CH_CFG_T tx_dma_cfg;
struct HAL_DMA_CH_CFG_T rx_dma_cfg;
/* i2cip cmd_data use 16bit and read action is driven by write action */
/* when use dma to read from i2c, we need to use another dma to write
* cmd/stop/restart */
/* cmd/stop/restart + data use 16bit width, so dma buffer are 2 times of orgin
* data buffer */
uint16_t dma_tx_buf[HAL_I2C_SM_DMA_BUF_LEN_MAX / 2];
#endif
#endif
};
/* state machine end */
struct HAL_I2C_MOD_NAME_T {};
struct HAL_I2C_HW_DESC_T {
uint32_t base;
enum HAL_CMU_MOD_ID_T mod;
enum HAL_CMU_MOD_ID_T apb;
IRQn_Type irq;
#ifdef I2C_USE_DMA
enum HAL_DMA_PERIPH_T rx_periph;
enum HAL_DMA_PERIPH_T tx_periph;
#endif
};
static const struct HAL_I2C_HW_DESC_T i2c_desc[HAL_I2C_ID_NUM] = {
{
.base = I2C0_BASE,
.mod = HAL_CMU_MOD_O_I2C0,
.apb = HAL_CMU_MOD_P_I2C0,
.irq = I2C0_IRQn,
#ifdef I2C_USE_DMA
.rx_periph = HAL_GPDMA_I2C0_RX,
.tx_periph = HAL_GPDMA_I2C0_TX,
#endif
},
#if (CHIP_HAS_I2C > 1)
{
.base = I2C1_BASE,
.mod = HAL_CMU_MOD_O_I2C1,
.apb = HAL_CMU_MOD_P_I2C1,
.irq = I2C1_IRQn,
#ifdef I2C_USE_DMA
.rx_periph = HAL_GPDMA_I2C1_RX,
.tx_periph = HAL_GPDMA_I2C1_TX,
#endif
},
#endif
};
static const char *const invalid_id = "Invalid I2C ID: %d";
static struct HAL_I2C_SM_T hal_i2c_sm[HAL_I2C_ID_NUM];
/* simple mode */
#ifdef I2C_SIMPLE_MODE
static void hal_i2c_simple_proc(enum HAL_I2C_ID_T id);
static HAL_I2C_INT_HANDLER_T hal_i2c_int_handlers[HAL_I2C_ID_NUM] = {NULL};
#endif
/* simple mode end */
#ifdef I2C_SENSOR_ENGINE
static enum HAL_SENSOR_ENGINE_ID_T i2c_sensor_id[HAL_I2C_ID_NUM];
static HAL_I2C_SENSOR_ENG_HANDLER_T i2c_sensor_handler[HAL_I2C_ID_NUM];
#ifdef I2C_SENSOR_ENGINE
static void hal_i2c_sensor_eng_proc(enum HAL_I2C_ID_T id);
#endif
#endif
static uint32_t _i2c_get_base(enum HAL_I2C_ID_T id) {
return i2c_desc[id].base;
}
static void POSSIBLY_UNUSED hal_i2c_delay_ms(int ms) { osDelay(ms); }
static uint32_t _i2c_adjust_period_cnt(uint32_t period_cnt, uint16_t trising_ns,
uint16_t tfalling_ns,
uint16_t pclk_mhz) {
uint32_t old_period_cnt;
uint16_t rising_falling_cycle;
old_period_cnt = period_cnt;
// Round down the rising and falling cycle, so that the period count is
// rounded up, and the SCL freq is always <= the requested freq.
rising_falling_cycle = ((trising_ns + tfalling_ns) * pclk_mhz) / 1000;
if (period_cnt > rising_falling_cycle) {
period_cnt -= rising_falling_cycle;
} else {
period_cnt = 0;
}
HAL_I2C_TRACE(5, "%s: period_cnt=%u->%u trising_ns=%u tfalling_ns=%u",
__FUNCTION__, old_period_cnt, period_cnt, trising_ns,
tfalling_ns);
return period_cnt;
}
static void _i2c_get_clk_cnt(uint32_t period_cnt, uint16_t tlow_ns,
uint16_t thigh_ns, uint16_t spklen,
uint16_t pclk_mhz, uint16_t *plcnt,
uint16_t *phcnt) {
#define IC_SCL_LOW_CYCLE_ADD (1)
// NOTE: H/w spec says that (6 + spklen) cycles is added for SCL high interval,
// but tests show that 1 more cycle is needed
#define IC_SCL_HIGH_CYCLE_ADD (6 + spklen + 1)
#define MIN_IC_SCL_LCNT (7 + spklen + IC_SCL_LOW_CYCLE_ADD)
#define MIN_IC_SCL_HCNT (5 + spklen + IC_SCL_HIGH_CYCLE_ADD)
uint32_t lcnt, hcnt;
uint16_t min_lcnt, min_hcnt;
HAL_I2C_TRACE(
6, "%s: period_cnt=%u tlow_ns=%u thigh_ns=%u spklen=%u pclk_mhz=%u",
__FUNCTION__, period_cnt, tlow_ns, thigh_ns, spklen, pclk_mhz);
min_lcnt = (tlow_ns * pclk_mhz + 1000 - 1) / 1000;
if (min_lcnt < MIN_IC_SCL_LCNT) {
min_lcnt = MIN_IC_SCL_LCNT;
}
min_hcnt = (thigh_ns * pclk_mhz + 1000 - 1) / 1000;
if (min_hcnt < MIN_IC_SCL_HCNT) {
min_hcnt = MIN_IC_SCL_HCNT;
}
if (min_lcnt + min_hcnt > period_cnt) {
HAL_I2C_ERROR(5,
"%s:WARNING: period_cnt=%u too small: min_lcnt=%u "
"min_hcnt=%u pclk_mhz=%u",
__FUNCTION__, period_cnt, min_lcnt, min_hcnt, pclk_mhz);
lcnt = min_lcnt;
hcnt = min_hcnt;
} else {
lcnt = (period_cnt + 1) / 2;
if (min_lcnt >= min_hcnt) {
if (lcnt < min_lcnt) {
lcnt = min_lcnt;
}
hcnt = period_cnt - lcnt;
if (hcnt < min_hcnt) {
hcnt = min_hcnt;
}
} else {
hcnt = lcnt;
if (hcnt < min_hcnt) {
hcnt = min_hcnt;
}
lcnt = period_cnt - hcnt;
if (lcnt < min_lcnt) {
lcnt = min_lcnt;
}
}
}
lcnt -= IC_SCL_LOW_CYCLE_ADD;
hcnt -= IC_SCL_HIGH_CYCLE_ADD;
ASSERT(lcnt <= UINT16_MAX && hcnt <= UINT16_MAX,
"%s: lcnt=%u or hcnt=%u overflow", __FUNCTION__, lcnt, hcnt);
*plcnt = lcnt;
*phcnt = hcnt;
}
static void _i2c_set_speed(enum HAL_I2C_ID_T id, int speed_mode, int speed) {
#define MAX_HS_SPK_NS 10
#define MAX_FSP_SPK_NS 50
#define MAX_FS_SPK_NS 50
#define SS_THOLD_NS 1800 // [300, 3450]
#define FS_THOLD_NS 600 // [300, 900]
#define FSP_THOLD_NS 300 // [ 0, -]
#define HS_100PF_THOLD_NS 30 // [ 0, 70]
#define HS_400PF_THOLD_NS 70 // [ 0, 150]
#define SS_TRISING_NS 300 // [ 0, 1000]
#define FS_TRISING_NS 50 // [ 20, 300]
#define FSP_TRISING_NS 30 // [ 0, 120]
#define HS_100PF_TRISING_NS 30 // [ 10, 40] for SCL, [ 20, 80] for SDA
#define HS_400PF_TRISING_NS 30 // [ 10, 80] for SCL, [ 20, 160] for SDA
#define SS_TFALLING_NS 30 // [ 0, 300]
#define FS_TFALLING_NS 30 // [ 20, 300]
#define FSP_TFALLING_NS 30 // [ 20, 120]
#define HS_100PF_TFALLING_NS 30 // [ 10, 40] for SCL, [ 20, 80] for SDA
#define HS_400PF_TFALLING_NS 30 // [ 10, 80] for SCL, [ 20, 160] for SDA
#define MIN_SS_TLOW_NS 4700
#define MIN_SS_THIGH_NS 4000
#define MIN_FS_TLOW_NS 1300
#define MIN_FS_THIGH_NS 600
#define MIN_FSP_TLOW_NS 500
#define MIN_FSP_THIGH_NS 260
#define MIN_HS_100PF_TLOW_NS 160
#define MIN_HS_100PF_THIGH_NS 60
#define MIN_HS_400PF_TLOW_NS 320
#define MIN_HS_400PF_THIGH_NS 120
// Round down the spike suppression limit value
#define GET_SPKLEN_VAL(s) ((s)*pclk_mhz / 1000)
uint32_t reg_base = _i2c_get_base(id);
uint32_t min_mclk, pclk, period_cnt;
uint16_t lcnt, hcnt, hold_cycle, spklen;
uint16_t tlow_ns, thigh_ns, thold_ns, trising_ns, tfalling_ns;
uint8_t spk_ns;
uint16_t pclk_mhz;
if (speed_mode == IC_SPEED_MODE_MAX) {
min_mclk = speed * 50;
} else {
min_mclk = speed * 40;
}
pclk = 0;
#ifdef PERIPH_PLL_FREQ
if (PERIPH_PLL_FREQ / 2 > 2 * hal_cmu_get_crystal_freq()) {
// Init to OSC_X2
pclk = 2 * hal_cmu_get_crystal_freq();
if (min_mclk > pclk) {
pclk = PERIPH_PLL_FREQ / 2;
hal_cmu_i2c_set_div(2);
} else {
pclk = 0;
}
}
#endif
if (pclk == 0) {
enum HAL_CMU_PERIPH_FREQ_T periph_freq;
// Init to OSC
pclk = hal_cmu_get_crystal_freq();
if (min_mclk > pclk) {
pclk *= 2;
periph_freq = HAL_CMU_PERIPH_FREQ_52M;
} else {
periph_freq = HAL_CMU_PERIPH_FREQ_26M;
}
// NOTE: All I2C controllers share the same module clock configuration
hal_cmu_i2c_set_freq(periph_freq);
}
pclk_mhz = pclk / 1000000;
period_cnt = (pclk + speed - 1) / speed;
switch (speed_mode) {
case IC_SPEED_MODE_MAX:
spk_ns = MAX_HS_SPK_NS;
tlow_ns = MIN_HS_100PF_TLOW_NS;
thigh_ns = MIN_HS_100PF_THIGH_NS;
thold_ns = HS_100PF_THOLD_NS;
trising_ns = HS_100PF_TRISING_NS;
tfalling_ns = HS_100PF_TFALLING_NS;
spklen = GET_SPKLEN_VAL(spk_ns);
if (spklen == 0) {
spklen = 1;
}
i2cip_w_hs_spklen(reg_base, spklen);
period_cnt =
_i2c_adjust_period_cnt(period_cnt, trising_ns, tfalling_ns, pclk_mhz);
_i2c_get_clk_cnt(period_cnt, tlow_ns, thigh_ns, spklen, pclk_mhz, &lcnt,
&hcnt);
i2cip_w_high_speed_hcnt(reg_base, hcnt);
i2cip_w_high_speed_lcnt(reg_base, lcnt);
i2cip_w_speed(reg_base, I2CIP_HIGH_SPEED_MASK);
// Continue to config fast mode
#ifdef I2S_FSP_MODE
period_cnt = (pclk + I2C_FSP_SPEED - 1) / I2C_FSP_SPEED;
#else
period_cnt = (pclk + I2C_FAST_SPEED - 1) / I2C_FAST_SPEED;
#endif
case IC_SPEED_MODE_FAST:
#ifdef I2S_FSP_MODE
if (speed > I2C_FAST_SPEED) {
spk_ns = MAX_FSP_SPK_NS;
tlow_ns = MIN_FSP_TLOW_NS;
thigh_ns = MIN_FSP_THIGH_NS;
thold_ns = FSP_THOLD_NS;
trising_ns = FSP_TRISING_NS;
tfalling_ns = FSP_TFALLING_NS;
} else
#endif
{
spk_ns = MAX_FS_SPK_NS;
tlow_ns = MIN_FS_TLOW_NS;
thigh_ns = MIN_FS_THIGH_NS;
trising_ns = FS_TRISING_NS;
tfalling_ns = FS_TFALLING_NS;
}
spklen = GET_SPKLEN_VAL(spk_ns);
if (spklen == 0) {
spklen = 1;
}
i2cip_w_fs_spklen(reg_base, spklen);
period_cnt =
_i2c_adjust_period_cnt(period_cnt, trising_ns, tfalling_ns, pclk_mhz);
_i2c_get_clk_cnt(period_cnt, tlow_ns, thigh_ns, spklen, pclk_mhz, &lcnt,
&hcnt);
i2cip_w_fast_speed_hcnt(reg_base, hcnt);
i2cip_w_fast_speed_lcnt(reg_base, lcnt);
// Update sda hold time and speed mode if in fast mode
// Skip if in high speed mode
if (speed_mode == IC_SPEED_MODE_FAST) {
thold_ns = FS_THOLD_NS;
i2cip_w_speed(reg_base, I2CIP_FAST_SPEED_MASK);
}
break;
case IC_SPEED_MODE_STANDARD:
default:
spk_ns = MAX_FS_SPK_NS;
tlow_ns = MIN_SS_TLOW_NS;
thigh_ns = MIN_SS_THIGH_NS;
thold_ns = SS_THOLD_NS;
trising_ns = SS_TRISING_NS;
tfalling_ns = SS_TFALLING_NS;
spklen = GET_SPKLEN_VAL(spk_ns);
if (spklen == 0) {
spklen = 1;
}
i2cip_w_fs_spklen(reg_base, spklen);
period_cnt =
_i2c_adjust_period_cnt(period_cnt, trising_ns, tfalling_ns, pclk_mhz);
_i2c_get_clk_cnt(period_cnt, tlow_ns, thigh_ns, spklen, pclk_mhz, &lcnt,
&hcnt);
i2cip_w_standard_speed_hcnt(reg_base, hcnt);
i2cip_w_standard_speed_lcnt(reg_base, lcnt);
i2cip_w_speed(reg_base, I2CIP_STANDARD_SPEED_MASK);
break;
}
// Master mode: min = 1; slave mode: min = (spklen + 7)
hold_cycle = (thold_ns * pclk_mhz + 1000 - 1) / 1000;
i2cip_w_sda_hold_time(reg_base, hold_cycle);
HAL_I2C_TRACE(1, "crystal freq=%d", pclk);
HAL_I2C_TRACE(5, "i2c-%d mode=%d lcnt=%d hcnt=%d hold=%d", id, speed_mode,
lcnt, hcnt, hold_cycle);
}
static uint8_t _i2c_set_bus_speed(enum HAL_I2C_ID_T id, unsigned int speed) {
uint32_t speed_mode;
if (speed > I2C_FSP_SPEED)
speed_mode = IC_SPEED_MODE_MAX;
else if (speed > I2C_FAST_SPEED)
#ifdef I2S_FSP_MODE
speed_mode = IC_SPEED_MODE_FAST;
#else
speed_mode = IC_SPEED_MODE_MAX;
#endif
else if (speed > I2C_STANDARD_SPEED)
speed_mode = IC_SPEED_MODE_FAST;
else
speed_mode = IC_SPEED_MODE_STANDARD;
_i2c_set_speed(id, speed_mode, speed);
return 0;
}
/* state machine related */
static void hal_i2c_sm_init(enum HAL_I2C_ID_T id,
const struct HAL_I2C_CONFIG_T *cfg) {
memcpy(&hal_i2c_sm[id].cfg, cfg, sizeof(*cfg));
hal_i2c_sm[id].state = HAL_I2C_SM_IDLE;
#if defined(I2C_TASK_MODE) || defined(I2C_SENSOR_ENGINE)
hal_i2c_sm[id].in_task = 0;
hal_i2c_sm[id].out_task = 0;
hal_i2c_sm[id].task_count = 0;
#ifdef I2C_USE_DMA
hal_i2c_sm[id].tx_dma_cfg.ch = HAL_DMA_CHAN_NONE;
hal_i2c_sm[id].rx_dma_cfg.ch = HAL_DMA_CHAN_NONE;
#else
hal_i2c_sm[id].cfg.use_dma = 0;
#endif
#endif
}
#if defined(I2C_TASK_MODE) || defined(I2C_SENSOR_ENGINE)
static uint32_t hal_i2c_sm_commit(enum HAL_I2C_ID_T id, const uint8_t *tx_buf,
uint16_t tx_txn_len, uint8_t *rx_buf,
uint16_t rx_txn_len, uint16_t txn_cnt,
uint16_t target_addr, uint32_t action,
uint32_t transfer_id,
HAL_I2C_TRANSFER_HANDLER_T handler) {
uint32_t cur = hal_i2c_sm[id].in_task;
hal_i2c_sm[id].task[cur].tx_buf = tx_buf;
hal_i2c_sm[id].task[cur].rx_buf = rx_buf;
hal_i2c_sm[id].task[cur].stop = 1;
hal_i2c_sm[id].task[cur].lock = 1;
hal_i2c_sm[id].task[cur].state = 0;
hal_i2c_sm[id].task[cur].rx_txn_len = rx_txn_len;
hal_i2c_sm[id].task[cur].tx_txn_len = tx_txn_len;
hal_i2c_sm[id].task[cur].txn_cnt = txn_cnt;
hal_i2c_sm[id].task[cur].tx_pos = 0;
hal_i2c_sm[id].task[cur].rx_pos = 0;
hal_i2c_sm[id].task[cur].rx_cmd_sent = 0;
hal_i2c_sm[id].task[cur].errcode = 0;
hal_i2c_sm[id].task[cur].action = action;
hal_i2c_sm[id].task[cur].handler = handler;
hal_i2c_sm[id].task[cur].restart_after_write = 1;
hal_i2c_sm[id].task[cur].target_addr = target_addr;
hal_i2c_sm[id].task[cur].transfer_id = transfer_id;
hal_i2c_sm[id].in_task = (cur + 1) % HAL_I2C_SM_TASK_NUM_MAX;
hal_i2c_sm[id].task_count++;
return cur;
}
static void hal_i2c_sm_done(enum HAL_I2C_ID_T id) {
hal_i2c_sm[id].in_task = 0;
hal_i2c_sm[id].out_task = 0;
hal_i2c_sm[id].task_count = 0;
hal_i2c_sm[id].state = HAL_I2C_SM_IDLE;
HAL_I2C_TRACE(1, "%s", __func__);
}
static enum HAL_I2C_SM_TASK_STATE_T
_i2c_chk_clr_task_error(uint32_t reg_base, uint32_t ip_int_status,
uint32_t tx_abrt_source) {
enum HAL_I2C_SM_TASK_STATE_T state = 0;
uint32_t tmp1;
/* tx abort interrupt */
if (ip_int_status & I2CIP_INT_STATUS_TX_ABRT_MASK) {
state |= HAL_I2C_SM_TASK_STATE_TX_ABRT;
/* sbyte_norstrt is special to clear : restart disable but user want to send
* a restart */
/* to fix this bit : enable restart , clear speical , clear gc_or_start bit
* temporary */
tmp1 = i2cip_r_target_address_reg(reg_base);
if (tx_abrt_source & I2CIP_TX_ABRT_SOURCE_ABRT_SBYTE_NORSTRT_MASK) {
i2cip_w_restart(reg_base, HAL_I2C_YES);
i2cip_w_special_bit(reg_base, HAL_I2C_NO);
i2cip_w_gc_or_start_bit(reg_base, HAL_I2C_NO);
}
i2cip_r_clr_tx_abrt(reg_base);
/* restore register after clear */
if (tx_abrt_source & I2CIP_TX_ABRT_SOURCE_ABRT_SBYTE_NORSTRT_MASK) {
i2cip_w_target_address_reg(reg_base, tmp1);
}
}
/* tx overflow interrupt */
if (ip_int_status & I2CIP_INT_MASK_TX_OVER_MASK) {
state |= HAL_I2C_SM_TASK_STATE_FIFO_ERR;
i2cip_r_clr_tx_over(reg_base);
}
/* rx overflow interrupt */
if (ip_int_status & I2CIP_INT_MASK_RX_OVER_MASK) {
state |= HAL_I2C_SM_TASK_STATE_FIFO_ERR;
i2cip_r_clr_rx_over(reg_base);
}
/* rx underflow interrupt */
if (ip_int_status & I2CIP_INT_MASK_RX_UNDER_MASK) {
state |= HAL_I2C_SM_TASK_STATE_FIFO_ERR;
i2cip_r_clr_rx_under(reg_base);
}
return state;
}
static void _i2c_show_error_code(uint32_t errcode) {
#ifdef DEBUG
if (errcode & HAL_I2C_ERRCODE_SLVRD_INTX)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_SLVRD_INTX");
if (errcode & HAL_I2C_ERRCODE_SLV_ARBLOST)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_SLV_ARBLOST");
if (errcode & HAL_I2C_ERRCODE_SLVFLUSH_TXFIFO)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_SLVFLUSH_TXFIFO");
if (errcode & HAL_I2C_ERRCODE_MASTER_DIS)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_MASTER_DIS");
if (errcode & HAL_I2C_ERRCODE_10B_RD_NORSTRT)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_10B_RD_NORSTRT");
if (errcode & HAL_I2C_ERRCODE_SBYTE_NORSTRT)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_SBYTE_NORSTRT");
if (errcode & HAL_I2C_ERRCODE_HS_NORSTRT)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_HS_NORSTRT");
if (errcode & HAL_I2C_ERRCODE_SBYTE_ACKDET)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_SBYTE_ACKDET");
if (errcode & HAL_I2C_ERRCODE_HS_ACKDET)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_HS_ACKDET");
if (errcode & HAL_I2C_ERRCODE_GCALL_READ)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_GCALL_READ");
if (errcode & HAL_I2C_ERRCODE_GCALL_NOACK)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_GCALL_NOACK");
if (errcode & HAL_I2C_ERRCODE_TXDATA_NOACK)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_TXDATA_NOACK");
if (errcode & HAL_I2C_ERRCODE_10ADDR2_NOACK)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_10ADDR2_NOACK");
if (errcode & HAL_I2C_ERRCODE_10ADDR1_NOACK)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_10ADDR1_NOACK");
if (errcode & HAL_I2C_ERRCODE_7B_ADDR_NOACK)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_7B_ADDR_NOACK");
if (errcode & HAL_I2C_ERRCODE_INV_PARAM)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_INV_PARAM");
if (errcode & HAL_I2C_ERRCODE_IN_USE)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_IN_USE");
if (errcode & HAL_I2C_ERRCODE_FIFO_ERR)
HAL_I2C_ERROR(0, "i2c err : HAL_I2C_ERRCODE_FIFO_ERR");
#endif
}
#ifdef I2C_USE_DMA
static void hal_i2c_tx_dma_handler(uint8_t chan, uint32_t remain_tsize,
uint32_t error, struct HAL_DMA_DESC_T *lli) {
enum HAL_I2C_ID_T id;
for (id = HAL_I2C_ID_0; id < HAL_I2C_ID_NUM; id++) {
if (hal_i2c_sm[id].tx_dma_cfg.ch == chan) {
}
}
}
static void hal_i2c_rx_dma_handler(uint8_t chan, uint32_t remain_tsize,
uint32_t error, struct HAL_DMA_DESC_T *lli) {
enum HAL_I2C_ID_T id;
for (id = HAL_I2C_ID_0; id < HAL_I2C_ID_NUM; id++) {
if (hal_i2c_sm[id].rx_dma_cfg.ch == chan) {
}
}
}
static void hal_i2c_dma_release(enum HAL_I2C_ID_T id) {
uint32_t reg_base;
struct HAL_DMA_CH_CFG_T *tx_dma_cfg = NULL, *rx_dma_cfg = NULL;
if (hal_i2c_sm[id].cfg.use_dma == 0) {
return;
}
reg_base = _i2c_get_base(id);
i2cip_w_tx_dma_enable(reg_base, HAL_I2C_NO);
i2cip_w_rx_dma_enable(reg_base, HAL_I2C_NO);
tx_dma_cfg = &hal_i2c_sm[id].tx_dma_cfg;
rx_dma_cfg = &hal_i2c_sm[id].rx_dma_cfg;
HAL_I2C_TRACE(1, "i2c tx free dma ch %d", tx_dma_cfg->ch);
if (tx_dma_cfg->ch != HAL_DMA_CHAN_NONE) {
hal_gpdma_cancel(tx_dma_cfg->ch);
hal_gpdma_free_chan(tx_dma_cfg->ch);
tx_dma_cfg->ch = HAL_DMA_CHAN_NONE;
}
HAL_I2C_TRACE(1, "i2c rx free dma ch %d", rx_dma_cfg->ch);
if (rx_dma_cfg->ch != HAL_DMA_CHAN_NONE) {
hal_gpdma_cancel(rx_dma_cfg->ch);
hal_gpdma_free_chan(rx_dma_cfg->ch);
rx_dma_cfg->ch = HAL_DMA_CHAN_NONE;
}
}
static void hal_i2c_dma_config(enum HAL_I2C_ID_T id,
const struct HAL_I2C_SM_TASK_T *out_task) {
uint32_t reg_base;
uint32_t i, txn;
uint32_t txn_start, org_start;
struct HAL_DMA_CH_CFG_T *tx_dma_cfg = NULL, *rx_dma_cfg = NULL;
enum HAL_I2C_SM_TASK_ACTION_T action;
uint32_t total_tx_len;
if (hal_i2c_sm[id].cfg.use_dma == 0) {
return;
}
reg_base = _i2c_get_base(id);
action = out_task->action;
total_tx_len = out_task->tx_txn_len * out_task->txn_cnt;
if (action == HAL_I2C_SM_TASK_ACTION_M_RECV) {
total_tx_len += out_task->rx_txn_len * out_task->txn_cnt;
}
ASSERT(total_tx_len < ARRAY_SIZE(hal_i2c_sm[id].dma_tx_buf),
"%s: xfer size too large: action=%d total_tx_len=%u (should <= %u)",
__FUNCTION__, action, total_tx_len,
ARRAY_SIZE(hal_i2c_sm[id].dma_tx_buf));
i2cip_w_tx_dma_enable(reg_base, HAL_I2C_YES);
i2cip_w_tx_dma_tl(reg_base, HAL_I2C_DMA_TX_TL);
tx_dma_cfg = &hal_i2c_sm[id].tx_dma_cfg;
memset(tx_dma_cfg, 0, sizeof(*tx_dma_cfg));
tx_dma_cfg->dst = 0; // useless
tx_dma_cfg->dst_bsize = HAL_DMA_BSIZE_1;
tx_dma_cfg->dst_periph = i2c_desc[id].tx_periph;
tx_dma_cfg->dst_width = HAL_DMA_WIDTH_HALFWORD;
tx_dma_cfg->handler = hal_i2c_tx_dma_handler;
tx_dma_cfg->src_bsize = HAL_DMA_BSIZE_1;
tx_dma_cfg->src_periph = 0; // useless
tx_dma_cfg->src_tsize = total_tx_len;
tx_dma_cfg->src_width = HAL_DMA_WIDTH_HALFWORD;
tx_dma_cfg->try_burst = 1;
tx_dma_cfg->type = HAL_DMA_FLOW_M2P_DMA;
tx_dma_cfg->src = (uint32_t)hal_i2c_sm[id].dma_tx_buf;
tx_dma_cfg->ch =
hal_gpdma_get_chan(tx_dma_cfg->dst_periph, HAL_DMA_HIGH_PRIO);
HAL_I2C_TRACE(1, "i2c tx get dma ch %d", tx_dma_cfg->ch);
ASSERT(tx_dma_cfg->ch != HAL_DMA_CHAN_NONE, "I2C: Failed to get tx dma chan");
HAL_I2C_TRACE(3, "tx size %d cnt %d total tx size %d", out_task->tx_txn_len,
out_task->txn_cnt, total_tx_len);
memset(&hal_i2c_sm[id].dma_tx_buf[0], 0, sizeof(hal_i2c_sm[id].dma_tx_buf));
for (txn = 0; txn < out_task->txn_cnt; txn++) {
org_start = out_task->tx_txn_len * txn;
txn_start = (out_task->tx_txn_len + out_task->rx_txn_len) * txn;
for (i = 0; i < out_task->tx_txn_len; i++) {
// lo byte of short : for data
// hi byte of short : for cmd/stop/restart
hal_i2c_sm[id].dma_tx_buf[txn_start + i] =
out_task->tx_buf[org_start + i];
}
if (txn && out_task->restart_after_write) {
hal_i2c_sm[id].dma_tx_buf[txn_start] |= I2CIP_CMD_DATA_RESTART_MASK;
}
}
if (action == HAL_I2C_SM_TASK_ACTION_M_RECV) {
i2cip_w_rx_dma_enable(reg_base, HAL_I2C_YES);
i2cip_w_rx_dma_tl(reg_base, HAL_I2C_DMA_RX_TL);
for (txn = 0; txn < out_task->txn_cnt; txn++) {
txn_start = (out_task->tx_txn_len + out_task->rx_txn_len) * txn +
out_task->tx_txn_len;
for (i = 0; i < out_task->rx_txn_len; i++) {
// lo byte of short : for data
// hi byte of short : for cmd/stop/restart
hal_i2c_sm[id].dma_tx_buf[txn_start + i] = I2CIP_CMD_DATA_CMD_READ_MASK;
}
if (out_task->restart_after_write) {
hal_i2c_sm[id].dma_tx_buf[txn_start] |= I2CIP_CMD_DATA_RESTART_MASK;
}
}
HAL_I2C_TRACE(2, "rx size %d cnt %d", out_task->rx_txn_len,
out_task->txn_cnt);
rx_dma_cfg = &hal_i2c_sm[id].rx_dma_cfg;
memset(rx_dma_cfg, 0, sizeof(*rx_dma_cfg));
rx_dma_cfg->dst = (uint32_t)(out_task->rx_buf);
rx_dma_cfg->dst_bsize = HAL_DMA_BSIZE_1;
rx_dma_cfg->dst_periph = 0; // useless
rx_dma_cfg->dst_width = HAL_DMA_WIDTH_BYTE;
rx_dma_cfg->handler = hal_i2c_rx_dma_handler;
rx_dma_cfg->src_bsize = HAL_DMA_BSIZE_1;
rx_dma_cfg->src_periph = i2c_desc[id].rx_periph;
rx_dma_cfg->src_tsize = out_task->rx_txn_len * out_task->txn_cnt;
rx_dma_cfg->src_width = HAL_DMA_WIDTH_BYTE;
rx_dma_cfg->try_burst = 0;
rx_dma_cfg->src = 0; // useless
rx_dma_cfg->type = HAL_DMA_FLOW_P2M_DMA;
rx_dma_cfg->ch =
hal_gpdma_get_chan(rx_dma_cfg->src_periph, HAL_DMA_HIGH_PRIO);
HAL_I2C_TRACE(1, "i2c rx get dma ch %d", rx_dma_cfg->ch);
ASSERT(tx_dma_cfg->ch != HAL_DMA_CHAN_NONE,
"I2C: Failed to get rx dma chan");
}
if (out_task->stop) {
hal_i2c_sm[id].dma_tx_buf[total_tx_len - 1] |= I2CIP_CMD_DATA_STOP_MASK;
}
}
#endif
#endif
#ifdef I2C_TASK_MODE
static void hal_i2c_sm_done_task(enum HAL_I2C_ID_T id) {
struct HAL_I2C_SM_TASK_T *task;
uint32_t reg_base = _i2c_get_base(id);
task = &(hal_i2c_sm[id].task[hal_i2c_sm[id].out_task]);
if (task->errcode) {
HAL_I2C_ERROR(1, "i2c err : 0x%X", task->errcode);
_i2c_show_error_code(task->errcode);
}
if (task->stop || task->errcode) {
HAL_I2C_TRACE(0, "disable i2c");
i2cip_w_enable(reg_base, HAL_I2C_NO);
}
#ifdef I2C_USE_DMA
if (hal_i2c_sm[id].cfg.use_dma) {
hal_i2c_dma_release(id);
}
#endif
if (hal_i2c_sm[id].cfg.use_sync) {
/* FIXME : os and non-os - different proc */
task->lock = 0;
} else {
if (task->handler) {
task->handler(id, task->transfer_id, task->tx_buf,
task->tx_txn_len * task->txn_cnt, task->rx_buf,
task->rx_txn_len * task->txn_cnt, task->errcode);
}
}
hal_i2c_sm[id].out_task =
(hal_i2c_sm[id].out_task + 1) % HAL_I2C_SM_TASK_NUM_MAX;
--hal_i2c_sm[id].task_count;
}
static void hal_i2c_sm_next_task(enum HAL_I2C_ID_T id) {
uint32_t out_task_index;
uint32_t reg_base, reinit;
enum HAL_I2C_SM_TASK_ACTION_T action;
struct HAL_I2C_SM_TASK_T *out_task = 0;
reg_base = _i2c_get_base(id);
if (hal_i2c_sm[id].task_count <= 0) {
HAL_I2C_TRACE(0, "no task");
hal_i2c_sm_done(id);
return;
}
out_task_index = hal_i2c_sm[id].out_task;
out_task = &(hal_i2c_sm[id].task[out_task_index]);
action = out_task->action;
/* tx : quarter trigger TX EMPTY INT */
i2cip_w_tx_threshold(reg_base, HAL_I2C_TX_TL);
if (action == HAL_I2C_SM_TASK_ACTION_M_RECV) {
/* rx : three quarter trigger RX FULL INT */
i2cip_w_rx_threshold(reg_base, HAL_I2C_RX_TL);
}
#ifdef I2C_USE_DMA
if (hal_i2c_sm[id].cfg.use_dma) {
i2cip_init_int_mask(reg_base, I2CIP_INT_MASK_STOP_DET_MASK |
I2CIP_INT_MASK_ERROR_MASK);
/* prepare for dma operation */
hal_i2c_dma_config(id, out_task);
} else
#endif
{
/* open all interrupt */
i2cip_init_int_mask(reg_base,
(I2CIP_INT_MASK_ALL & ~(I2CIP_INT_MASK_START_DET_MASK |
I2CIP_INT_MASK_ACTIVITY_MASK)));
}
reinit = i2cip_r_enable_status(reg_base);
/* not enable : reconfig i2cip with new-task params */
/* enable : same operation with pre task */
if (!(reinit & I2CIP_ENABLE_STATUS_ENABLE_MASK)) {
HAL_I2C_TRACE(0, "enable i2c");
i2cip_w_restart(reg_base, HAL_I2C_YES);
i2cip_w_target_address(reg_base, out_task->target_addr);
i2cip_w_enable(reg_base, HAL_I2C_YES);
}
#ifdef I2C_USE_DMA
if (hal_i2c_sm[id].cfg.use_dma) {
if (action == HAL_I2C_SM_TASK_ACTION_M_RECV) {
HAL_I2C_TRACE(0, "enable rx dma");
hal_gpdma_start(&hal_i2c_sm[id].rx_dma_cfg);
}
HAL_I2C_TRACE(0, "enable tx dma");
hal_gpdma_start(&hal_i2c_sm[id].tx_dma_cfg);
}
#endif
}
static uint32_t hal_i2c_sm_wait_task_if_need(enum HAL_I2C_ID_T id,
uint32_t task_idx,
uint32_t tm_ms) {
int tmcnt;
struct HAL_I2C_SM_TASK_T *task = 0;
/* FIXME : task_id maybe invalid cause so-fast device operation */
task = &(hal_i2c_sm[id].task[task_idx]);
if (!(hal_i2c_sm[id].cfg.use_sync))
return 0;
/* FIXME : os and non-os - different proc */
tmcnt = tm_ms / HAL_I2C_DLY_MS;
while (1) {
uint32_t lock = task->lock;
if (!lock)
break;
if (!tmcnt) {
HAL_I2C_TRACE(1, "wait lock timeout %d ms", tm_ms);
task->errcode = HAL_I2C_ERRCODE_SYNC_TIMEOUT;
hal_i2c_sm_done_task(id);
hal_i2c_sm_next_task(id);
break;
}
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
tmcnt--;
}
return task->errcode;
}
static void hal_i2c_sm_kickoff(enum HAL_I2C_ID_T id) {
if (hal_i2c_sm[id].state == HAL_I2C_SM_IDLE) {
hal_i2c_sm[id].state = HAL_I2C_SM_RUNNING;
hal_i2c_sm_next_task(id);
}
}
static void hal_i2c_sm_proc(enum HAL_I2C_ID_T id) {
uint32_t reg_base = 0;
enum HAL_I2C_SM_STATE_T state;
enum HAL_I2C_SM_TASK_STATE_T task_state;
struct HAL_I2C_SM_TASK_T *task;
uint32_t i = 0, restart = 0, stop = 0, data = 0;
uint32_t ip_int_status = 0, tx_abrt_source = 0;
uint8_t rx_limit, tx_limit, rx_cnt, tx_cnt;
uint32_t total_tx_len, total_rx_len;
uint32_t txn_idx, txn_pos;
reg_base = _i2c_get_base(id);
state = hal_i2c_sm[id].state;
task = &(hal_i2c_sm[id].task[hal_i2c_sm[id].out_task]);
ip_int_status = i2cip_r_int_status(reg_base);
tx_abrt_source = i2cip_r_tx_abrt_source(reg_base);
HAL_I2C_TRACE(4, "id:%d, ip_int_status=0x%X tx_abrt_source=0x%X state=%d", id,
ip_int_status, tx_abrt_source, state);
task_state = _i2c_chk_clr_task_error(reg_base, ip_int_status, tx_abrt_source);
if (state != HAL_I2C_SM_RUNNING) {
HAL_I2C_ERROR(3,
"*** WARNING: No i2c task running: id=%d ip_int_status=0x%X "
"tx_abrt_source=0x%X",
id, ip_int_status, tx_abrt_source);
i2cip_r_clr_all_intr(reg_base);
return;
}
HAL_I2C_TRACE(1, "RUNNING action=%d", task->action);
task->state |= task_state;
if (task->state &
(HAL_I2C_SM_TASK_STATE_TX_ABRT | HAL_I2C_SM_TASK_STATE_FIFO_ERR)) {
HAL_I2C_ERROR(5,
"*** ERROR:%s: id=%d task_state=0x%X ip_int_status=0x%X "
"tx_abrt_source=0x%X",
__func__, id, task->state, ip_int_status, tx_abrt_source);
task->errcode = tx_abrt_source;
if (task->state & HAL_I2C_SM_TASK_STATE_FIFO_ERR) {
task->errcode |= HAL_I2C_ERRCODE_FIFO_ERR;
}
/* done task on any error */
hal_i2c_sm_done_task(id);
hal_i2c_sm_next_task(id);
return;
}
/* stop det interrupt */
if (ip_int_status & I2CIP_INT_STATUS_STOP_DET_MASK) {
task->state |= HAL_I2C_SM_TASK_STATE_STOP;
i2cip_r_clr_stop_det(reg_base);
}
/* start det interrupt */
if (ip_int_status & I2CIP_INT_STATUS_START_DET_MASK) {
task->state |= HAL_I2C_SM_TASK_STATE_START;
i2cip_r_clr_start_det(reg_base);
}
/* activeity det interrupt */
if (ip_int_status & I2CIP_INT_STATUS_ACTIVITY_MASK) {
task->state |= HAL_I2C_SM_TASK_STATE_ACT;
i2cip_r_clr_activity(reg_base);
}
switch (task->action) {
case HAL_I2C_SM_TASK_ACTION_M_SEND: {
if (hal_i2c_sm[id].cfg.use_dma == 0) {
/* tx empty : means tx fifo is at or below IC_TX_TL :
need to write more data : we can NOT clear this bit, cleared by hw */
if (ip_int_status & I2CIP_INT_STATUS_TX_EMPTY_MASK) {
total_tx_len = task->tx_txn_len * task->txn_cnt;
tx_limit = i2cip_r_tx_fifo_level(reg_base);
if (tx_limit < I2CIP_TX_FIFO_DEPTH) {
tx_limit = I2CIP_TX_FIFO_DEPTH - tx_limit;
} else {
tx_limit = 0;
}
HAL_I2C_TRACE(4, "m_send: tx_pos=%d tx_txn_len=%d cnt=%d tx_limit=%d",
task->tx_pos, task->tx_txn_len, task->txn_cnt, tx_limit);
for (i = task->tx_pos, tx_cnt = 0;
((i < total_tx_len) && (tx_cnt < tx_limit)); ++i, ++tx_cnt) {
/* last byte : we need to decide stop */
if (i == total_tx_len - 1) {
stop = task->stop ? I2CIP_CMD_DATA_STOP_MASK : 0;
} else {
stop = 0;
}
if (task->txn_cnt == 1) {
txn_pos = i;
} else {
txn_pos = i % task->tx_txn_len;
}
/* first byte : need to decide restart */
if (i && task->restart_after_write && txn_pos == 0) {
restart = I2CIP_CMD_DATA_RESTART_MASK;
} else {
restart = 0;
}
/* write data to FIFO */
i2cip_w_cmd_data(reg_base, task->tx_buf[i] |
I2CIP_CMD_DATA_CMD_WRITE_MASK |
restart | stop);
HAL_I2C_TRACE(3, "m_send: data=0x%02X restart=0x%X stop=0x%X",
task->tx_buf[i], restart, stop);
}
task->tx_pos = i;
/* all write action done : do NOT need tx empty int */
if (task->tx_pos == total_tx_len) {
i2cip_clear_int_mask(reg_base, I2CIP_INT_MASK_TX_EMPTY_MASK);
}
HAL_I2C_TRACE(1, "m_send: i2c status=0x%X", i2cip_r_status(reg_base));
}
}
/* stop condition : done task */
if (task->state & HAL_I2C_SM_TASK_STATE_STOP) {
HAL_I2C_TRACE(1, "m_send: task->state:0x%X", task->state);
hal_i2c_sm_done_task(id);
hal_i2c_sm_next_task(id);
}
break;
}
case HAL_I2C_SM_TASK_ACTION_M_RECV: {
if (hal_i2c_sm[id].cfg.use_dma == 0) {
/* rx full : need to read */
if (ip_int_status & I2CIP_INT_STATUS_RX_FULL_MASK) {
total_rx_len = task->rx_txn_len * task->txn_cnt;
rx_limit = i2cip_r_rx_fifo_level(reg_base);
HAL_I2C_TRACE(4,
"m_recv:full: rx_pos=%d rx_txn_len=%d cnt=%d rx_limit=%d",
task->rx_pos, task->rx_txn_len, task->txn_cnt, rx_limit);
for (i = task->rx_pos, rx_cnt = 0;
((i < total_rx_len) && (rx_cnt < rx_limit)); ++i, ++rx_cnt) {
task->rx_buf[i] = i2cip_r_cmd_data(reg_base);
HAL_I2C_TRACE(2, "m_recv:full: rx_buf[%d] 0x%X", i, task->rx_buf[i]);
}
task->rx_pos = i;
}
/* tx empty : means tx fifo is at or below IC_TX_TL :
need to write more data : we can NOT clear this bit, cleared by hw */
if (ip_int_status & I2CIP_INT_STATUS_TX_EMPTY_MASK) {
total_tx_len = (task->tx_txn_len + task->rx_txn_len) * task->txn_cnt;
tx_limit = i2cip_r_tx_fifo_level(reg_base);
if (tx_limit < I2CIP_TX_FIFO_DEPTH) {
tx_limit = I2CIP_TX_FIFO_DEPTH - tx_limit;
} else {
tx_limit = 0;
}
rx_limit = task->rx_cmd_sent - task->rx_pos + 1;
if (rx_limit < I2CIP_RX_FIFO_DEPTH) {
rx_limit = I2CIP_RX_FIFO_DEPTH - rx_limit;
} else {
rx_limit = 0;
}
HAL_I2C_TRACE(6,
"m_recv:txEmpty: tx_pos=%d tx_txn_len=%d rx_txn_len=%d "
"cnt=%d tx_limit=%d rx_limit=%d",
task->tx_pos, task->tx_txn_len, task->rx_txn_len,
task->txn_cnt, tx_limit, rx_limit);
if (tx_limit > rx_limit) {
tx_limit = rx_limit;
}
for (i = task->tx_pos, tx_cnt = 0;
((i < total_tx_len) && (tx_cnt < tx_limit)); ++i, ++tx_cnt) {
/* last byte : we need to decide stop */
if (i == (total_tx_len - 1)) {
stop = task->stop ? I2CIP_CMD_DATA_STOP_MASK : 0;
} else {
stop = 0;
}
if (task->txn_cnt == 1) {
txn_idx = 0;
txn_pos = i;
} else {
txn_idx = i / (task->tx_txn_len + task->rx_txn_len);
txn_pos = i % (task->tx_txn_len + task->rx_txn_len);
}
/* first byte : need to decide restart */
if (i && task->restart_after_write &&
(txn_pos == 0 || txn_pos == task->tx_txn_len)) {
restart = I2CIP_CMD_DATA_RESTART_MASK;
} else {
restart = 0;
}
/* real write data */
if (txn_pos < task->tx_txn_len) {
if (task->txn_cnt == 1) {
data = task->tx_buf[txn_pos];
} else {
data = task->tx_buf[txn_idx * task->tx_txn_len + txn_pos];
}
} else {
data = I2CIP_CMD_DATA_CMD_READ_MASK;
task->rx_cmd_sent++;
}
i2cip_w_cmd_data(reg_base, data | restart | stop);
HAL_I2C_TRACE(4, "m_recv:tx: data[%u]=0x%02X restart=0x%X stop=0x%X",
i, data, restart, stop);
}
task->tx_pos = i;
/* all write action done */
if (task->tx_pos == total_tx_len) {
i2cip_clear_int_mask(reg_base, I2CIP_INT_MASK_TX_EMPTY_MASK);
}
}
}
/* stop condition : need to read out all rx fifo */
if (task->state & HAL_I2C_SM_TASK_STATE_STOP) {
if (hal_i2c_sm[id].cfg.use_dma) {
#ifdef I2C_USE_DMA
if (hal_i2c_sm[id].rx_dma_cfg.ch == HAL_DMA_CHAN_NONE) {
HAL_I2C_TRACE(0, "m_recv:stop:WARNING: bad rx dma chan!");
} else {
if (hal_dma_chan_busy(hal_i2c_sm[id].rx_dma_cfg.ch)) {
HAL_I2C_TRACE(0, "m_recv:stop:WARNING: rx dma not finished yet!");
}
}
#endif
} else {
rx_limit = i2cip_r_rx_fifo_level(reg_base);
HAL_I2C_TRACE(1, "m_recv:stop: rx_limit=%d", rx_limit);
for (i = task->rx_pos, rx_cnt = 0;
((rx_cnt < rx_limit) && (i < task->rx_txn_len)); ++i, ++rx_cnt) {
task->rx_buf[i] = i2cip_r_cmd_data(reg_base);
HAL_I2C_TRACE(2, "m_recv:stop: rx_buf[%d] 0x%X", i, task->rx_buf[i]);
}
task->rx_pos = i;
if (task->rx_pos != task->rx_txn_len * task->txn_cnt) {
HAL_I2C_TRACE(
3,
"m_recv:stop:WARNING: rx_pos(%u) != rx_txn_len(%u) * txn_cnt(%u)",
task->rx_pos, task->rx_txn_len, task->txn_cnt);
}
}
hal_i2c_sm_done_task(id);
hal_i2c_sm_next_task(id);
}
break;
}
default:
break;
}
}
void hal_i2c_irq_handler(void) {
enum HAL_I2C_ID_T id;
for (id = HAL_I2C_ID_0; id < HAL_I2C_ID_NUM; id++) {
if (NVIC_GetActive(i2c_desc[id].irq)) {
hal_i2c_sm_proc(id);
}
}
}
#endif
#ifdef I2C_SIMPLE_MODE
void hal_i2c_irq_handler_s(void) {
enum HAL_I2C_ID_T id;
for (id = HAL_I2C_ID_0; id < HAL_I2C_ID_NUM; id++) {
if (NVIC_GetActive(i2c_desc[id].irq)) {
hal_i2c_simple_proc(id);
}
}
}
#endif
#ifdef I2C_SENSOR_ENGINE
void hal_i2c_irq_handler_sensor_eng(void) {
enum HAL_I2C_ID_T id;
for (id = HAL_I2C_ID_0; id < HAL_I2C_ID_NUM; id++) {
if (NVIC_GetActive(i2c_desc[id].irq)) {
hal_i2c_sensor_eng_proc(id);
}
}
}
#endif
static int POSSIBLY_UNUSED hal_i2c_nvic_setup_irq(enum HAL_I2C_ID_T id,
uint32_t handler) {
IRQn_Type irqt = i2c_desc[id].irq;
NVIC_SetVector(irqt, handler);
NVIC_SetPriority(irqt, IRQ_PRIORITY_NORMAL);
return 0;
}
static int hal_i2c_nvic_enable_irq(enum HAL_I2C_ID_T id, int enabled) {
IRQn_Type irqt = i2c_desc[id].irq;
if (enabled) {
NVIC_ClearPendingIRQ(irqt);
NVIC_EnableIRQ(irqt);
} else {
NVIC_DisableIRQ(irqt);
NVIC_ClearPendingIRQ(irqt);
}
return 0;
}
uint32_t hal_i2c_open(enum HAL_I2C_ID_T id,
const struct HAL_I2C_CONFIG_T *cfg) {
uint32_t reg_base;
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].state != HAL_I2C_SM_CLOSED) {
return HAL_I2C_ERRCODE_IN_USE;
}
hal_i2c_sm_init(id, cfg);
hal_cmu_clock_enable(i2c_desc[id].mod);
hal_cmu_clock_enable(i2c_desc[id].apb);
hal_cmu_reset_clear(i2c_desc[id].mod);
hal_cmu_reset_clear(i2c_desc[id].apb);
reg_base = _i2c_get_base(id);
HAL_I2C_TRACE(2, "i2c id=%d reg_base=0x%X", id, reg_base);
i2cip_w_enable(reg_base, HAL_I2C_NO);
i2cip_w_target_address(reg_base, 0x18);
/* clear */
i2cip_w_clear_ctrl(reg_base);
/* as master */
if (cfg->as_master) {
i2cip_w_disable_slave(reg_base, HAL_I2C_YES);
i2cip_w_master_mode(reg_base, HAL_I2C_YES);
} else {
i2cip_w_disable_slave(reg_base, HAL_I2C_NO);
i2cip_w_master_mode(reg_base, HAL_I2C_NO);
/* address as slave */
i2cip_w_address_as_slave(reg_base, cfg->addr_as_slave);
}
/* speed */
_i2c_set_bus_speed(id, cfg->speed);
if (0) {
#ifdef I2C_SIMPLE_MODE
} else if (cfg->mode == HAL_I2C_API_MODE_SIMPLE) {
HAL_I2C_TRACE(0, "simple mode");
hal_i2c_nvic_setup_irq(id, (uint32_t)hal_i2c_irq_handler_s);
/* only open slave related int, polling in master */
/* read req (master read us), rx full (master write us) */
if (cfg->as_master) {
i2cip_init_int_mask(reg_base, I2CIP_INT_UNMASK_ALL);
} else {
i2cip_init_int_mask(reg_base, I2CIP_INT_MASK_RD_REQ_MASK |
I2CIP_INT_MASK_RX_FULL_MASK);
}
/* rx threshold, 1 byte trigger RX_FULL */
i2cip_w_rx_threshold(reg_base, I2CIP_RX_TL_1_BYTE);
/* tx threshold, 1 byte trigger TX_EMPTY */
i2cip_w_tx_threshold(reg_base, I2CIP_TX_TL_1_BYTE);
/* enable restart */
i2cip_w_restart(reg_base, HAL_I2C_YES);
/* enable i2c */
i2cip_w_enable(reg_base, HAL_I2C_YES);
#endif
#ifdef I2C_TASK_MODE
} else if (cfg->mode == HAL_I2C_API_MODE_TASK) {
/* only use task irq handler when master mode */
HAL_I2C_TRACE(0, "task mode");
if (!cfg->as_master) {
HAL_I2C_TRACE(0, "not as master");
return HAL_I2C_ERRCODE_INV_PARAM;
}
#ifndef I2C_USE_DMA
if (cfg->use_dma) {
HAL_I2C_TRACE(0, "using DMA when I2C_USE_DMA is NOT enabled");
return HAL_I2C_ERRCODE_INV_PARAM;
}
#endif
hal_i2c_nvic_setup_irq(id, (uint32_t)hal_i2c_irq_handler);
#endif
#ifdef I2C_SENSOR_ENGINE
} else if (cfg->mode == HAL_I2C_API_MODE_SENSOR_ENGINE) {
HAL_I2C_TRACE(0, "sensor engine mode");
ASSERT(cfg->as_master, "%s: i2c master should be used with sensor engine",
__FUNCTION__);
ASSERT(cfg->use_dma, "%s: i2c dma should be used with sensor engine",
__FUNCTION__);
hal_i2c_nvic_setup_irq(id, (uint32_t)hal_i2c_irq_handler_sensor_eng);
#endif
} else {
ASSERT(false, "%s: Bad i2c api mode: %u", __FUNCTION__, cfg->mode);
}
hal_i2c_nvic_enable_irq(id, HAL_I2C_YES);
return 0;
}
uint32_t hal_i2c_close(enum HAL_I2C_ID_T id) {
uint32_t reg_base;
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].state == HAL_I2C_SM_CLOSED) {
return 0;
}
reg_base = _i2c_get_base(id);
hal_i2c_nvic_enable_irq(id, HAL_I2C_NO);
i2cip_w_enable(reg_base, HAL_I2C_NO);
#if defined(I2C_TASK_MODE) || defined(I2C_SENSOR_ENGINE)
#ifdef I2C_USE_DMA
hal_i2c_dma_release(id);
#endif
#endif
hal_cmu_reset_set(i2c_desc[id].apb);
hal_cmu_reset_set(i2c_desc[id].mod);
hal_cmu_clock_disable(i2c_desc[id].apb);
hal_cmu_clock_disable(i2c_desc[id].mod);
hal_i2c_sm[id].state = HAL_I2C_SM_CLOSED;
return 0;
}
/* task mode */
#ifdef I2C_TASK_MODE
uint32_t hal_i2c_task_msend(enum HAL_I2C_ID_T id, uint16_t device_addr,
const uint8_t *tx_buf, uint16_t tx_item_len,
uint16_t item_cnt, uint32_t transfer_id,
HAL_I2C_TRANSFER_HANDLER_T handler) {
uint32_t task_idx;
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].cfg.mode != HAL_I2C_API_MODE_TASK) {
HAL_I2C_TRACE(0, "send: not task mode");
return HAL_I2C_ERRCODE_INV_PARAM;
}
task_idx =
hal_i2c_sm_commit(id, tx_buf, tx_item_len, NULL, 0, item_cnt, device_addr,
HAL_I2C_SM_TASK_ACTION_M_SEND, transfer_id, handler);
hal_i2c_sm_kickoff(id);
return hal_i2c_sm_wait_task_if_need(id, task_idx, HAL_I2C_SYNC_TM_MS);
}
uint32_t hal_i2c_task_send(enum HAL_I2C_ID_T id, uint16_t device_addr,
const uint8_t *tx_buf, uint16_t tx_len,
uint32_t transfer_id,
HAL_I2C_TRANSFER_HANDLER_T handler) {
return hal_i2c_task_msend(id, device_addr, tx_buf, tx_len, 1, transfer_id,
handler);
}
uint32_t hal_i2c_task_mrecv(enum HAL_I2C_ID_T id, uint16_t device_addr,
const uint8_t *tx_buf, uint16_t tx_item_len,
uint8_t *rx_buf, uint16_t rx_item_len,
uint16_t item_cnt, uint32_t transfer_id,
HAL_I2C_TRANSFER_HANDLER_T handler) {
uint32_t task_idx;
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].cfg.mode != HAL_I2C_API_MODE_TASK) {
HAL_I2C_TRACE(0, "recv: not task mode");
return HAL_I2C_ERRCODE_INV_PARAM;
}
task_idx = hal_i2c_sm_commit(
id, tx_buf, tx_item_len, rx_buf, rx_item_len, item_cnt, device_addr,
HAL_I2C_SM_TASK_ACTION_M_RECV, transfer_id, handler);
hal_i2c_sm_kickoff(id);
return hal_i2c_sm_wait_task_if_need(id, task_idx, HAL_I2C_SYNC_TM_MS);
}
uint32_t hal_i2c_task_recv(enum HAL_I2C_ID_T id, uint16_t device_addr,
const uint8_t *tx_buf, uint16_t tx_len,
uint8_t *rx_buf, uint16_t rx_len,
uint32_t transfer_id,
HAL_I2C_TRANSFER_HANDLER_T handler) {
return hal_i2c_task_mrecv(id, device_addr, tx_buf, tx_len, rx_buf, rx_len, 1,
transfer_id, handler);
}
uint32_t hal_i2c_send(enum HAL_I2C_ID_T id, uint32_t device_addr, uint8_t *buf,
uint32_t reg_len, uint32_t value_len,
uint32_t transfer_id,
HAL_I2C_TRANSFER_HANDLER_T handler) {
return hal_i2c_task_send(id, device_addr, buf, reg_len + value_len,
transfer_id, handler);
}
uint32_t hal_i2c_recv(enum HAL_I2C_ID_T id, uint32_t device_addr, uint8_t *buf,
uint32_t reg_len, uint32_t value_len,
uint8_t restart_after_write, uint32_t transfer_id,
HAL_I2C_TRANSFER_HANDLER_T handler) {
return hal_i2c_task_recv(id, device_addr, buf, reg_len, buf + reg_len,
value_len, transfer_id, handler);
}
#endif
/* task mode end */
/* simple mode */
#ifdef I2C_SIMPLE_MODE
static void hal_i2c_simple_proc(enum HAL_I2C_ID_T id) {
uint32_t reg_base = _i2c_get_base(id);
uint32_t irq_status = i2cip_r_raw_int_status(reg_base);
uint32_t abt_source = i2cip_r_tx_abrt_source(reg_base);
HAL_I2C_INT_HANDLER_T h = hal_i2c_int_handlers[id];
i2cip_r_clr_all_intr(reg_base);
if (h) {
HAL_I2C_TRACE(3, "%s:irq=0x%X abt=0x%X", __func__, irq_status, abt_source);
h(id, irq_status, abt_source);
}
// TODO: clean irq after callback done ?
i2cip_r_clr_all_intr(reg_base);
HAL_I2C_TRACE(3, "%s:0x%X 0x%X", __func__, i2cip_r_status(reg_base),
i2cip_r_raw_int_status(reg_base));
}
static uint32_t _i2c_check_tx_abrt_error(enum HAL_I2C_ID_T id) {
uint32_t reg_base = _i2c_get_base(id);
if (i2cip_r_raw_int_status(reg_base) & I2CIP_RAW_INT_STATUS_TX_ABRT_MASK)
return i2cip_r_tx_abrt_source(reg_base);
return 0;
}
uint32_t hal_i2c_slv_write(enum HAL_I2C_ID_T id, uint8_t *buf, uint32_t len,
uint32_t *act_write) {
uint32_t reg_base = 0, i = 0, ret = 0;
reg_base = _i2c_get_base(id);
*act_write = 0;
for (i = 0; i < len;) {
/* Tx Fifo Not Full */
if (i2cip_r_status(reg_base) & I2CIP_STATUS_TFNF_MASK) {
i2cip_w_cmd_data(reg_base, buf[i]);
++(*act_write);
++i;
} else {
/* wait for TFNF & not rx done & no error */
while (!(i2cip_r_status(reg_base) & I2CIP_STATUS_TFNF_MASK) &&
!(i2cip_r_raw_int_status(reg_base) &
I2CIP_RAW_INT_STATUS_RX_DONE_MASK) &&
!(ret = _i2c_check_tx_abrt_error(reg_base)))
;
if (ret || (i2cip_r_raw_int_status(reg_base) &
I2CIP_RAW_INT_STATUS_RX_DONE_MASK))
break;
}
}
/* FIXME : tx empty is not end of transmit, i2cip may transmit the last byte
*/
while (!(i2cip_r_status(reg_base) & I2CIP_STATUS_TFE_SHIFT) &&
!(ret = _i2c_check_tx_abrt_error(reg_base)))
;
/* wait to idle */
/* FIXME : time out */
while (i2cip_r_status(reg_base) & I2CIP_STATUS_ACT_MASK)
;
return ret;
}
uint32_t hal_i2c_slv_read(enum HAL_I2C_ID_T id, uint8_t *buf, uint32_t len,
uint32_t *act_read) {
uint32_t reg_base = 0, i = 0, ret = 0, depth = 0;
reg_base = _i2c_get_base(id);
*act_read = 0;
/* slave mode : just read */
for (i = 0; i < len;) {
/* Rx Fifo Not Empty */
if (i2cip_r_status(reg_base) & I2CIP_STATUS_RFNE_MASK) {
buf[i] = i2cip_r_cmd_data(reg_base);
++(*act_read);
++i;
} else {
/* wait for RFNE & no stop & no error */
while (!(i2cip_r_status(reg_base) & I2CIP_STATUS_RFNE_MASK) &&
!(i2cip_r_raw_int_status(reg_base) &
I2CIP_RAW_INT_STATUS_STOP_DET_MASK) &&
!(ret = _i2c_check_tx_abrt_error(reg_base))) {
}
if (ret || (i2cip_r_raw_int_status(reg_base) &
I2CIP_RAW_INT_STATUS_STOP_DET_MASK)) {
HAL_I2C_TRACE(2, "drv:i2c slave read ret 0x%X, raw status 0x%X", ret,
i2cip_r_raw_int_status(reg_base));
break;
}
}
}
/* may left some bytes in rx fifo */
depth = i2cip_r_rx_fifo_level(reg_base);
HAL_I2C_TRACE(1, "drv:i2c slave read depth %d", depth);
while (depth > 0 && i < len) {
buf[i] = i2cip_r_cmd_data(reg_base);
++(*act_read);
++i;
--depth;
}
/* wait to idle */
while (i2cip_r_status(reg_base) & I2CIP_STATUS_ACT_MASK)
;
return 0;
}
static void i2c_clear_special_tx_abrt(uint32_t reg_base) {
uint32_t abrt = i2cip_r_tx_abrt_source(reg_base);
i2cip_r_clr_tx_abrt(reg_base);
if (abrt & I2CIP_TX_ABRT_SOURCE_ABRT_SBYTE_NORSTRT_MASK) {
i2cip_w_restart(reg_base, HAL_I2C_YES);
i2cip_w_special_bit(reg_base, HAL_I2C_NO);
i2cip_w_gc_or_start_bit(reg_base, HAL_I2C_NO);
i2cip_r_clr_tx_abrt(reg_base);
}
}
static uint32_t _i2c_check_raw_int_status(uint32_t reg_base, uint32_t mask) {
uint32_t regval = i2cip_r_raw_int_status(reg_base);
HAL_I2C_TRACE(3, "%s: raw status=0x%X mask=0x%X", __func__, regval, mask);
return regval & mask;
}
uint32_t hal_i2c_mst_write(enum HAL_I2C_ID_T id, uint32_t dev_addr,
const uint8_t *buf, uint32_t len,
uint32_t *act_write, uint32_t restart, uint32_t stop,
uint32_t yield) {
uint32_t i, tar, wrcnt, ret = 0;
uint32_t reg_base;
uint32_t start_time, timeout;
uint32_t res, sto;
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].cfg.mode != HAL_I2C_API_MODE_SIMPLE) {
HAL_I2C_TRACE(0, "mst_write: not simple mode");
return HAL_I2C_ERRCODE_INV_PARAM;
}
HAL_I2C_TRACE(7, "%s:id=%d addr=0x%02X buf=0x%X len=%d res=%d sto=%d",
__func__, id, dev_addr, (int)buf, len, restart, stop);
reg_base = _i2c_get_base(id);
// update TAR
tar = i2cip_r_target_address_reg(reg_base);
if (tar != dev_addr) {
timeout = MS_TO_TICKS(HAL_I2C_WAIT_ACT_MS);
start_time = hal_sys_timer_get();
while ((i2cip_r_status(reg_base) & I2CIP_STATUS_ACT_MASK)) {
if (hal_sys_timer_get() - start_time >= timeout) {
HAL_I2C_TRACE(1, "%s:wait bus idle timeout", __func__);
ret = HAL_I2C_ERRCODE_ACT_TIMEOUT;
goto exit;
}
if (yield) {
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
}
}
i2cip_w_enable(reg_base, HAL_I2C_NO);
i2cip_w_target_address(reg_base, dev_addr);
i2cip_w_enable(reg_base, HAL_I2C_YES);
HAL_I2C_TRACE(3, "%s:update tar to 0x%02X from 0x%02X", __func__, dev_addr,
tar);
}
// check error
if (_i2c_check_raw_int_status(reg_base,
I2CIP_RAW_INT_STATUS_TX_ABRT_MASK |
I2CIP_RAW_INT_STATUS_TX_OVER_MASK |
I2CIP_RAW_INT_STATUS_RX_OVER_MASK |
I2CIP_RAW_INT_STATUS_RX_UNDER_MASK)) {
i2cip_r_clr_all_intr(reg_base);
i2c_clear_special_tx_abrt(reg_base);
HAL_I2C_TRACE(1, "clear error status done before xfer: status=0x%X",
i2cip_r_raw_int_status(reg_base));
}
// start to transmit
wrcnt = 0;
for (i = 0; i < len; i++) {
if (i == 0) {
res = restart ? I2CIP_CMD_DATA_RESTART_MASK : 0;
} else {
res = 0;
}
if (i == (len - 1)) {
sto = stop ? I2CIP_CMD_DATA_STOP_MASK : 0;
} else {
sto = 0;
}
timeout = MS_TO_TICKS(HAL_I2C_WAIT_TFNF_MS);
start_time = hal_sys_timer_get();
while (!(i2cip_r_status(reg_base) & I2CIP_STATUS_TFNF_MASK)) {
ret = _i2c_check_raw_int_status(reg_base,
I2CIP_RAW_INT_STATUS_TX_ABRT_MASK);
if (ret) {
i2c_clear_special_tx_abrt(reg_base);
HAL_I2C_TRACE(2, "%s:error 0x%X", __func__, ret);
goto exit;
}
if (hal_sys_timer_get() - start_time >= timeout) {
HAL_I2C_TRACE(1, "%s:wait tfnf timeout", __func__);
ret = HAL_I2C_ERRCODE_TFNF_TIMEOUT;
goto exit;
}
if (yield) {
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
}
}
i2cip_w_cmd_data(reg_base,
buf[i] | res | sto | I2CIP_CMD_DATA_CMD_WRITE_MASK);
HAL_I2C_TRACE(4, "send write cmd: data[%d]=0x%02X res=0x%X sto=0x%X", i,
buf[i], res, sto);
wrcnt++;
}
if (act_write)
*act_write = wrcnt;
if (stop) {
// wait bus idle
timeout = MS_TO_TICKS(HAL_I2C_WAIT_ACT_MS);
start_time = hal_sys_timer_get();
while (i2cip_r_status(reg_base) & I2CIP_STATUS_ACT_MASK) {
if (hal_sys_timer_get() - start_time >= timeout) {
if (_i2c_check_raw_int_status(reg_base,
I2CIP_RAW_INT_STATUS_TX_ABRT_MASK)) {
i2cip_r_clr_all_intr(reg_base);
i2c_clear_special_tx_abrt(reg_base);
HAL_I2C_TRACE(0, "clear error status done after xfer");
}
HAL_I2C_TRACE(1, "%s:wait act timeout", __func__);
ret = HAL_I2C_ERRCODE_ACT_TIMEOUT;
goto exit;
}
if (yield) {
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
}
}
} else {
// wait until txfifo empty
timeout = MS_TO_TICKS(HAL_I2C_WAIT_TFE_MS);
start_time = hal_sys_timer_get();
while (!(i2cip_r_status(reg_base) & I2CIP_STATUS_TFE_MASK)) {
if (hal_sys_timer_get() - start_time >= timeout) {
HAL_I2C_TRACE(1, "%s:wait tfe timeout", __func__);
ret = HAL_I2C_ERRCODE_TFE_TIMEOUT;
goto exit;
}
if (yield) {
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
}
}
}
HAL_I2C_TRACE(1, "%s:done", __func__);
return 0;
exit:
HAL_I2C_TRACE(3, "%s:error=0x%X, status=0x%X", __func__, ret,
i2cip_r_raw_int_status(reg_base));
return ret;
}
uint32_t hal_i2c_mst_read(enum HAL_I2C_ID_T id, uint32_t dev_addr, uint8_t *buf,
uint32_t len, uint32_t *act_read, uint32_t restart,
uint32_t stop, uint32_t yield) {
uint32_t i, j, tar, rdcnt, wrcnt, ret = 0;
uint32_t reg_base;
uint32_t start_time, timeout;
uint32_t res, sto;
uint8_t tmp;
uint8_t rx_ongoing, tx_limit;
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].cfg.mode != HAL_I2C_API_MODE_SIMPLE) {
HAL_I2C_TRACE(0, "mst_read: not simple mode");
return HAL_I2C_ERRCODE_INV_PARAM;
}
HAL_I2C_TRACE(7, "%s:id=%d addr=0x%02X buf=0x%X len=%d res=%d sto=%d",
__func__, id, dev_addr, (int)buf, len, restart, stop);
reg_base = _i2c_get_base(id);
// update TAR
tar = i2cip_r_target_address_reg(reg_base);
if (tar != dev_addr) {
timeout = MS_TO_TICKS(HAL_I2C_WAIT_ACT_MS);
start_time = hal_sys_timer_get();
while ((i2cip_r_status(reg_base) & I2CIP_STATUS_ACT_MASK)) {
if (hal_sys_timer_get() - start_time >= timeout) {
HAL_I2C_TRACE(1, "%s:wait bus idle timeout", __func__);
ret = HAL_I2C_ERRCODE_ACT_TIMEOUT;
goto exit;
}
if (yield) {
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
}
}
i2cip_w_enable(reg_base, HAL_I2C_NO);
i2cip_w_target_address(reg_base, dev_addr);
i2cip_w_enable(reg_base, HAL_I2C_YES);
HAL_I2C_TRACE(3, "%s:update tar to 0x%02X from 0x%02X", __func__, dev_addr,
tar);
}
// clear fifo by reading
j = i2cip_r_rx_fifo_level(reg_base);
if (j) {
for (i = 0; i < j; i++) {
tmp = i2cip_r_cmd_data(reg_base);
HAL_I2C_TRACE(2, "%s:discard data 0x%02X", __func__, tmp);
}
}
// check error
if (_i2c_check_raw_int_status(reg_base,
I2CIP_RAW_INT_STATUS_TX_ABRT_MASK |
I2CIP_RAW_INT_STATUS_TX_OVER_MASK |
I2CIP_RAW_INT_STATUS_RX_OVER_MASK |
I2CIP_RAW_INT_STATUS_RX_UNDER_MASK)) {
i2cip_r_clr_all_intr(reg_base);
i2c_clear_special_tx_abrt(reg_base);
HAL_I2C_TRACE(1, "clear error status done before xfer, status=0x%X",
i2cip_r_raw_int_status(reg_base));
}
// read data
timeout = MS_TO_TICKS(HAL_I2C_WAIT_RFNE_MS);
start_time = hal_sys_timer_get();
wrcnt = 0;
rdcnt = 0;
while (rdcnt < len) {
// send reading cmd
rx_ongoing =
i2cip_r_tx_fifo_level(reg_base) + i2cip_r_rx_fifo_level(reg_base) + 1;
if (rx_ongoing < I2CIP_RX_FIFO_DEPTH) {
tx_limit = I2CIP_RX_FIFO_DEPTH - rx_ongoing;
} else {
tx_limit = 0;
}
for (i = 0; i < tx_limit && wrcnt < len; i++, wrcnt++) {
if (!(i2cip_r_status(reg_base) & I2CIP_STATUS_TFNF_MASK)) {
break;
}
if (wrcnt == 0) {
res = restart ? I2CIP_CMD_DATA_RESTART_MASK : 0;
} else {
res = 0;
}
if (wrcnt == len - 1) {
sto = stop ? I2CIP_CMD_DATA_STOP_MASK : 0;
} else {
sto = 0;
}
i2cip_w_cmd_data(reg_base, I2CIP_CMD_DATA_CMD_READ_MASK | res | sto);
HAL_I2C_TRACE(3, "send read cmd: [%u] res=0x%X, sto=0x%X", wrcnt, res,
sto);
}
if (i2cip_r_status(reg_base) & I2CIP_STATUS_RFNE_MASK) {
tmp = i2cip_r_cmd_data(reg_base);
HAL_I2C_TRACE(2, "i2c recv [%u] 0x%02X", rdcnt, tmp);
if (buf) {
buf[rdcnt++] = tmp;
}
start_time = hal_sys_timer_get();
} else {
if (hal_sys_timer_get() - start_time >= timeout) {
HAL_I2C_TRACE(1, "%s:wait rfne timeout", __func__);
ret = HAL_I2C_ERRCODE_RFNE_TIMEOUT;
goto exit;
}
if (yield) {
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
}
}
}
if (act_read)
*act_read = rdcnt;
if (stop) {
timeout = MS_TO_TICKS(HAL_I2C_WAIT_ACT_MS);
start_time = hal_sys_timer_get();
while (i2cip_r_status(reg_base) & I2CIP_STATUS_ACT_MASK) {
if (hal_sys_timer_get() - start_time >= timeout) {
HAL_I2C_TRACE(1, "%s:wait act timeout", __func__);
ret = HAL_I2C_ERRCODE_ACT_TIMEOUT;
goto exit;
}
if (yield) {
hal_i2c_delay_ms(HAL_I2C_DLY_MS);
}
}
}
HAL_I2C_TRACE(1, "%s:done", __func__);
return 0;
exit:
HAL_I2C_TRACE(3, "%s:error=0x%X, status=0x%X", __func__, ret,
i2cip_r_raw_int_status(reg_base));
return ret;
}
uint32_t hal_i2c_simple_send(enum HAL_I2C_ID_T id, uint16_t device_addr,
const uint8_t *tx_buf, uint16_t tx_len) {
return hal_i2c_mst_write(id, device_addr, tx_buf, tx_len, NULL, true, true,
false);
}
uint32_t hal_i2c_simple_recv(enum HAL_I2C_ID_T id, uint16_t device_addr,
const uint8_t *tx_buf, uint16_t tx_len,
uint8_t *rx_buf, uint16_t rx_len) {
int ret;
ret = hal_i2c_mst_write(id, device_addr, tx_buf, tx_len, NULL, true, false,
false);
if (ret) {
HAL_I2C_TRACE(2, "%s: mst_write failed: ret=%d", __func__, ret);
return ret;
}
return hal_i2c_mst_read(id, device_addr, rx_buf, rx_len, NULL, true, true,
false);
}
uint32_t hal_i2c_set_interrupt_handler(enum HAL_I2C_ID_T id,
HAL_I2C_INT_HANDLER_T handler) {
hal_i2c_int_handlers[id] = handler;
return 0;
}
#endif
/* simple mode end */
/* sensor engine mode */
#ifdef I2C_SENSOR_ENGINE
static void hal_i2c_sensor_eng_proc(enum HAL_I2C_ID_T id) {
HAL_I2C_TRACE(2, "%s: id=%d", __func__, id);
uint32_t reg_base = _i2c_get_base(id);
uint32_t irq_status = i2cip_r_int_status(reg_base);
uint32_t POSSIBLY_UNUSED irq_raw_status = i2cip_r_raw_int_status(reg_base);
uint32_t abt_source = i2cip_r_tx_abrt_source(reg_base);
enum HAL_I2C_SM_TASK_STATE_T task_state;
task_state = _i2c_chk_clr_task_error(reg_base, irq_status, abt_source);
HAL_I2C_TRACE(5, "%s: id=%d irq=0x%X/0x%X abt=0x%X", __func__, id, irq_status,
irq_raw_status, abt_source);
_i2c_show_error_code(abt_source);
if (task_state &
(HAL_I2C_SM_TASK_STATE_TX_ABRT | HAL_I2C_SM_TASK_STATE_FIFO_ERR)) {
HAL_I2C_ERROR(
6, "*** Error:%s: id=%d task_state=0x%X irq=0x%X/0x%X abt=0x%X",
__func__, id, task_state, irq_status, irq_raw_status, abt_source);
hal_i2c_sensor_engine_stop(i2c_sensor_id[id]);
}
}
static void _sensor_irq_handler(enum HAL_SENSOR_ENGINE_ID_T id,
enum HAL_SENSOR_ENGINE_DEVICE_T device,
const uint8_t *buf, uint32_t len) {
enum HAL_I2C_ID_T i2c_id;
i2c_id = HAL_I2C_ID_0 + (device - HAL_SENSOR_ENGINE_DEVICE_I2C0);
ASSERT(i2c_id < HAL_I2C_ID_NUM, invalid_id, i2c_id);
if (i2c_sensor_handler[i2c_id]) {
i2c_sensor_handler[i2c_id](i2c_id, buf, len);
}
}
uint32_t
hal_i2c_sensor_engine_start(enum HAL_I2C_ID_T id,
const struct HAL_I2C_SENSOR_ENGINE_CONFIG_T *cfg) {
enum HAL_I2C_SM_TASK_ACTION_T action;
const struct HAL_I2C_SM_TASK_T *out_task;
struct HAL_SENSOR_ENGINE_CFG_T sensor_cfg;
uint32_t reg_base;
HAL_I2C_ERROR(2, "%s: id=%d", __func__, id);
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].cfg.mode != HAL_I2C_API_MODE_SENSOR_ENGINE) {
HAL_I2C_TRACE(1, "i2c-se start: not sensor engine mode: %d",
hal_i2c_sm[id].cfg.mode);
return HAL_I2C_ERRCODE_INV_PARAM;
}
if (hal_i2c_sm[id].state != HAL_I2C_SM_IDLE) {
HAL_I2C_TRACE(1, "i2c-se start: not idle: %d", hal_i2c_sm[id].state);
return HAL_I2C_ERRCODE_INV_PARAM;
}
reg_base = _i2c_get_base(id);
action = HAL_I2C_SM_TASK_ACTION_M_RECV;
hal_i2c_sm[id].state = HAL_I2C_SM_RUNNING;
hal_i2c_sm_commit(id, cfg->write_buf, cfg->write_txn_len, cfg->read_buf,
cfg->read_txn_len, cfg->txn_cnt, cfg->target_addr, action,
0, NULL);
out_task = &(hal_i2c_sm[id].task[hal_i2c_sm[id].out_task]);
hal_i2c_dma_config(id, out_task);
i2c_sensor_id[id] = cfg->id;
i2c_sensor_handler[id] = cfg->handler;
memset(&sensor_cfg, 0, sizeof(sensor_cfg));
sensor_cfg.id = cfg->id;
sensor_cfg.device = (id == HAL_I2C_ID_0) ? HAL_SENSOR_ENGINE_DEVICE_I2C0
: HAL_SENSOR_ENGINE_DEVICE_I2C1;
sensor_cfg.trigger_type = cfg->trigger_type;
sensor_cfg.trigger_gpio = cfg->trigger_gpio;
sensor_cfg.period_us = cfg->period_us;
sensor_cfg.device_address = cfg->target_addr;
sensor_cfg.tx_dma_cfg = &hal_i2c_sm[id].tx_dma_cfg;
sensor_cfg.rx_dma_cfg = &hal_i2c_sm[id].rx_dma_cfg;
sensor_cfg.rx_burst_len = cfg->read_txn_len * cfg->txn_cnt;
sensor_cfg.rx_burst_cnt = cfg->read_burst_cnt;
sensor_cfg.handler = _sensor_irq_handler;
;
#ifdef I2C_VAD
sensor_cfg.data_to_vad = 1;
i2cip_w_data_to_vad(reg_base, HAL_I2C_YES);
#endif
hal_sensor_engine_open(&sensor_cfg);
/* tx : quarter trigger TX EMPTY INT */
i2cip_w_tx_threshold(reg_base, HAL_I2C_TX_TL);
if (action == HAL_I2C_SM_TASK_ACTION_M_RECV) {
/* rx : three quarter trigger RX FULL INT */
i2cip_w_rx_threshold(reg_base, HAL_I2C_RX_TL);
}
i2cip_init_int_mask(reg_base, I2CIP_INT_MASK_ERROR_MASK);
i2cip_w_restart(reg_base, HAL_I2C_YES);
i2cip_w_target_address(reg_base, out_task->target_addr);
return 0;
}
uint32_t hal_i2c_sensor_engine_stop(enum HAL_I2C_ID_T id) {
uint32_t reg_base;
uint32_t irq_status;
uint32_t abt_source;
HAL_I2C_ERROR(2, "%s: id=%d", __func__, id);
ASSERT(id < HAL_I2C_ID_NUM, invalid_id, id);
if (hal_i2c_sm[id].cfg.mode != HAL_I2C_API_MODE_SENSOR_ENGINE) {
HAL_I2C_TRACE(1, "i2c-se stop: not sensor engine mode: %d",
hal_i2c_sm[id].cfg.mode);
return HAL_I2C_ERRCODE_INV_PARAM;
}
if (hal_i2c_sm[id].state != HAL_I2C_SM_RUNNING) {
HAL_I2C_TRACE(1, "i2c-se stop: not running: %d", hal_i2c_sm[id].state);
return HAL_I2C_ERRCODE_INV_PARAM;
}
hal_sensor_engine_close(i2c_sensor_id[id]);
hal_i2c_dma_release(id);
reg_base = _i2c_get_base(id);
HAL_I2C_TRACE(0, "disable i2c");
i2cip_w_enable(reg_base, HAL_I2C_NO);
irq_status = i2cip_r_int_status(reg_base);
abt_source = i2cip_r_tx_abrt_source(reg_base);
_i2c_chk_clr_task_error(reg_base, irq_status, abt_source);
#ifdef I2C_VAD
i2cip_w_data_to_vad(reg_base, HAL_I2C_NO);
#endif
hal_i2c_sm_done(id);
return 0;
}
#endif
/* sensor engine mode end */
/* gpio iic mode */
#include "hal_gpio.h"
static uint8_t g_i2c_open = false;
#define DURATION_INIT_1 600
#define DURATION_INIT_2 600
#define DURATION_INIT_3 600
#define DURATION_START_1 600
#define DURATION_START_2 600
#define DURATION_START_3 600
#define DURATION_STOP_1 800
#define DURATION_STOP_2 600
#define DURATION_STOP_3 1300
#define DURATION_HIGH 900
#define DURATION_LOW 600
#define HAL_GPIO_I2C_DELAY(duration) hal_sys_timer_delay_ns(duration);
struct HAL_GPIO_I2C_CONFIG_T hal_gpio_i2c_cfg;
inline void GPIO_InitIO(uint8_t port, uint8_t direction, uint8_t val_for_out) {
hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)port,
(enum HAL_GPIO_DIR_T)direction, val_for_out);
}
inline void GPIO_WriteIO(uint8_t port, uint8_t data) {
if (data) {
hal_gpio_pin_set((enum HAL_GPIO_PIN_T)port);
} else {
hal_gpio_pin_clr((enum HAL_GPIO_PIN_T)port);
}
}
inline uint8_t GPIO_ReadIO(uint8_t port) {
uint8_t level = 0;
level = hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)port);
return level;
}
//
//-------------------------------------------------------------------
// Function: gpio_i2c_init
// Purpose: This function is used to init I2C port of the device
// In:
// Return: bool
//-------------------------------------------------------------------
static int hal_gpio_i2c_initialize(const struct HAL_GPIO_I2C_CONFIG_T *cfg) {
struct HAL_IOMUX_PIN_FUNCTION_MAP hal_gpio_i2c_iomux_cfg[] = {
{HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
HAL_IOMUX_PIN_PULLUP_ENABLE},
{HAL_IOMUX_PIN_NUM, HAL_IOMUX_FUNC_GPIO, HAL_IOMUX_PIN_VOLTAGE_VIO,
HAL_IOMUX_PIN_PULLUP_ENABLE},
};
hal_gpio_i2c_cfg.scl = cfg->scl;
hal_gpio_i2c_cfg.sda = cfg->sda;
hal_gpio_i2c_iomux_cfg[0].pin = (enum HAL_IOMUX_PIN_T)hal_gpio_i2c_cfg.scl;
hal_gpio_i2c_iomux_cfg[1].pin = (enum HAL_IOMUX_PIN_T)hal_gpio_i2c_cfg.sda;
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)hal_gpio_i2c_iomux_cfg,
sizeof(hal_gpio_i2c_iomux_cfg) /
sizeof(struct HAL_IOMUX_PIN_FUNCTION_MAP));
HAL_I2C_TRACE(2, "hal_gpio_i2c_initialize scl=%d sda=%d",
hal_gpio_i2c_cfg.scl, hal_gpio_i2c_cfg.sda);
// iTemp = hal_gpio_i2c_cfg.scl | hal_gpio_i2c_cfg.sda ;
// Set the GPIO pin to output status
GPIO_InitIO(hal_gpio_i2c_cfg.scl, 1, 1);
GPIO_InitIO(hal_gpio_i2c_cfg.sda, 1, 1);
HAL_GPIO_I2C_DELAY(DURATION_INIT_1);
// Make the I2C bus in idle status
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1);
HAL_GPIO_I2C_DELAY(DURATION_INIT_1);
GPIO_WriteIO(hal_gpio_i2c_cfg.sda, 1);
HAL_GPIO_I2C_DELAY(DURATION_INIT_1);
for (byte i = 0; i < 30; i++) {
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0); /* low */
HAL_GPIO_I2C_DELAY(DURATION_LOW);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1);
HAL_GPIO_I2C_DELAY(DURATION_HIGH);
}
return 0;
}
static void hal_gpio_i2c_start(void) /* start or re-start */
{
GPIO_InitIO(hal_gpio_i2c_cfg.sda, 1, 1);
GPIO_WriteIO(hal_gpio_i2c_cfg.sda, 1);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1);
HAL_GPIO_I2C_DELAY(DURATION_START_1);
GPIO_WriteIO(hal_gpio_i2c_cfg.sda, 0);
HAL_GPIO_I2C_DELAY(DURATION_START_2);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0);
HAL_GPIO_I2C_DELAY(DURATION_START_3); /* start condition */
}
static void hal_gpio_i2c_stop(void) {
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0);
HAL_GPIO_I2C_DELAY(DURATION_LOW);
GPIO_InitIO(hal_gpio_i2c_cfg.sda, 1, 0);
GPIO_WriteIO(hal_gpio_i2c_cfg.sda, 0);
HAL_GPIO_I2C_DELAY(DURATION_STOP_1);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1);
HAL_GPIO_I2C_DELAY(DURATION_STOP_2);
GPIO_WriteIO(hal_gpio_i2c_cfg.sda, 1); /* stop condition */
HAL_GPIO_I2C_DELAY(DURATION_STOP_3);
}
static uint8_t hal_gpio_i2c_txbyte(uint8_t data) /* return 0 --> ack */
{
int i;
uint8_t temp_value = 0;
for (i = 7; (i >= 0) && (i <= 7); i--) {
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0); /* low */
HAL_GPIO_I2C_DELAY(DURATION_LOW);
if (i == 7)
GPIO_InitIO(hal_gpio_i2c_cfg.sda, 1, 0);
HAL_GPIO_I2C_DELAY(DURATION_LOW);
GPIO_WriteIO(hal_gpio_i2c_cfg.sda, ((data >> i) & 0x01));
HAL_GPIO_I2C_DELAY(DURATION_LOW / 2);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1); /* high */
HAL_GPIO_I2C_DELAY(DURATION_HIGH);
}
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0); /* low */
HAL_GPIO_I2C_DELAY(DURATION_LOW);
GPIO_InitIO(hal_gpio_i2c_cfg.sda, 0, 1); /* input */
HAL_GPIO_I2C_DELAY(DURATION_LOW / 2);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1); /* high */
HAL_GPIO_I2C_DELAY(DURATION_HIGH);
temp_value = GPIO_ReadIO(hal_gpio_i2c_cfg.sda);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0); /* low */
HAL_GPIO_I2C_DELAY(DURATION_LOW);
return temp_value;
}
static void hal_gpio_i2c_rxbyte(uint8_t *data, uint8_t ack) {
int i;
uint32_t dataCache;
dataCache = 0;
for (i = 7; (i >= 0) && (i <= 7); i--) {
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0);
HAL_GPIO_I2C_DELAY(DURATION_LOW);
if (i == 7)
GPIO_InitIO(hal_gpio_i2c_cfg.sda, 0, 1);
HAL_GPIO_I2C_DELAY(DURATION_LOW);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1);
HAL_GPIO_I2C_DELAY(DURATION_HIGH);
dataCache |= (GPIO_ReadIO(hal_gpio_i2c_cfg.sda) << i);
HAL_GPIO_I2C_DELAY(DURATION_LOW / 2);
}
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0);
HAL_GPIO_I2C_DELAY(DURATION_LOW);
GPIO_InitIO(hal_gpio_i2c_cfg.sda, 1, 1);
GPIO_WriteIO(hal_gpio_i2c_cfg.sda, ack);
HAL_GPIO_I2C_DELAY(DURATION_LOW / 2);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 1);
HAL_GPIO_I2C_DELAY(DURATION_HIGH);
GPIO_WriteIO(hal_gpio_i2c_cfg.scl, 0); /* low */
HAL_GPIO_I2C_DELAY(DURATION_LOW);
*data = (uint8_t)dataCache;
}
uint32_t hal_gpio_i2c_simple_send(uint32_t device_addr, const uint8_t *tx_buf,
uint16_t tx_len) {
uint32_t i;
hal_gpio_i2c_start();
if (device_addr & HAL_I2C_10BITADDR_MASK) {
hal_gpio_i2c_txbyte(0xF0 | ((device_addr & 0x200) >> 7));
hal_gpio_i2c_txbyte(device_addr & 0xFF);
} else {
hal_gpio_i2c_txbyte((device_addr & 0x7F) << 1);
}
for (i = 0; i < tx_len; i++, tx_buf++) {
hal_gpio_i2c_txbyte(*tx_buf);
}
hal_gpio_i2c_stop();
return 0;
}
uint32_t hal_gpio_i2c_simple_recv(uint32_t device_addr, const uint8_t *tx_buf,
uint16_t tx_len, uint8_t *rx_buf,
uint16_t rx_len) {
uint8_t tempdata;
uint32_t i;
if (tx_len) {
hal_gpio_i2c_start();
if (device_addr & HAL_I2C_10BITADDR_MASK) {
hal_gpio_i2c_txbyte(((device_addr & 0x200) >> 7) | 0xF0);
hal_gpio_i2c_txbyte(device_addr & 0xFF);
} else {
hal_gpio_i2c_txbyte((device_addr & 0x7F) << 1);
}
for (i = 0; i < tx_len; i++, tx_buf++) {
hal_gpio_i2c_txbyte(*tx_buf);
}
}
hal_gpio_i2c_start();
if (device_addr & HAL_I2C_10BITADDR_MASK) {
hal_gpio_i2c_txbyte(((device_addr & 0x200) >> 7) | 0xF1);
} else {
hal_gpio_i2c_txbyte(((device_addr & 0x7F) << 1) | 1);
}
for (i = 0; i < rx_len; i++, rx_buf++) {
hal_gpio_i2c_rxbyte(&tempdata, (i == rx_len - 1));
*rx_buf = tempdata;
}
hal_gpio_i2c_stop();
return 0;
}
#define touch_ic_device_addr 0x60
unsigned char I2C_WriteByte(unsigned char reg, unsigned char data) {
unsigned char result;
unsigned char buff[2];
buff[0] = reg;
buff[1] = data;
result =
hal_gpio_i2c_simple_send((unsigned char)touch_ic_device_addr, buff, 2);
return result;
}
unsigned char I2C_ReadByte(unsigned char reg, unsigned char *data) {
unsigned char result;
result = hal_gpio_i2c_simple_recv((unsigned char)touch_ic_device_addr, &reg,
1, data, 1);
return result;
}
int hal_gpio_i2c_open(const struct HAL_GPIO_I2C_CONFIG_T *cfg) {
static bool i2cInitDone = false;
int lock;
if (g_i2c_open == true) {
return -1;
}
lock = int_lock();
g_i2c_open = 0;
int_unlock(lock);
if (!i2cInitDone) {
hal_gpio_i2c_initialize(cfg);
i2cInitDone = 0;
}
return 0;
}
int hal_gpio_i2c_close(void) {
int lock;
if (g_i2c_open == false) {
return false;
}
lock = int_lock();
g_i2c_open = false;
int_unlock(lock);
return 0;
}
uint32_t hal_gpio_i2c_send(uint32_t device_addr, const uint8_t *buf,
uint32_t reg_len, uint32_t value_len) {
return hal_gpio_i2c_simple_send(device_addr, buf, reg_len + value_len);
}
uint32_t hal_gpio_i2c_recv(uint32_t device_addr, uint8_t *buf, uint32_t reg_len,
uint32_t value_len, uint8_t restart_after_write) {
return hal_gpio_i2c_simple_recv(device_addr, buf, reg_len, buf + reg_len,
value_len);
}
/* gpio iic end */
int app_i2c_demo_init(void) {
static struct HAL_GPIO_I2C_CONFIG_T i2c_cfg = {
HAL_GPIO_PIN_P2_0,
HAL_GPIO_PIN_P2_1,
0,
};
hal_gpio_i2c_open(&i2c_cfg);
return 0;
}
Reference in a new issue View git blame Copy permalink