/****************************************************************************
 *
 * Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
 *
 * This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics Ltd and MAY NOT
 * be copied by any method or incorporated into another program without
 * the express written consent of Aerospace C.Power. This Information or any portion
 * thereof remains the property of Aerospace C.Power. The Information contained herein
 * is believed to be accurate and Aerospace C.Power assumes no responsibility or
 * liability for its use in any way and conveys no license or title under
 * any patent or copyright and makes no representation or warranty that this
 * Information is free from patent or copyright infringement.
 *
 * ****************************************************************************/

 /* os shim includes */
#include "os_types.h"
#include "os_task.h"
#include "os_utils.h"
#include "iot_errno_api.h"

/* common includes */
#include "iot_io.h"
#include "iot_bitops.h"
#include "iot_pkt_api.h"
#include "iot_ipc.h"
#include "iot_plc_lib.h"
#include "iot_dbglog_api.h"
#include "iot_config.h"

/* driver includes */
#include "iot_clock.h"
#include "iot_uart.h"
#include "iot_led.h"

/* cli includes */
#include "iot_cli.h"
#include "iot_uart_h.h"

/* debug includes*/
#include "dbg_io.h"

#include "gpio.h"

#include "apb_glb_reg.h"
#include "hw_reg_api.h"

#include "gpio_mtx_reg.h"
#include "pin_rf.h"
#include "gpio_mtx.h"
#include "gpio_reg.h"
#include "i2c_reg.h"

#include "iot_i2c_api.h"
#include "iot_gpio_api.h"

#include "xc7027_reg.h"
#include "ov9282_reg.h"

struct mp3336_module_reg_t {
    uint8_t reg;
    uint8_t val;
};

const struct mp3336_module_reg_t mp3336_flash_mode[] = {
    {0x1, 0xE6},
    //{0x6, 0x33},
    {0x6, 200},
    {0x3, 0x18},
    {0x1, 0xF6},
};

iot_i2c_module_cfg_t g_cfg = {0};
iot_i2c_module_cfg_t g_sgm_cfg = {0};

extern int platform_init();
os_task_h test_init_handle;

int xc7027_gpio_rst(uint8_t gpio)
{
    uint8_t r = ERR_FAIL;
    r = iot_gpio_open_as_output(gpio);

    if(r != 0)
    {
        iot_printf("\ngpio_set_direction failed!\n");
    }

    if (0 != iot_gpio_value_set(gpio, 1)) {
        iot_printf("\n WRITE 0 FAILED\n");
        r = ERR_FAIL;
    } else {
        os_delay(1000);
        if (0 != iot_gpio_value_set(gpio, 0)) {
            iot_printf("\n WRITE 1 FAILED\n");
            r = ERR_FAIL;
        } else {
            r = ERR_OK;
        }
        os_delay(1000);
        if (0 != iot_gpio_value_set(gpio, 1)) {
            iot_printf("\n WRITE 1 FAILED\n");
            r = ERR_FAIL;
        } else {
            r = ERR_OK;
        }
    }
    return r;
}


int xc7027_write_command(uint8_t addr, uint8_t reg1, uint8_t reg2, uint8_t val)
{
    uint8_t ret = 0;
    char buf[4] = {0};
    buf[0] = reg1;
    buf[1] = reg2;
    buf[2] = val;

    ret = iot_i2c_write(g_cfg.port, addr, buf, 3);

    os_delay(10);

    return ret;
}

int ov9282_write_command(uint8_t addr, uint16_t reg, uint8_t val)
{
    uint8_t ret = 0;
    char buf[4] = {0};
    buf[0] = reg >> 8;
    buf[1] = reg & 0xff;
    buf[2] = val;

    ret = iot_i2c_write(g_cfg.port, addr, buf, 3);

    os_delay(10);

    return ret;
}

int xc7027_read_command(uint8_t addr, uint16_t reg, uint8_t *data, uint8_t len)
{
    uint8_t ret = 0;
    char buf[4] = {0};
    buf[0] = reg >> 8;
    buf[1] = reg & 0xff;

    ret = iot_i2c_write(g_cfg.port, addr, buf, 2);

    if (ret) {
        iot_printf("xc7027_read_command write addr error\n");
        return ret;
    }
    os_delay(10);
    ret = iot_i2c_read(g_cfg.port, addr, (char *)data, len);
    if (ret) {
        iot_printf("xc7027_read_command get value error\n");
        return ret;
    }
    return ret;
}

int mp3336_write_command(uint8_t addr, uint8_t reg, uint8_t val)
{
    uint8_t ret = 0;
    char buf[4] = {0};
    buf[0] = reg;
    buf[1] = val;

    ret = iot_i2c_write(g_sgm_cfg.port, addr, buf, 2);

    os_delay(10);

    return ret;
}

int mp3336_read_command(uint8_t addr, uint8_t reg, uint8_t *data, uint8_t len)
{
    uint8_t ret = 0;
    char buf[4] = {0};
    buf[0] = reg;

    ret = iot_i2c_write(g_sgm_cfg.port, addr, buf, 1);

    if (ret) {
        iot_printf("xc7027_read_command write addr error\n");
        return ret;
    }
    os_delay(10);
    ret = iot_i2c_read(g_sgm_cfg.port, addr, (char *)data, len);
    if (ret) {
        iot_printf("xc7027_read_command get value error\n");
        return ret;
    }
    return ret;
}

uint8_t g_xc7027_addr = 0x1b;
uint8_t g_ov9282_addr = 0x60;
uint8_t g_mp3336_addr = 0x27;
uint8_t g_xc7027_rst_gpio = 56;
uint8_t g_cfg_test = 0;

void mp3336_flash_mode_cfg()
{
    uint8_t val = 0;
    int reg_len = 0;
    uint8_t reg;

    reg_len = sizeof(mp3336_flash_mode)/sizeof(struct mp3336_module_reg_t);

    for(uint32_t i = 0; i<reg_len; i++) {
        reg = mp3336_flash_mode[i].reg;

        if(mp3336_read_command(g_mp3336_addr, reg, &val, 1)) {
            iot_printf("mp3336_read_command error\n");
        } else {
            iot_printf("read value: %02x, write mp3336 reg[%02x: %02x]\n",
                val, reg, mp3336_flash_mode[i].val);
            val = mp3336_flash_mode[i].val;
            if(mp3336_write_command(g_mp3336_addr, reg, val)) {
                iot_printf("write mp3336_flash_mode regs error[%d]\n", i);
            }
            os_delay(10);
            if (mp3336_read_command(g_mp3336_addr, reg, &val, 1)) {
                iot_printf("mp3336_read_command error\n");
            } else {
                iot_printf("read value: %02x\n", val);
            }
        }
    }
}

void i2c_test_task()
{

    g_cfg.port = IOT_I2C_PORT_0;
    g_cfg.nack_wait_num = 1;
    g_cfg.baud = 50;
    g_cfg.gpio.scl = 57;
    g_cfg.gpio.sda = 58;
    iot_i2c_module_init(&g_cfg);

    g_sgm_cfg.port = IOT_I2C_PORT_1;
    g_sgm_cfg.nack_wait_num = 1;
    g_sgm_cfg.baud = 50;
    g_sgm_cfg.gpio.scl = 59;
    g_sgm_cfg.gpio.sda = 60;
    iot_i2c_module_init(&g_sgm_cfg);

    if (xc7027_gpio_rst(g_xc7027_rst_gpio)) {
        iot_printf("xc7027 gpio reset failed\n");
    }

    // read 0xfffb value
    iot_printf("\n[read xc7027 reg]\n");
    uint8_t val = 0;
    if(xc7027_read_command(g_xc7027_addr, 0xfffb, &val, 1)) {
        iot_printf("xc7027_read_command error\n");
    } else {
        iot_printf("xc7027_read_command value: %02x\n", val);
    }
    os_delay(10);
    iot_printf("[read xc7027 reg]\n");

    // send xc7027 pattern
    iot_printf("\n[send xc7027 pattern]\n");
    int reg_len = 0;
    int ret = 0;
    uint16_t reg = 0;
    reg_len = sizeof(XC7027_default_regs);
    for(uint32_t i = 0; i<reg_len/3; i++)
    {
        reg = (uint16_t)(XC7027_default_regs[i*3] << 8) + XC7027_default_regs[i*3+1];
        iot_printf("write config reg[%04x: %02x]\n", reg, XC7027_default_regs[i*3+2]);
        ret = xc7027_write_command(g_xc7027_addr, XC7027_default_regs[i*3],
                XC7027_default_regs[i*3+1],
                XC7027_default_regs[i*3+2]);
        if (ret) {
            iot_printf("write XC7027_default_regs regs error[%d]\n", i);
        }

        if(xc7027_read_command(g_xc7027_addr, reg, &val, 1)) {
            iot_printf("xc7027_read_command error\n");
        } else {
            iot_printf("xc7027_read_command value: %02x\n", val);
            if (val != XC7027_default_regs[i*3+2]) {
                iot_printf("write 7027 failed, i=%d, reg:%04x, value:%02x-%02x\n",
                    i, reg, XC7027_default_regs[i*3+2], val);
                //while(1);
            }
        }
    }
    iot_printf("[send xc7027 pattern]\n");
    iot_printf("\n[send xc7027 bypass]\n");
    reg_len = sizeof(bypass_on);
    for(uint32_t i = 0; i<reg_len/3; i++)
    {
        reg = (uint16_t)(bypass_on[i*3] << 8) + bypass_on[i*3+1];
        iot_printf("write bypass reg[%04x: %02x]\n", reg, bypass_on[i*3+2]);
        ret = xc7027_write_command(g_xc7027_addr, bypass_on[i*3],
                bypass_on[i*3+1],
                bypass_on[i*3+2]);
        if (ret) {
            iot_printf("write bypass_on regs error[%d]\n", i);
        }

        if(xc7027_read_command(g_xc7027_addr, reg, &val, 1)) {
            iot_printf("xc7027_read_command error\n");
        } else {
            iot_printf("xc7027_read_command value: %02x\n", val);
            if (val != bypass_on[i*3+2]) {
                iot_printf("write bypass failed, i=%d, reg:%04x, value:%02x-%02x\n",
                    i, reg, bypass_on[i*3+2], val);
                //while(1);
            }
        }
    }
    iot_printf("[send xc7027 bypass]\n");

    // reset pin
    iot_printf("\n[reset xc7027 pin]\n");
    ret =  xc7027_write_command(g_xc7027_addr, 0x00, 0x58, 0x01);
    if (ret) {
        iot_printf("reset pin error\n");
    }
    iot_printf("[reset xc7027 pin]\n");

    os_delay(100);
    // read ov9282 ID reg: 0x300a
    iot_printf("\n[read ov9282 reg]\n");
    if(xc7027_read_command(g_ov9282_addr, 0x300a, &val, 1)) {
        iot_printf("xc7027_read_command error\n");
    } else {
        iot_printf("xc7027_read_command value: %02x\n", val);
    }
    if(xc7027_read_command(g_ov9282_addr, 0x300b, &val, 1)) {
        iot_printf("xc7027_read_command error\n");
    } else {
        iot_printf("xc7027_read_command value: %02x\n", val);
    }
    iot_printf("[read ov9282 reg]\n");

    // write ov9282 default reg
    os_delay(100);
    iot_printf("\n[write ov9282 pattern]\n");
    reg_len = sizeof(ov9282_init_tab_720_1280_30fps)/
        sizeof(struct ov_camera_module_reg);
    for(uint32_t i = 0; i<reg_len; i++)
    {
        reg = ov9282_init_tab_720_1280_30fps[i].reg;
        iot_printf("write 9282 reg[%04x: %02x]\n",
                reg, ov9282_init_tab_720_1280_30fps[i].val);
        ret = ov9282_write_command(g_ov9282_addr,
                ov9282_init_tab_720_1280_30fps[i].reg,
                ov9282_init_tab_720_1280_30fps[i].val);
        if (ret) {
            iot_printf("write XC7027_default_regs regs error[%d]\n", i);
        }
        os_delay(10);
        if(xc7027_read_command(g_ov9282_addr, reg, &val, 1)) {
            iot_printf("xc7027_read_command error\n");
        } else {
            iot_printf("xc7027_read_command value: %02x\n", val);
            if (val != ov9282_init_tab_720_1280_30fps[i].val) {
                iot_printf("write 9282 failed,i=%d,reg:%04x,value:%02x-%02x\n",
                    i, reg, ov9282_init_tab_720_1280_30fps[i].val, val);
                //while(1);
            }
        }
    }

    // write mp3336 reg, flash mode
    mp3336_flash_mode_cfg();

    while(1) {

        iot_printf("...........\n");
        if (g_cfg_test) {
            // clear ai ram to 0
            uint32_t *reg = (uint32_t *) 0x73000000;
            os_mem_set(reg, 0, 128*1024*2);
            g_cfg_test = 0;
        }
        os_delay(1000);
    }
}

void i2c_test_task_init()
{
   os_task_h handle;

   handle = os_create_task(i2c_test_task, NULL, 6);
   if(handle != NULL) {
       iot_printf("task create successfully...\n");
   }
}

void i2c_test_init()
{
    /* init common modules */
    iot_bitops_init();

    /* init os related modules and utilities */
    os_utils_init();

    /* gpio matrix enable */
    gpio_mtx_enable();

    /* init ipc module */
    iot_ipc_init();

    /*init uart module*/
    iot_uart_init(1);


    i2c_test_task_init();

}

void i2c_init_task(void *arg)
{
    iot_printf("task 1 entry....\n");

    for(;;) {
       i2c_test_init();
       os_delete_task(test_init_handle);
    }
}

int32_t i2c_task_init()
{
    /* start plc lib task */
    test_init_handle = os_create_task(i2c_init_task, NULL, 9);
    //create the tasks;
    if(test_init_handle != NULL) {
        iot_printf("task 1 init successfully...\n");
    }

    return 0;
}

int32_t i2c_task_start()
{
    os_start_kernel();

    return 0;
}

 int32_t iot_platform_init()
{
    platform_init();
    system_clock_init();
    system_uart_init();
    dbg_uart_init();

  iot_led_init();
    return 0;
}

int32_t iot_module_init(void)
{
    //platform intialization;
    iot_platform_init();
    //create all the tasks;
    i2c_task_init();
    iot_printf("starting...\n");

    return 0;
}

int main(void)
{
   //module init;
   iot_module_init();

   //module start;
   i2c_task_start();

   return 0;
}