375 lines
12 KiB
C
375 lines
12 KiB
C
/***************************************************************************
|
|
*
|
|
* 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.
|
|
*
|
|
****************************************************************************/
|
|
#ifndef __HAL_I2CIP_H__
|
|
#define __HAL_I2CIP_H__
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "plat_types.h"
|
|
#include "reg_i2cip.h"
|
|
|
|
#define i2cip_read32(b,a) \
|
|
(*(volatile uint32_t *)(b+a))
|
|
|
|
#define i2cip_write32(v,b,a) \
|
|
((*(volatile uint32_t *)(b+a)) = v)
|
|
|
|
static inline uint8_t i2cip_w_enable(uint32_t reg_base, uint8_t enable)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_ENABLE_REG_OFFSET);
|
|
if (enable)
|
|
val |= I2CIP_ENABLE_MASK;
|
|
else
|
|
val &= ~I2CIP_ENABLE_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_ENABLE_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_clear_ctrl(uint32_t reg_base)
|
|
{
|
|
i2cip_write32(0, reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_10bit_master(uint32_t reg_base, uint8_t enable)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
if (enable)
|
|
val |= I2CIP_10BITADDR_MASTER_MASK;
|
|
else
|
|
val &= ~I2CIP_10BITADDR_MASTER_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_r_ctrl_reg(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
}
|
|
static inline uint8_t i2cip_w_10bit_slave(uint32_t reg_base, uint8_t enable)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
if (enable)
|
|
val |= I2CIP_10BITADDR_SLAVE_MASK;
|
|
else
|
|
val &= ~I2CIP_10BITADDR_SLAVE_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_restart(uint32_t reg_base, uint8_t restart)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
if (restart)
|
|
val |= I2CIP_RESTART_ENABLE_MASK;
|
|
else
|
|
val &= ~I2CIP_RESTART_ENABLE_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_speed(uint32_t reg_base, uint32_t speed)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
val &= ~I2CIP_SPEED_MASK;
|
|
val |= speed;
|
|
i2cip_write32(val, reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_standard_speed_hcnt(uint32_t reg_base, uint32_t hcnt)
|
|
{
|
|
uint32_t val = 0;
|
|
val |= hcnt<<I2CIP_SS_SCL_HCNT_SHIFT;
|
|
i2cip_write32(val, reg_base, I2CIP_SS_SCL_HCNT_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_fast_speed_hcnt(uint32_t reg_base, uint32_t hcnt)
|
|
{
|
|
uint32_t val = 0;
|
|
val |= hcnt<<I2CIP_FS_SCL_HCNT_SHIFT;
|
|
i2cip_write32(val, reg_base, I2CIP_FS_SCL_HCNT_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_high_speed_hcnt(uint32_t reg_base, uint32_t hcnt)
|
|
{
|
|
uint32_t val = 0;
|
|
val |= hcnt<<I2CIP_HS_SCL_HCNT_SHIFT;
|
|
i2cip_write32(val, reg_base, I2CIP_HS_SCL_HCNT_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_standard_speed_lcnt(uint32_t reg_base, uint32_t lcnt)
|
|
{
|
|
uint32_t val = 0;
|
|
val |= lcnt<<I2CIP_SS_SCL_LCNT_SHIFT;
|
|
i2cip_write32(val, reg_base, I2CIP_SS_SCL_LCNT_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_fast_speed_lcnt(uint32_t reg_base, uint32_t lcnt)
|
|
{
|
|
uint32_t val = 0;
|
|
val |= lcnt<<I2CIP_FS_SCL_LCNT_SHIFT;
|
|
i2cip_write32(val, reg_base, I2CIP_FS_SCL_LCNT_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_high_speed_lcnt(uint32_t reg_base, uint32_t lcnt)
|
|
{
|
|
uint32_t val = 0;
|
|
val |= lcnt<<I2CIP_HS_SCL_LCNT_SHIFT;
|
|
i2cip_write32(val, reg_base, I2CIP_HS_SCL_LCNT_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint32_t i2cip_r_target_address_reg(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
}
|
|
static inline void i2cip_w_target_address_reg(uint32_t reg_base, uint32_t val)
|
|
{
|
|
i2cip_write32(val, reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
}
|
|
static inline uint8_t i2cip_w_target_address(uint32_t reg_base, uint32_t addr)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
val &= ~I2CIP_TARGET_ADDRESS_MASK;
|
|
val |= (addr<<I2CIP_TARGET_ADDRESS_SHIFT) & I2CIP_TARGET_ADDRESS_MASK;
|
|
if (addr & HAL_I2C_10BITADDR_MASK) {
|
|
val |= I2CIP_TARGET_ADDRESS_IC_10BITADDR_MASTER_MASK;
|
|
} else {
|
|
val &= ~I2CIP_TARGET_ADDRESS_IC_10BITADDR_MASTER_MASK;
|
|
}
|
|
i2cip_write32(val, reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_gc_or_start_bit(uint32_t reg_base, uint8_t set)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
if (set)
|
|
val |= I2CIP_TARGET_ADDRESS_GC_OR_START_MASK;
|
|
else
|
|
val &= ~I2CIP_TARGET_ADDRESS_GC_OR_START_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_special_bit(uint32_t reg_base, uint8_t set)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
if (set)
|
|
val |= I2CIP_TARGET_ADDRESS_SPECIAL_BIT_MASK;
|
|
else
|
|
val &= ~I2CIP_TARGET_ADDRESS_SPECIAL_BIT_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_TARGET_ADDRESS_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_address_as_slave(uint32_t reg_base, uint32_t addr)
|
|
{
|
|
uint32_t val = 0;
|
|
val |= addr<<I2CIP_ADDRESS_AS_SLAVE_SHIFT;
|
|
i2cip_write32(val, reg_base, I2CIP_ADDRESS_AS_SLAVE_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_init_int_mask(uint32_t reg_base, uint32_t mask)
|
|
{
|
|
uint32_t val = 0;
|
|
val = mask;
|
|
i2cip_write32(val, reg_base, I2CIP_INT_MASK_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_set_int_mask(uint32_t reg_base, uint32_t mask)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_INT_MASK_REG_OFFSET);
|
|
val |= mask;
|
|
i2cip_write32(val, reg_base, I2CIP_INT_MASK_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_clear_int_mask(uint32_t reg_base, uint32_t mask)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_INT_MASK_REG_OFFSET);
|
|
val &= ~mask;
|
|
i2cip_write32(val, reg_base, I2CIP_INT_MASK_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_disable_slave(uint32_t reg_base, uint8_t disable)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
if (disable)
|
|
val |= I2CIP_SLAVE_DISABLE_MASK;
|
|
else
|
|
val &= ~I2CIP_SLAVE_DISABLE_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_master_mode(uint32_t reg_base, uint8_t master_mode)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
if (master_mode)
|
|
val |= I2CIP_MASTER_MODE_MASK;
|
|
else
|
|
val &= ~I2CIP_MASTER_MODE_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_CTRL_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_rx_threshold(uint32_t reg_base, uint32_t th)
|
|
{
|
|
i2cip_write32(th, reg_base, I2CIP_RX_THRESHOLD_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_tx_threshold(uint32_t reg_base, uint32_t th)
|
|
{
|
|
i2cip_write32(th, reg_base, I2CIP_TX_THRESHOLD_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint8_t i2cip_w_cmd_data(uint32_t reg_base, uint32_t cmd_data)
|
|
{
|
|
i2cip_write32(cmd_data, reg_base, I2CIP_CMD_DATA_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint32_t i2cip_r_clr_tx_over(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_TX_OVER_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_rx_over(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_RX_OVER_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_rx_under(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_RX_UNDER_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_stop_det(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_STOP_DET_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_start_det(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_START_DET_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_tx_abrt(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_TX_ABRT_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_activity(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_ACTIVITY_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_all_intr(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_ALL_INTR_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_rd_req(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_RD_REQ_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_clr_rx_done(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CLR_RX_DONE_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_cmd_data(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_CMD_DATA_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_status(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_STATUS_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_int_status(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_INT_STATUS_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_raw_int_status(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_RAW_INT_STATUS_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_enable_status(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_ENABLE_STATUS_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_tx_fifo_level(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_TX_FIFO_LEVEL_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_rx_fifo_level(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_RX_FIFO_LEVEL_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_tx_abrt_source(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_TX_ABRT_SOURCE_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_w_tx_dma_enable(uint32_t reg_base, uint8_t enable)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_DMA_CR_REG_OFFSET);
|
|
if (enable)
|
|
val |= I2CIP_DMA_CR_TDMAE_MASK;
|
|
else
|
|
val &= ~I2CIP_DMA_CR_TDMAE_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_DMA_CR_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint32_t i2cip_w_rx_dma_enable(uint32_t reg_base, uint8_t enable)
|
|
{
|
|
uint32_t val = 0;
|
|
val = i2cip_read32(reg_base, I2CIP_DMA_CR_REG_OFFSET);
|
|
if (enable)
|
|
val |= I2CIP_DMA_CR_RDMAE_MASK;
|
|
else
|
|
val &= ~I2CIP_DMA_CR_RDMAE_MASK;
|
|
i2cip_write32(val, reg_base, I2CIP_DMA_CR_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
static inline uint32_t i2cip_w_tx_dma_tl(uint32_t reg_base, uint32_t val)
|
|
{
|
|
return i2cip_write32(val, reg_base, I2CIP_DMA_TX_TL_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_w_rx_dma_tl(uint32_t reg_base, uint32_t val)
|
|
{
|
|
return i2cip_write32(val, reg_base, I2CIP_DMA_RX_TL_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_w_sda_hold_time(uint32_t reg_base, uint32_t val)
|
|
{
|
|
return i2cip_write32(val, reg_base, I2CIP_SDA_HOLD_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_r_ic_enable_status(uint32_t reg_base)
|
|
{
|
|
return i2cip_read32(reg_base, I2CIP_IC_ENABLE_STATUS_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_w_fs_spklen(uint32_t reg_base, uint32_t val)
|
|
{
|
|
return i2cip_write32(val, reg_base, I2CIP_IC_FS_SPKLEN_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_w_hs_spklen(uint32_t reg_base, uint32_t val)
|
|
{
|
|
return i2cip_write32(val, reg_base, I2CIP_IC_HS_SPKLEN_REG_OFFSET);
|
|
}
|
|
static inline uint32_t i2cip_w_data_to_vad(uint32_t reg_base, uint32_t val)
|
|
{
|
|
i2cip_write32(val ? 1 : 0, reg_base, I2CIP_IC_VAD_PATH_REG_OFFSET);
|
|
return 0;
|
|
}
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* __HAL_I2CIP_H__ */
|