/*
 *
 * 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