358 lines
8.5 KiB
C
Executable File
358 lines
8.5 KiB
C
Executable File
#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
|