/***************************************************************************//**
* @brief Writes data into a register.
*
* @param dev - The device structure.
* @param register_address - Address of the register.
* Example:
* AD5755_DREG_WR_DAC
* AD5755_DREG_WR_GAIN
* AD5755_DREG_WR_GAIN_ALL
* AD5755_DREG_WR_OFFSET
* AD5755_DREG_WR_OFFSET_ALL
* AD5755_DREG_WR_CLR_CODE
* AD5755_DREG_WR_CTRL_REG
*
* @param channel - Channel option.
* Example: AD5755_DAC_A
* AD5755_DAC_B
* AD5755_DAC_C
* AD5755_DAC_D
* @param register_value - Data value to write.
*
* @return None.
*******************************************************************************/
uint16_t ad5755_set_register_value(struct ad5755_dev *dev,
uint8_t register_address,
uint8_t channel,
uint16_t register_value)
{
uint8_t buff[4] = {0, 0, 0, 0};
uint32_t command = 0;
uint16_t status_reg = 0;
command = AD5755_ISR_WRITE |
AD5755_ISR_DUT_AD1(dev->p_ad5755_st->pin_ad1state) |
AD5755_ISR_DUT_AD0(dev->p_ad5755_st->pin_ad0state) |
AD5755_ISR_DREG(register_address) |
AD5755_ISR_DAC_AD(channel)|
AD5755_ISR_DATA(register_value);
buff[0] = (command & 0xFF0000) >> 16;
buff[1] = (command & 0x00FF00) >> 8;
buff[2] = (command & 0x0000FF) >> 0;
if(dev->p_ad5755_st->enable_packet_error_check) {
buff[3] = ad5755_check_crc(buff, 3);
}
if(dev->p_ad5755_st->stat_readbit == 0) {
spi_write_and_read(dev->spi_desc,
buff,
3 + dev->p_ad5755_st->enable_packet_error_check);
} else {
spi_write_and_read(dev->spi_desc,
buff,
3 + dev->p_ad5755_st->enable_packet_error_check);
status_reg = (buff[1] << 8) + buff[2];
}
return status_reg;
}
static ssize_t spi_test_write(struct file *file,
const char __user *buf, size_t count, loff_t *offset)
{
u8 nr_buf[8];
int nr = 0, ret;
int i = 0;
struct spi_device *spi = NULL;
char txbuf[256],rxbuf[256];
printk("%s:0:bus=0,cs=0; 1:bus=0,cs=1; 2:bus=1,cs=0; 3:bus=1,cs=1; 4:bus=2,cs=0; 5:bus=2,cs=1\n",__func__);
if(count > 5)
return -EFAULT;
ret = copy_from_user(nr_buf, buf, count);
if(ret < 0)
return -EFAULT;
sscanf(nr_buf, "%d", &nr);
if(nr >= 6 || nr < 0)
{
printk("%s:cmd is error\n",__func__);
return -EFAULT;
}
for(i=0; i<256; i++)
txbuf[i] = i;
if(!g_spi_test_data[nr] || !g_spi_test_data[nr]->spi)
{
printk("%s:error g_spi_test_data is null\n",__func__);
return -EFAULT;
}
spi = g_spi_test_data[nr]->spi;
for(i=0; i<5000; i++)
{
ret = spi_write(spi, txbuf, 256);
ret = spi_read(spi, rxbuf, 255);
ret = spi_write_then_read(spi,txbuf,254,rxbuf,253);
ret = spi_write_and_read(spi,txbuf,rxbuf,252);
ret = spi_write_and_read(spi,txbuf,rxbuf,251);
if(i%500==0)
printk("%s:test %d times\n\n",__func__,i+1);
}
if(!ret)
printk("%s:bus_num=%d,chip_select=%d,ok\n",__func__,spi->master->bus_num, spi->chip_select);
else
printk("%s:bus_num=%d,chip_select=%d,error\n",__func__,spi->master->bus_num, spi->chip_select);
return count;
}
/**************************************************************************//**
* @brief Update one of the latch via the SPI interface
*
* @param dev - The device structure.
* @param latch_data - the data which will be written to the latch
*
* @return
******************************************************************************/
void adf4153_update_latch(struct adf4153_dev *dev,
uint32_t latch_data)
{
uint8_t data_buffer[3] = {0,};
uint8_t latch_type = latch_data & 0x3;
/* Update the internal buffers */
switch(latch_type) {
case ADF4153_CTRL_N_DIVIDER :
dev->r0 = latch_data;
break;
case ADF4153_CTRL_R_DIVIDER :
dev->r1 = latch_data;
break;
case ADF4153_CTRL_CONTROL :
dev->r2 = latch_data;
break;
case ADF4153_CTRL_NOISE_SPUR :
dev->r3 = latch_data;
break;
}
data_buffer[0] = (latch_data & DATA_MASK_MSB8) >> DATA_OFFSET_MSB8;
data_buffer[1] = (latch_data & DATA_MASK_MID8) >> DATA_OFFSET_MID8;
data_buffer[2] = (latch_data & DATA_MASK_LSB8) >> DATA_OFFSET_LSB8;
spi_write_and_read(dev->spi_desc,
data_buffer,
3);
/* Generate a load pulse */
ADF4153_LE_HIGH;
ADF4153_LE_LOW;
}
/***************************************************************************//**
* @brief Reads the value of a register.
*
* @param dev - The device structure.
* @param register_address - Address of the register.
* Example:
* AD5755_RD_DATA_REG(x)
* AD5755_RD_CTRL_REG(x)
* AD5755_RD_GAIN_REG(x)
* AD5755_RD_OFFSET_REG(x)
* AD5755_RD_CODE_REG(x)
* AD5755_RD_SR_CTRL_REG(x)
* AD5755_RD_STATUS_REG
* AD5755_RD_MAIN_CTRL_REG
* AD5755_RD_Dc_DC_CTRL_REG
* x = any of AD5755_DAC_A, .. AD5755_DAC_D
*
* @return regValue - Value of the register.
*******************************************************************************/
int32_t ad5755_get_register_value(struct ad5755_dev *dev,
uint8_t register_address)
{
uint8_t buffer[4] = {0, 0, 0, 0};
uint32_t command = 0;
int32_t reg_value = 0;
uint8_t crc = 0;
command = AD5755_ISR_READ |
AD5755_ISR_DUT_AD1(dev->p_ad5755_st->pin_ad1state) |
AD5755_ISR_DUT_AD0(dev->p_ad5755_st->pin_ad0state) |
AD5755_ISR_RD(register_address);
buffer[0] = (command & 0xFF0000) >> 16;
buffer[1] = (command & 0x00FF00) >> 8;
buffer[2] = (command & 0x0000FF) >> 0;
if(dev->p_ad5755_st->enable_packet_error_check) {
buffer[3] = ad5755_check_crc(buffer, 3);
}
spi_write_and_read(dev->spi_desc,
buffer,
3 + dev->p_ad5755_st->enable_packet_error_check);
command = AD5755_ISR_WRITE |
AD5755_ISR_DUT_AD1(dev->p_ad5755_st->pin_ad1state) |
AD5755_ISR_DUT_AD0(dev->p_ad5755_st->pin_ad0state) |
AD5755_ISR_NOP;
buffer[0] = (command & 0xFF0000) >> 16;
buffer[1] = (command & 0x00FF00) >> 8;
buffer[2] = (command & 0x0000FF) >> 0;
if(dev->p_ad5755_st->enable_packet_error_check) {
buffer[3] = ad5755_check_crc(buffer, 3);
}
spi_write_and_read(dev->spi_desc,
buffer,
3 + dev->p_ad5755_st->enable_packet_error_check);
reg_value = ((uint16_t)buffer[1] << 8) + buffer[2];
/* Check the CRC. */
if(dev->p_ad5755_st->enable_packet_error_check) {
crc = ad5755_check_crc(&buffer[1], 3);
if(crc != AD5755_CRC_CHECK_CODE) {
reg_value = -1;
}
}
return reg_value;
}
/***************************************************************************//**
* @brief Writes a value to the selected register.
*
* @param registerAddress - The address of the register to write to.
* @param registerValue - The value to write to the register.
*
* @return Returns 0 in case of success or negative error code.
*******************************************************************************/
int32_t ad9739a_write(unsigned char registerAddress,
unsigned char registerValue)
{
uint8_t data[2] = {0, 0};
data[0] = AD9739A_WRITE | (0x7F & registerAddress);
data[1] = registerValue;
return spi_write_and_read(ad9739a_slave_select, data, 2);
}
/***************************************************************************//**
* @brief Reads the value of the selected register.
*
* @param regAddress - The address of the register to read.
*
* @return registerValue - The register's value or negative error code.
*******************************************************************************/
int32_t ad9739a_read(unsigned char registerAddress)
{
uint8_t txData[2] = {0, 0};
int32_t ret;
txData[0] = AD9739A_READ | (0x7F & registerAddress);
ret = spi_write_and_read(ad9739a_slave_select, txData, 2);
return (ret < 0 ? ret : (int32_t)txData[1]);
}
static int codec_spi_read(unsigned char addr, unsigned char *data)
{
int rc;
u8 buffer[2] = {0, 0};
u8 result[2] = {0, 0};
codec_dev->bits_per_word = 16;
buffer[0] = addr << 1 | 1;
rc = spi_write_and_read(codec_dev, buffer, result, 2);
if (rc < 0)
return rc;
*data = result[1];
return 0;
}
