static void updn_converter_lo_freq_changed_cb(GtkSpinButton *button, int data)
{
struct iio_channel *ad9361_ch, *updn_ch;
double target_freq, ad9361_lo, updn_pll, center_freq;
int ret;
if (data == UPDN_RX) {
ad9361_ch = iio_device_find_channel(dev, "altvoltage0", true);
updn_ch = iio_device_find_channel(udc_rx, "altvoltage0", true);
center_freq = RX_CENTER_FREQ;
} else if (data == UPDN_TX) {
ad9361_ch = iio_device_find_channel(dev, "altvoltage1", true);
updn_ch = iio_device_find_channel(udc_tx, "altvoltage0", true);
center_freq = TX_CENTER_FREQ;
} else {
return;
}
target_freq = gtk_spin_button_get_value(button);
split_target_lo_freq(target_freq, &updn_pll, &ad9361_lo, updn_freq_span, center_freq);
ret = iio_channel_attr_write_longlong(ad9361_ch, freq_name, (long long)MHZ_TO_HZ(ad9361_lo));
if (ret < 0)
fprintf(stderr,"Write to %s attribute of %s device: %s\n",
freq_name, PHY_DEVICE, strerror(-ret));
ret = iio_channel_attr_write_longlong(updn_ch, "frequency", (long long)MHZ_TO_HZ(updn_pll));
if (ret < 0)
fprintf(stderr,"Write to %s attribute of %s device: %s\n",
"frequency", (UPDN_TX) ? UDC_TX_DEVICE : UDC_RX_DEVICE, strerror(-ret));
rx_freq_info_update();
}
static void dds_tx_phase_rotation(struct iio_device *dev, gdouble val)
{
long long i, q;
int d, j;
if (dev == dev_dds_slave)
d = 1;
else
d = 0;
i = scale_phase_0_360(val + 90.0) * 1000;
q = scale_phase_0_360(val) * 1000;
DBG("Val %f, I = %d, Q = %d", val, (int)i,(int) q);
for (j = 0; j < 8; j++) {
switch (j) {
case 0:
case 1:
case 4:
case 5:
iio_channel_attr_write_longlong(dds_out[d][j], "phase", i);
break;
default:
iio_channel_attr_write_longlong(dds_out[d][j], "phase", q);
}
}
}
static void spin_button_save(struct iio_widget *widget, bool is_double)
{
gdouble freq, min;
gdouble scale = widget->priv ? *(gdouble *)widget->priv : 1.0;
freq = gtk_spin_button_get_value(GTK_SPIN_BUTTON (widget->widget));
min = gtk_adjustment_get_lower(gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(widget->widget)));
if (scale < 0 && min < 0)
freq = fabs(freq * scale);
else
freq *= scale;
if (widget->priv_convert_function)
freq = ((double (*)(double, bool))widget->priv_convert_function)(freq, false);
if (widget->chn) {
if (is_double)
iio_channel_attr_write_double(widget->chn,
widget->attr_name, freq);
else
iio_channel_attr_write_longlong(widget->chn,
widget->attr_name, (long long) freq);
} else {
if (is_double)
iio_device_attr_write_double(widget->dev,
widget->attr_name, freq);
else
iio_device_attr_write_longlong(widget->dev,
widget->attr_name, (long long) freq);
}
}
static void mcs_cb (GtkWidget *widget, gpointer data)
{
unsigned step;
struct iio_channel *tx_sample_master, *tx_sample_slave;
long long tx_sample_master_freq, tx_sample_slave_freq;
char temp[40], ensm_mode[40];
unsigned tmp;
static int fix_slave_tune = 1;
tx_sample_master = iio_device_find_channel(dev, "voltage0", true);
tx_sample_slave = iio_device_find_channel(dev_slave, "voltage0", true);
iio_channel_attr_read_longlong(tx_sample_master, "sampling_frequency", &tx_sample_master_freq);
iio_channel_attr_read_longlong(tx_sample_slave, "sampling_frequency", &tx_sample_slave_freq);
if (tx_sample_master_freq != tx_sample_slave_freq) {
printf("tx_sample_master_freq != tx_sample_slave_freq\nUpdating...\n");
iio_channel_attr_write_longlong(tx_sample_slave, "sampling_frequency", tx_sample_master_freq);
}
if (fix_slave_tune) {
iio_device_reg_read(dev, 0x6, &tmp);
iio_device_reg_write(dev_slave, 0x6, tmp);
iio_device_reg_read(dev, 0x7, &tmp);
iio_device_reg_write(dev_slave, 0x7, tmp);
fix_slave_tune = 0;
}
iio_device_attr_read(dev, "ensm_mode", ensm_mode, sizeof(ensm_mode));
/* Move the parts int ALERT for MCS */
iio_device_attr_write(dev, "ensm_mode", "alert");
iio_device_attr_write(dev_slave, "ensm_mode", "alert");
for (step = 1; step <= 5; step++) {
sprintf(temp, "%d", step);
/* Don't change the order here - the master controls the SYNC GPIO */
iio_device_debug_attr_write(dev_slave, "multichip_sync", temp);
iio_device_debug_attr_write(dev, "multichip_sync", temp);
sleep(0.1);
}
iio_device_attr_write(dev, "ensm_mode", ensm_mode);
iio_device_attr_write(dev_slave, "ensm_mode", ensm_mode);
#if 0
iio_device_debug_attr_write(dev, "multichip_sync", "6");
iio_device_debug_attr_write(dev_slave, "multichip_sync", "6");
#endif
}
static int default_dds(long long freq, double scale)
{
int i, j, ret = 0;
for (i = 0; i < 2; i++) {
for (j = 0; j < 8; j++) {
ret |= iio_channel_attr_write_longlong(dds_out[i][j], "frequency", freq);
ret |= iio_channel_attr_write_double(dds_out[i][j], "scale", scale);
}
tx_phase_rotation(i ? dev_dds_slave : dev_dds_master, 0.0);
}
return ret;
}
/* write attribute: long long int */
static void wr_ch_lli(struct iio_channel *chn, const char* what, long long val)
{
errchk(iio_channel_attr_write_longlong(chn, what, val), what);
}
static int write_int(struct iio_channel *chn, const char *attr, int val)
{
return iio_channel_attr_write_longlong(chn, attr, (long long) val);
}
int ad9361_set_bb_rate(struct iio_device *dev, unsigned long rate)
{
struct iio_channel *chan;
long long current_rate;
int dec, taps, ret, i, enable, len = 0;
int16_t *fir;
char *buf;
if (rate <= 20000000UL) {
dec = 4;
taps = 128;
fir = fir_128_4;
} else if (rate <= 40000000UL) {
dec = 2;
fir = fir_128_2;
taps = 128;
} else if (rate <= 53333333UL) {
dec = 2;
fir = fir_96_2;
taps = 96;
} else {
dec = 2;
fir = fir_64_2;
taps = 64;
}
chan = iio_device_find_channel(dev, "voltage0", true);
if (chan == NULL)
return -ENODEV;
ret = iio_channel_attr_read_longlong(chan, "sampling_frequency", ¤t_rate);
if (ret < 0)
return ret;
ret = ad9361_get_trx_fir_enable(dev, &enable);
if (ret < 0)
return ret;
if (enable) {
if (current_rate <= (25000000 / 12))
iio_channel_attr_write_longlong(chan, "sampling_frequency", 3000000);
ret = ad9361_set_trx_fir_enable(dev, false);
if (ret < 0)
return ret;
}
buf = malloc(FIR_BUF_SIZE);
if (!buf)
return -ENOMEM;
len += snprintf(buf + len, FIR_BUF_SIZE - len, "RX 3 GAIN -6 DEC %d\n", dec);
len += snprintf(buf + len, FIR_BUF_SIZE - len, "TX 3 GAIN 0 INT %d\n", dec);
for (i = 0; i < taps; i++)
len += snprintf(buf + len, FIR_BUF_SIZE - len, "%d,%d\n", fir[i], fir[i]);
len += snprintf(buf + len, FIR_BUF_SIZE - len, "\n");
ret = iio_device_attr_write_raw(dev, "filter_fir_config", buf, len);
free (buf);
if (ret < 0)
return ret;
if (rate <= (25000000 / 12)) {
ret = ad9361_set_trx_fir_enable(dev, true);
if (ret < 0)
return ret;
ret = iio_channel_attr_write_longlong(chan, "sampling_frequency", rate);
if (ret < 0)
return ret;
} else {
ret = iio_channel_attr_write_longlong(chan, "sampling_frequency", rate);
if (ret < 0)
return ret;
ret = ad9361_set_trx_fir_enable(dev, true);
if (ret < 0)
return ret;
}
return 0;
}
