#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <fcntl.h>
#include <linux/spi/spidev.h>

#include "../inc/type.h"
#include "../inc/i2c_drv.h"
#include "../inc/ispi.h"
#include "../inc/isys_com.h"

#include "adrv9009.h"

#define ADRV9009_SPI_NODE               "/dev/spidev32766.1"

struct ad9009_chip_init ad9009_config =
{
	0x2,  //chip_count
	{
		// ad9009_0
		{
			0x61, //写使能寄存器 				 write_en_reg
			0,    //写使能寄存器的控制位	write_en_bit
			0x60, //读使能寄存器				 read_en_reg
			0, 	  //读使能寄存器的控制位 read_en_bit
			0x62, //操作寄存器				 addr_reg
			0x63, //写数据寄存器				 write_data_reg
			0x98, //读数据寄存器				 read_data_reg
			0x99, //写数据状态寄存器			 write_status_reg
			0,    //写数据状态寄存器的标志位 write_status_bit
			0x99, //读数据状态寄存器     		 read_status_reg
			0,    //读数据状态寄存器的标志位 read_status_bit
			0x12, //复位寄存器				 read_status_bit
			0, 	  //复位寄存器的标志位	  
			1, //reset_level
			4, //每次发送休眠时间(us)
		},
		// ad9009_1
		{
			0x65, //写使能寄存器
			0, //写使能寄存器的控制位
			0x64, //读使能寄存器
			0, //读使能寄存器的控制位
			0x66, //操作寄存器
			0x67, //写数据寄存器
			0x9A, //读数据寄存器
			0x9B, //写数据状态寄存器
			0, //写数据状态寄存器的标志位
			0x9B, //读数据状态寄存器
			0, //读数据状态寄存器的标志位
			0x22, //复位寄存器
			0, //复位寄存器的标志位
			1, //reset_level
			4, //每次发送休眠时间(us)
		}
	}
};


#if 1

int adrv9009_spi_fd = -1;

void spi_9009_init(void)
{
    unsigned char mode = SPI_MODE_3 ; // 1 0 --  1 闲时高电平， 0第一个边沿采样
    unsigned char bits = 8;
    unsigned int speed = 100000;
    uint16 u16data = 0;

    init_spi_dev(ADRV9009_SPI_NODE, &adrv9009_spi_fd, mode, bits, speed);

	printf("spi init 9009 fd=%d\n", adrv9009_spi_fd);
}

static s8 spi_write_9009(u16 addr, u8 data)
{
    int ret;

	//printf("spi_write addr=0x%x data=0x%x\n", addr, data);
    ret = spi_w_addr16_data8(adrv9009_spi_fd, addr, data);
    if(ret == 0) {
        return 0;
    } else {
        if(ret == -1)
            log_printf(LOG_ERR,I_SYS_STATUS,"9009_spi_fd err, < 0 \n");
        else if(ret == -2)
            log_printf(LOG_ERR,I_SYS_STATUS,"can't send spi message, for write 9009_spi_fd\n");

        return -1;
    }
}

static s8 spi_read_9009(u16 addr, u8 *pdata)
{
    int ret;

	//printf("spi_read addr=0x%x \n", addr);
	ret = spi_r_addr16_data8(adrv9009_spi_fd, addr, pdata);
    if(ret == 0) {
        return 0;
    } else {
        if(ret == -1)
            log_printf(LOG_ERR,I_SYS_STATUS,"9009_spi_fd err, < 0 \n");
        else if(ret == -2)
            log_printf(LOG_ERR,I_SYS_STATUS,"can't send spi message, for read 9009_spi_fd\n");
        return -1;
    }
}


int ad9009_write_hw_spi(int num, u32 addr, u32 *pdata, u32 count)
{
	int ret = OK;
	struct ad9009_init *p;

	if(num > ad9009_config.chip_count){
		printf("ERROR:ad9009_write:chip num(%d) >%d.! \r\n", num, ad9009_config.chip_count);
		return ERROR;
	}

	if(num == 1){
		p = (struct ad9009_init *)&ad9009_config.data;
	}
	else{
		p = &ad9009_config.data[1];
	}

	uint8 *p8data = (uint8 *)pdata;
	while (count--){
		spi_write_9009((uint16)(addr&0xffff), *p8data);
		addr++;
		p8data++;
	}

	return ret;
}

int ad9009_read_hw_spi(int num, u32 addr, u32 *pdata, u32 count)
{
	int ret = OK;
	struct ad9009_init *p;

	if(num >ad9009_config.chip_count){
		printf("ERROR:ad9009_read:chip num(%d) >%d.! \r\n",num,ad9009_config.chip_count);
		return ERROR;
	}

	if(num==1){
		p = (struct ad9009_init *)&ad9009_config.data;
	}
	else{
		p = &ad9009_config.data[1];
	}
	
	uint8 *p8data = (uint8 *)pdata;
	while (count--){
		if(addr>0xffff){
			printf("warning, addr=0x%x over range!\n", addr);
		}
		spi_read_9009((uint16)(addr&0xffff), p8data);
		
		addr++;
		p8data++;
	}

	return ret;
}

#if 0
int ad9009_write_sim_spi(int num, u32 addr, u32 *pdata, u32 count)
{
	int ret = OK;
	struct ad9009_init *p;
	u32 write_status = 0;
	u32 timeout_count = 0;
	u32 write_data;

	if(num > ad9009_config.chip_count){
		printf("ERROR:ad9009_write:chip num(%d) >%d.! \r\n", num, ad9009_config.chip_count);
		return ERROR;
	}

	if(num == 1){
		p = (struct ad9009_init *)&ad9009_config.data;
	}
	else{
		p = &ad9009_config.data[1];
	}

	/*int fd = open(FPGA_ADRV9009_NODE, O_RDWR);
    if (fd < 0) {
        printf("\n\n[ ad9009_write_sim_spi ] node err.\n");
        return ERROR;
    }*/

	while (count--){
		fpga_write_axi0(p->addr_reg, addr, 1);

		fpga_write_axi0(p->write_data_reg, *pdata, 1);

		write_data = 0;
		fpga_write_axi0(p->write_en_reg, write_data, 1);

		write_data = 1;
		fpga_write_axi0(p->write_en_reg, write_data, 1);

		timeout_count = 0;
		do{
			usleep(p->sleep_time);
			//if(OK != (fpga_getbit(fd, p->write_status_reg, p->write_status_bit, 1, &write_status)))
			if(OK != (fpga_read_axi0(p->write_status_reg, &write_status, 1))){
                ret = ERROR;
				printf("ERROR:read status reg[0x%x]=0x%x failed! \n", p->write_status_reg, write_status);
				break;
			}

			timeout_count++;
			write_status = (write_status >> p->write_status_bit);

			if ((RETRY_GET_STATUS_COUNT_MAX) < timeout_count){ //最多尝试100次
				ret = ERROR;
				printf("[%s,%d]ERROR:read reg[0x%x]=0x%x timeout! \r\n", __FUNCTION__, __LINE__, p->write_status_reg,write_status);
				break;
			}
		}while (write_status != 1);

		addr++;
		pdata++;
	}

	//close(fd);
	return ret;
}

int ad9009_read_sim_spi(int num, u32 addr, u32 *pdata, u32 count)
{
	int ret = OK;
	struct ad9009_init *p;

	u32 read_status = 0;
	u32 timeout_count = 0;
	u32 write_data;

	if(num >ad9009_config.chip_count){
		printf("ERROR:ad9009_read:chip num(%d) >%d.! \r\n",num,ad9009_config.chip_count);
		return ERROR;
	}

	if(num==1){
		p = (struct ad9009_init *)&ad9009_config.data;
	}
	else{
		p = &ad9009_config.data[1];
	}
	
	/*int fd = open(FPGA_ADRV9009_NODE, O_RDWR);
    if (fd < 0) {
        printf("\n\n[ ad9009_read_sim_spi ] node err.\n");
        return ERROR;
    }*/

	while (count--){
		fpga_write_axi0(p->addr_reg, addr, 1);

		write_data = 0;
		fpga_write_axi0(p->read_en_reg, write_data, 1);

		write_data = 1;
		fpga_write_axi0(p->read_en_reg, write_data, 1);

		timeout_count = 0;
		
		do{
			usleep(p->sleep_time);
			//if (OK != fpga_getbit(fd, p->read_status_reg, p->read_status_bit, 1, &read_status))
			if (OK != fpga_read_axi0(p->read_status_reg, &read_status, 1)){
				ret = ERROR;
				printf("ERROR:read status reg[0x%x] =0x%xfailed! \r\n", p->read_status_reg, read_status);
				break;
			}
			read_status = (read_status >> p->read_status_bit);
			timeout_count++;
			if ((RETRY_GET_STATUS_COUNT_MAX) < timeout_count){ //最多尝试100次
				ret = ERROR;
				printf("[%s,%d]ERROR:read reg[0x%x] timeout! \r\n", __FUNCTION__, __LINE__,  p->write_status_reg);
				break;
			}

		}while (read_status != 1);

		if (1 != read_status){
			ret = ERROR;
			printf("ERROR:time out, read_status = %d\r\n",read_status);
			break;
		}

		if (OK != fpga_read_axi0(p->read_data_reg, pdata, 1)){
			printf("[%s%d]ERROR: read reg[0x%x] failed! \r\n",  __FUNCTION__, __LINE__, addr);
			ret = ERROR;
			break;
		}

		addr++;
		pdata++;
	}

	//close(fd);

	return ret;
}
#endif

int ad9009_reset(int num)
{
	int ret = OK;
 	//分开寄存器控制
	struct ad9009_init *p;
	u32 write_data;

	if(num >ad9009_config.chip_count){
		printf("ERROR:ad9009_reset:chip num(%d) >%d.! \r\n",num,ad9009_config.chip_count);
		return ERROR;
	}

	if(num==1){
		p = (struct ad9009_init *)&ad9009_config.data;
	}
	else{
		p = &ad9009_config.data[1];
	}

	/*int fd = open(FPGA_ADRV9009_NODE, O_RDWR);
    if (fd < 0) {
        printf("\n\n[ ad9009_reset ] node err.\n");
        return ERROR;
    }*/

	//@cc参照原来的程序 reset adrv9009 0x12      先 1后0
	//write_data = (p->reset_level<<p->reset_bit);
	write_data = p->reset_level;
	fpga_write_axi0(p->reset_reg, write_data, 1);

	usleep(100*1000);
	write_data = !(p->reset_level);
	fpga_write_axi0(p->reset_reg, write_data, 1);

	//close(fd);
	return ret;
}

#endif