libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/essemi/es32vf2264/drivers/drv_i2c.c

348 lines
9.9 KiB
C
Raw Blame History

/*
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed 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
*
* 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.
*
* Change Logs:
* Date Author Notes
* 2019-11-01 wangyq update libraries
* 2020-01-14 wangyq the first version
* 2021-04-20 liuhy the second version
*/
#include <rthw.h>
#include <rtthread.h>
#include <rtdevice.h>
#include "board.h"
#include "drv_i2c.h"
#ifdef RT_USING_I2C
#define TIMEOUT 0x0FFF
/* I2C struct definition */
#ifdef BSP_USING_I2C0
static ald_i2c_handle_t _h_i2c0;
#endif
#ifdef BSP_USING_I2C1
static i2c_handle_t _h_i2c1;
#endif
static void _i2c_init(void)
{
ald_gpio_init_t gpio_instruct;
/* Initialize I2C Pin */
gpio_instruct.mode = ALD_GPIO_MODE_OUTPUT;
gpio_instruct.od = ALD_GPIO_OPEN_DRAIN;
gpio_instruct.pupd = ALD_GPIO_PUSH_UP;
gpio_instruct.odrv = ALD_GPIO_OUT_DRIVE_NORMAL;
gpio_instruct.flt = ALD_GPIO_FILTER_DISABLE;
gpio_instruct.type = ALD_GPIO_TYPE_CMOS;
#ifdef BSP_USING_I2C0
#if defined(ES_I2C0_SCL_GPIO_FUNC)&&defined(ES_I2C0_SCL_GPIO_PORT)&&defined(ES_I2C0_SCL_GPIO_PIN)
gpio_instruct.func = ES_I2C0_SCL_GPIO_FUNC;
ald_gpio_init(ES_I2C0_SCL_GPIO_PORT, ES_I2C0_SCL_GPIO_PIN, &gpio_instruct);
#endif
#if defined(ES_I2C0_SDA_GPIO_FUNC)&&defined(ES_I2C0_SDA_GPIO_PORT)&&defined(ES_I2C0_SDA_GPIO_PIN)
gpio_instruct.func = ES_I2C0_SDA_GPIO_FUNC;
ald_gpio_init(ES_I2C0_SDA_GPIO_PORT, ES_I2C0_SDA_GPIO_PIN, &gpio_instruct);
#endif
/* Initialize I2C Function */
_h_i2c0.perh = I2C0;
_h_i2c0.init.module = ALD_I2C_MODULE_MASTER;
_h_i2c0.init.clk_speed = ES_I2C0_CLK_SPEED;
_h_i2c0.init.own_addr1 = ES_I2C0_OWN_ADDR1;
_h_i2c0.init.addr_mode = ES_I2C0_ADDR_MODE;
_h_i2c0.init.general_call = ES_I2C0_GENERAL_CALL;
_h_i2c0.init.no_stretch = ES_I2C0_STRETCH;
ald_i2c_reset(&_h_i2c0);
ald_i2c_init(&_h_i2c0);
#endif
#ifdef BSP_USING_I2C1
#if defined(ES_I2C1_SCL_GPIO_FUNC)&&defined(ES_I2C1_SCL_GPIO_PORT)&&defined(ES_I2C1_SCL_GPIO_PIN)
gpio_instruct.func = ES_I2C1_SCL_GPIO_FUNC;
ald_gpio_init(ES_I2C1_SCL_GPIO_PORT, ES_I2C1_SCL_GPIO_PIN, &gpio_instruct);
#endif
#if defined(ES_I2C1_SDA_GPIO_FUNC)&&defined(ES_I2C1_SDA_GPIO_PORT)&&defined(ES_I2C1_SDA_GPIO_PIN)
gpio_instruct.func = ES_I2C1_SDA_GPIO_FUNC;
ald_gpio_init(ES_I2C1_SDA_GPIO_PORT, ES_I2C1_SDA_GPIO_PIN, &gpio_instruct);
#endif
/* Initialize i2c function */
_h_i2c1.perh = I2C1;
_h_i2c1.init.module = I2C_MODULE_MASTER;
_h_i2c1.init.clk_speed = ES_I2C1_CLK_SPEED;
_h_i2c1.init.own_addr1 = ES_I2C1_OWN_ADDR1;
_h_i2c1.init.addr_mode = ES_I2C1_ADDR_MODE;
_h_i2c1.init.general_call = ES_I2C1_GENERAL_CALL;
_h_i2c1.init.no_stretch = ES_I2C1_STRETCH;
ald_i2c_reset(&_h_i2c1);
ald_i2c_init(&_h_i2c1);
#endif
}
#define _I2C_NO_START 0x1
#define _I2C_NO_STOP 0x2
int _i2c_master_req(ald_i2c_handle_t *hperh, uint16_t dev_addr, uint32_t timeout,uint32_t req_write)
{
if (hperh->init.addr_mode == ALD_I2C_ADDR_7BIT) {
CLEAR_BIT(hperh->perh->CON2, I2C_CON2_ADD10_MSK);
}
else {
SET_BIT(hperh->perh->CON2, I2C_CON2_ADD10_MSK);
}
MODIFY_REG(hperh->perh->CON2, I2C_CON2_SADD_MSK, dev_addr << I2C_CON2_SADD_POSS);
if (req_write)
CLEAR_BIT(hperh->perh->CON2, I2C_CON2_RD_WRN_MSK);
else
SET_BIT(hperh->perh->CON2, I2C_CON2_RD_WRN_MSK);
return ALD_OK;
}
int _i2c_wait_flag(ald_i2c_handle_t *hperh, uint32_t flag, flag_status_t status, uint32_t timeout)
{
uint32_t tickstart = 0;
tickstart = ald_get_tick();
while (ALD_I2C_GET_FLAG(hperh, flag) == status) {
if ((timeout == 0) || ((ald_get_tick() - tickstart ) > timeout)) {
hperh->error_code |= ALD_I2C_ERROR_TIMEOUT;
return TIMEOUT;
}
}
return ALD_OK;
}
int _i2c_wait_txe(ald_i2c_handle_t *hperh, uint32_t timeout)
{
uint32_t tickstart = ald_get_tick();
while (ALD_I2C_GET_FLAG(hperh, ALD_I2C_STAT_TXE) == RESET) {
if (ALD_I2C_GET_IT_FLAG(hperh, ALD_I2C_IT_ARLO)) {
hperh->error_code |= ALD_I2C_ERROR_ARLO;
return ALD_ERROR;
}
if (ALD_I2C_GET_IT_FLAG(hperh, ALD_I2C_IT_NACK) == SET) {
hperh->error_code |= ALD_I2C_ERROR_AF;
return ALD_ERROR;
}
if ((timeout == 0) || ((ald_get_tick() - tickstart) > timeout)) {
hperh->error_code |= ALD_I2C_ERROR_TIMEOUT;
return ALD_ERROR;
}
}
return ALD_OK;
}
int _i2c_master_send(ald_i2c_handle_t *hperh, uint16_t dev_addr, uint8_t *buf,
uint32_t size, uint32_t timeout,uint32_t flag)
{
if (hperh->state != ALD_I2C_STATE_READY)
return ALD_BUSY;
if ((buf == NULL) || (size == 0))
return ALD_ERROR;
if ((flag&_I2C_NO_START)==0x0) //NOSTART==0
{
if (_i2c_wait_flag(hperh, ALD_I2C_STAT_BUSY, SET, 100) != ALD_OK)
return ALD_BUSY;
_i2c_master_req(hperh, dev_addr, timeout,1);
}
assert_param(IS_I2C_TYPE(hperh->perh));
__LOCK(hperh);
hperh->state = ALD_I2C_STATE_BUSY_TX;
hperh->mode = ALD_I2C_MODE_MASTER;
hperh->error_code = ALD_I2C_ERROR_NONE;
hperh->p_buff = buf;
hperh->xfer_size = size;
hperh->xfer_count = 0;
if ((flag&_I2C_NO_STOP)!=0) //NOSTOP==1
SET_BIT(hperh->perh->CON2, I2C_CON2_RELOAD_MSK);
else
CLEAR_BIT(hperh->perh->CON2, I2C_CON2_RELOAD_MSK);
if (size <= 0xFF) {
MODIFY_REG(hperh->perh->CON2, I2C_CON2_NBYTES_MSK, size << I2C_CON2_NBYTES_POSS);
}
else {
MODIFY_REG(hperh->perh->CON2, I2C_CON2_NBYTES_MSK, 0xFF << I2C_CON2_NBYTES_POSS);
SET_BIT(hperh->perh->CON2, I2C_CON2_RELOAD_MSK);
}
if ((flag&_I2C_NO_START)==0x0)
SET_BIT(hperh->perh->CON2, I2C_CON2_START_MSK);
while (size > 0) {
hperh->perh->TXDATA = (*buf++);
size--;
hperh->xfer_count++;
if (_i2c_wait_txe(hperh, timeout) != ALD_OK)
goto ERROR;
if (((hperh->xfer_count % 0xFF) == 0) && (READ_BIT(hperh->perh->CON2, I2C_CON2_RELOAD_MSK))) {
if (_i2c_wait_flag(hperh, ALD_I2C_STAT_TCR, RESET, 10) == ALD_OK) {
if (size > 0xFF) {
MODIFY_REG(hperh->perh->CON2, I2C_CON2_NBYTES_MSK, 0xFF << I2C_CON2_NBYTES_POSS);
}
else {
MODIFY_REG(hperh->perh->CON2, I2C_CON2_NBYTES_MSK, size << I2C_CON2_NBYTES_POSS);
if ((flag&_I2C_NO_STOP)==0)
CLEAR_BIT(hperh->perh->CON2, I2C_CON2_RELOAD_MSK);
}
}
else {
goto ERROR;
}
}
}
if (READ_BIT(hperh->perh->CON2, I2C_CON2_AUTOEND_MSK) == SET)
goto SUCCESS;
if ((flag&_I2C_NO_STOP)!=0&&_i2c_wait_flag(hperh, ALD_I2C_STAT_TCR, RESET, 10) == ALD_OK)
{
goto SUCCESS;
}
if (_i2c_wait_flag(hperh, ALD_I2C_STAT_TC, RESET, 10) == ALD_OK) {
if ((flag&_I2C_NO_STOP)==0x0)
SET_BIT(hperh->perh->CON2, I2C_CON2_STOP_MSK);
goto SUCCESS;
}
else {
goto ERROR;
}
ERROR:
SET_BIT(hperh->perh->CON2, I2C_CON2_STOP_MSK);
hperh->state = ALD_I2C_STATE_READY;
hperh->mode = ALD_I2C_MODE_NONE;
__UNLOCK(hperh);
return ALD_ERROR;
SUCCESS:
hperh->state = ALD_I2C_STATE_READY;
hperh->mode = ALD_I2C_MODE_NONE;
__UNLOCK(hperh);
return ALD_OK;
}
static rt_size_t es32f3_master_xfer(struct rt_i2c_bus_device *bus,
struct rt_i2c_msg msgs[],
rt_uint32_t num)
{
struct rt_i2c_msg *msg;
rt_uint32_t i;
rt_err_t ret = RT_ERROR;
for (i = 0; i < num; i++)
{
msg = &msgs[i];
if (msg->flags & RT_I2C_RD)
{
if (ald_i2c_master_recv(bus->priv, msg->addr << 1, msg->buf, msg->len, TIMEOUT) != 0)
{
LOG_E("i2c bus write failed,i2c bus stop!\n");
goto out;
}
}
else
{
uint32_t f=((msg->flags&RT_I2C_NO_START)?0x1:0)|((msg->flags&RT_I2C_NO_STOP)?0x2:0);
if (_i2c_master_send(bus->priv, msg->addr << 1, msg->buf, msg->len, TIMEOUT,f) != 0)
{
LOG_E("i2c bus write failed,i2c bus stop!\n");
goto out;
}
}
}
ret = i;
out:
//LOG_E("send stop condition\n");
return ret;
}
const struct rt_i2c_bus_device_ops es32f3_i2c_ops =
{
es32f3_master_xfer,
RT_NULL,
RT_NULL,
};
int rt_hw_i2c_init(void)
{
int result = RT_EOK;
_i2c_init();
#ifdef BSP_USING_I2C0
/* define i2c Instance */
static struct rt_i2c_bus_device _i2c_device0;
rt_memset((void *)&_i2c_device0, 0, sizeof(struct rt_i2c_bus_device));
_i2c_device0.ops = &es32f3_i2c_ops;
_i2c_device0.priv = &_h_i2c0;
result = rt_i2c_bus_device_register(&_i2c_device0, ES_DEVICE_NAME_I2C0);
if (result != RT_EOK)
{
return result;
}
#endif
#ifdef BSP_USING_I2C1
/* define i2c Instance */
static struct rt_i2c_bus_device _i2c_device1;
rt_memset((void *)&_i2c_device1, 0, sizeof(struct rt_i2c_bus_device));
_i2c_device1.ops = &es32f3_i2c_ops;
_i2c_device1.priv = &_h_i2c1;
rt_i2c_bus_device_register(&_i2c_device1, ES_DEVICE_NAME_I2C1);
if (result != RT_EOK)
{
return result;
}
#endif
return RT_EOK;
}
INIT_DEVICE_EXPORT(rt_hw_i2c_init);
#endif
View Git Blame Copy Permalink