static int read_probe_eeprom(unsigned int addr, struct probe_eeprom *eeprom)
{
GString *path = g_string_sized_new(64);
char eeprom_buf[EEPROM_SIZE];
ssize_t rd;
int fd;
probe_eeprom_path(addr, path);
fd = g_open(path->str, O_RDONLY);
g_string_free(path, TRUE);
if (fd < 0)
return -1;
rd = read(fd, eeprom_buf, EEPROM_SIZE);
g_close(fd, NULL);
if (rd != EEPROM_SIZE)
return -1;
eeprom->type = RB32(eeprom_buf + EEPROM_OFF_TYPE);
eeprom->rev = RB32(eeprom_buf + EEPROM_OFF_REV);
eeprom->shunt = RB32(eeprom_buf + EEPROM_OFF_SHUNT);
eeprom->pwr_sw = R8(eeprom_buf + EEPROM_OFF_PWR_SW);
/* Don't care about the serial number and tag for now. */
/* Check if we have some sensible values. */
if (eeprom->rev != 'B')
/* 'B' is the only supported revision with EEPROM for now. */
return -1;
if (eeprom->type != EEPROM_PROBE_TYPE_USB &&
eeprom->type != EEPROM_PROBE_TYPE_JACK &&
eeprom->type != EEPROM_PROBE_TYPE_HE10)
return -1;
return 0;
}
static int
isom_write_avcc(sbuf_t *sb, const uint8_t *data, int len)
{
if (len > 6) {
/* check for h264 start code */
if (RB32(data) == 0x00000001 ||
RB24(data) == 0x000001) {
uint8_t *buf=NULL, *end, *start;
uint32_t *sps_size_array=0, *pps_size_array=0;
uint32_t pps_count=0,sps_count=0;
uint8_t **sps_array=0, **pps_array=0;
int i;
int ret = avc_parse_nal_units_buf(data, &buf, &len);
if (ret < 0)
return ret;
start = buf;
end = buf + len;
/* look for sps and pps */
while (buf < end) {
unsigned int size;
uint8_t nal_type;
size = RB32(buf);
nal_type = buf[4] & 0x1f;
if (nal_type == 7) { /* SPS */
sps_array = realloc(sps_array,sizeof(uint8_t*)*(sps_count+1));
sps_size_array = realloc(sps_size_array,sizeof(uint32_t)*(sps_count+1));
sps_array[sps_count] = buf + 4;
sps_size_array[sps_count] = size;
sps_count++;
} else if (nal_type == 8) { /* PPS */
pps_size_array = realloc(pps_size_array,sizeof(uint32_t)*(pps_count+1));
pps_array = realloc(pps_array,sizeof (uint8_t*)*(pps_count+1));
pps_array[pps_count] = buf + 4;
pps_size_array[pps_count] = size;
pps_count++;
}
buf += size + 4;
}
if(!sps_count || !pps_count) {
free(start);
if (sps_count)
free(sps_array);
if (pps_count)
free(pps_array);
return -1;
}
sbuf_put_byte(sb, 1); /* version */
sbuf_put_byte(sb, sps_array[0][1]); /* profile */
sbuf_put_byte(sb, sps_array[0][2]); /* profile compat */
sbuf_put_byte(sb, sps_array[0][3]); /* level */
sbuf_put_byte(sb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
sbuf_put_byte(sb, 0xe0+sps_count); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
for (i=0;i<sps_count;i++) {
sbuf_put_be16(sb, sps_size_array[i]);
sbuf_append(sb, sps_array[i], sps_size_array[i]);
}
sbuf_put_byte(sb, pps_count); /* number of pps */
for (i=0;i<pps_count;i++) {
sbuf_put_be16(sb, pps_size_array[i]);
sbuf_append(sb, pps_array[i], pps_size_array[i]);
}
free(start);
if (sps_count)
free(sps_array);
if (pps_count)
free(pps_array);
} else {
sbuf_append(sb, data, len);
}
}
return 0;
}
SR_PRIV int gwinstek_gds_800_receive_data(int fd, int revents, void *cb_data)
{
struct sr_dev_inst *sdi;
struct sr_scpi_dev_inst *scpi;
struct dev_context *devc;
struct sr_datafeed_packet packet;
struct sr_datafeed_analog_old analog;
char command[32];
char *response;
float volts_per_division;
int num_samples, i;
float samples[MAX_SAMPLES];
uint32_t sample_rate;
char *end_ptr;
(void)fd;
if (!(sdi = cb_data))
return TRUE;
if (!(devc = sdi->priv))
return TRUE;
scpi = sdi->conn;
if (!(revents == G_IO_IN || revents == 0))
return TRUE;
switch (devc->state) {
case START_ACQUISITION:
if (sr_scpi_send(scpi, ":TRIG:MOD 3") != SR_OK) {
sr_err("Failed to set trigger mode to SINGLE.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
if (sr_scpi_send(scpi, ":STOP") != SR_OK) {
sr_err("Failed to put the trigger system into STOP state.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
if (sr_scpi_send(scpi, ":RUN") != SR_OK) {
sr_err("Failed to put the trigger system into RUN state.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
devc->cur_acq_channel = 0;
devc->state = START_TRANSFER_OF_CHANNEL_DATA;
break;
case START_TRANSFER_OF_CHANNEL_DATA:
if (((struct sr_channel *)g_slist_nth_data(sdi->channels, devc->cur_acq_channel))->enabled) {
if (sr_scpi_send(scpi, ":ACQ%d:MEM?", devc->cur_acq_channel+1) != SR_OK) {
sr_err("Failed to acquire memory.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
if (sr_scpi_read_begin(scpi) != SR_OK) {
sr_err("Could not begin reading SCPI response.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
devc->state = WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE;
devc->cur_rcv_buffer_position = 0;
} else {
/* All channels acquired. */
if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) {
sr_spew("All channels acquired.");
if (devc->cur_acq_frame == devc->frame_limit - 1) {
/* All frames accquired. */
sr_spew("All frames acquired.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
} else {
/* Start acquiring next frame. */
if (devc->df_started) {
packet.type = SR_DF_FRAME_END;
sr_session_send(sdi, &packet);
packet.type = SR_DF_FRAME_BEGIN;
sr_session_send(sdi, &packet);
}
devc->cur_acq_frame++;
devc->state = START_ACQUISITION;
}
} else {
/* Start acquiring next channel. */
devc->cur_acq_channel++;
}
}
break;
case WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE:
if (read_data(sdi, scpi, devc, 1) == SR_OK) {
if (devc->rcv_buffer[0] == '#')
devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE;
}
break;
case WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE:
if (read_data(sdi, scpi, devc, 1) == SR_OK) {
if (devc->rcv_buffer[0] != '4' &&
devc->rcv_buffer[0] != '5' &&
devc->rcv_buffer[0] != '6') {
sr_err("Data size digits is not 4, 5 or 6 but "
"'%c'.", devc->rcv_buffer[0]);
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
} else {
devc->data_size_digits = devc->rcv_buffer[0] - '0';
devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE;
}
}
break;
case WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE:
if (read_data(sdi, scpi, devc, devc->data_size_digits) == SR_OK) {
devc->rcv_buffer[devc->data_size_digits] = 0;
if (sr_atoi(devc->rcv_buffer, &devc->data_size) != SR_OK) {
sr_err("Could not parse data size '%s'", devc->rcv_buffer);
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
} else
devc->state = WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE;
}
break;
case WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE:
if (read_data(sdi, scpi, devc, sizeof(float)) == SR_OK) {
/*
* Contrary to the documentation, this field is
* transfered with most significant byte first!
*/
sample_rate = RB32(devc->rcv_buffer);
memcpy(&devc->sample_rate, &sample_rate, sizeof(float));
devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE;
if (!devc->df_started) {
std_session_send_df_header(sdi);
packet.type = SR_DF_FRAME_BEGIN;
sr_session_send(sdi, &packet);
devc->df_started = TRUE;
}
}
break;
case WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE:
if (read_data(sdi, scpi, devc, 1) == SR_OK)
devc->state = WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE;
break;
case WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE:
if (read_data(sdi, scpi, devc, 3) == SR_OK)
devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE;
break;
case WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE:
if (read_data(sdi, scpi, devc, devc->data_size - 8) == SR_OK) {
/* Fetch data needed for conversion from device. */
snprintf(command, sizeof(command), ":CHAN%d:SCAL?",
devc->cur_acq_channel + 1);
if (sr_scpi_get_string(scpi, command, &response) != SR_OK) {
sr_err("Failed to get volts per division.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
volts_per_division = g_ascii_strtod(response, &end_ptr);
if (!strcmp(end_ptr, "mV"))
volts_per_division *= 1.e-3;
g_free(response);
num_samples = (devc->data_size - 8) / 2;
sr_spew("Received %d number of samples from channel "
"%d.", num_samples, devc->cur_acq_channel + 1);
/* Convert data. */
for (i = 0; i < num_samples; i++)
samples[i] = ((float) ((int16_t) (RB16(&devc->rcv_buffer[i*2])))) / 256. * VERTICAL_DIVISIONS * volts_per_division;
/* Fill frame. */
analog.channels = g_slist_append(NULL, g_slist_nth_data(sdi->channels, devc->cur_acq_channel));
analog.num_samples = num_samples;
analog.data = samples;
analog.mq = SR_MQ_VOLTAGE;
analog.unit = SR_UNIT_VOLT;
analog.mqflags = 0;
packet.type = SR_DF_ANALOG_OLD;
packet.payload = &analog;
sr_session_send(sdi, &packet);
g_slist_free(analog.channels);
/* All channels acquired. */
if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) {
sr_spew("All channels acquired.");
if (devc->cur_acq_frame == devc->frame_limit - 1) {
/* All frames acquired. */
sr_spew("All frames acquired.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
} else {
/* Start acquiring next frame. */
if (devc->df_started) {
packet.type = SR_DF_FRAME_END;
sr_session_send(sdi, &packet);
packet.type = SR_DF_FRAME_BEGIN;
sr_session_send(sdi, &packet);
}
devc->cur_acq_frame++;
devc->state = START_ACQUISITION;
}
} else {
/* Start acquiring next channel. */
devc->state = START_TRANSFER_OF_CHANNEL_DATA;
devc->cur_acq_channel++;
return TRUE;
}
}
break;
}
return TRUE;
}
