* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <config.h>
#include "protocol.h"
-extern SR_PRIV struct sr_dev_driver p_ols_driver_info;
-static struct sr_dev_driver *di = &p_ols_driver_info;
-
SR_PRIV int write_shortcommand(struct dev_context *devc, uint8_t command)
{
uint8_t buf[1];
ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
- sr_dbg("FTDI chip interface B set successfully.");
/* Check for the device and temporarily open it. */
ret = ftdi_usb_open_desc(devc->ftdic, USB_VENDOR_ID, USB_DEVICE_ID,
ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
- sr_dbg("FTDI device opened successfully.");
/* Purge RX/TX buffers in the FTDI chip. */
if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0) {
ret, ftdi_get_error_string(devc->ftdic));
goto err_open_close_ftdic;
}
- sr_dbg("FTDI chip buffers purged successfully.");
/* Reset the FTDI bitmode. */
ret = ftdi_set_bitmode(devc->ftdic, 0xff, BITMODE_RESET);
ret, ftdi_get_error_string(devc->ftdic));
goto err_open_close_ftdic;
}
- sr_dbg("FTDI chip bitmode reset successfully.");
/* Set the FTDI latency timer to 16. */
ret = ftdi_set_latency_timer(devc->ftdic, 16);
ret, ftdi_get_error_string(devc->ftdic));
goto err_open_close_ftdic;
}
- sr_dbg("FTDI chip latency timer set successfully.");
/* Set the FTDI read data chunk size to 64kB. */
ret = ftdi_read_data_set_chunksize(devc->ftdic, 64 * 1024);
ret, ftdi_get_error_string(devc->ftdic));
goto err_open_close_ftdic;
}
- sr_dbg("FTDI chip read data chunk size set successfully.");
-
+
return SR_OK;
err_open_close_ftdic:
ftdi_usb_close(devc->ftdic);
+
return SR_ERR;
}
return SR_OK;
}
-SR_PRIV int p_ols_configure_channels(const struct sr_dev_inst *sdi)
+/* Configures the channel mask based on which channels are enabled. */
+SR_PRIV void pols_channel_mask(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- const struct sr_channel *ch;
+ struct sr_channel *channel;
const GSList *l;
- int channel_bit, stage, i;
- char *tc;
devc = sdi->priv;
devc->channel_mask = 0;
+ for (l = sdi->channels; l; l = l->next) {
+ channel = l->data;
+ if (channel->enabled)
+ devc->channel_mask |= 1 << channel->index;
+ }
+}
+
+SR_PRIV int pols_convert_trigger(const struct sr_dev_inst *sdi)
+{
+ struct dev_context *devc;
+ struct sr_trigger *trigger;
+ struct sr_trigger_stage *stage;
+ struct sr_trigger_match *match;
+ const GSList *l, *m;
+ int i;
+
+ devc = sdi->priv;
+
+ devc->num_stages = 0;
for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
devc->trigger_mask[i] = 0;
devc->trigger_value[i] = 0;
devc->trigger_edge[i] = 0;
}
- devc->num_stages = 0;
- for (l = sdi->channels; l; l = l->next) {
- ch = (const struct sr_channel *)l->data;
- if (!ch->enabled)
- continue;
+ if (!(trigger = sr_session_trigger_get(sdi->session)))
+ return SR_OK;
- if (ch->index >= devc->max_channels) {
- sr_err("Channels over the limit of %d\n", devc->max_channels);
- return SR_ERR;
- }
+ devc->num_stages = g_slist_length(trigger->stages);
+ if (devc->num_stages > NUM_TRIGGER_STAGES) {
+ sr_err("This device only supports %d trigger stages.",
+ NUM_TRIGGER_STAGES);
+ return SR_ERR;
+ }
- /*
- * Set up the channel mask for later configuration into the
- * flag register.
- */
- channel_bit = 1 << (ch->index);
- devc->channel_mask |= channel_bit;
-
- if (!ch->trigger)
- continue;
-
- /* Configure trigger mask and value. */
- stage = 0;
- for (tc = ch->trigger; tc && *tc; tc++) {
- devc->trigger_mask[stage] |= channel_bit;
- if ((*tc == '1') || (*tc == 'r'))
- devc->trigger_value[stage] |= channel_bit;
- if ((*tc == 'r') || (*tc == 'f'))
- devc->trigger_edge[stage] |= channel_bit;
- stage++;
- /* Only supporting parallel mode, with up to 4 stages. */
- if (stage > 3)
- return SR_ERR;
+ for (l = trigger->stages; l; l = l->next) {
+ stage = l->data;
+ for (m = stage->matches; m; m = m->next) {
+ match = m->data;
+ if (!match->channel->enabled)
+ /* Ignore disabled channels with a trigger. */
+ continue;
+ devc->trigger_mask[stage->stage] |= 1 << match->channel->index;
+ if (match->match == SR_TRIGGER_ONE || match->match == SR_TRIGGER_RISING)
+ devc->trigger_value[stage->stage] |= 1 << match->channel->index;
+ if (match->match == SR_TRIGGER_RISING || match->match == SR_TRIGGER_FALLING)
+ devc->trigger_edge[stage->stage] |= 1 << match->channel->index;
}
- if (stage > devc->num_stages)
- devc->num_stages = stage - 1;
}
return SR_OK;
SR_PRIV struct sr_dev_inst *p_ols_get_metadata(uint8_t *buf, int bytes_read, struct dev_context *devc)
{
struct sr_dev_inst *sdi;
- struct sr_channel *ch;
uint32_t tmp_int, ui;
uint8_t key, type, token;
GString *tmp_str, *devname, *version;
guchar tmp_c;
int index, i;
- sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, NULL, NULL, NULL);
- sdi->driver = di;
+ sdi = g_malloc0(sizeof(struct sr_dev_inst));
+ sdi->status = SR_ST_INACTIVE;
sdi->priv = devc;
devname = g_string_new("");
switch (token) {
case 0x00:
/* Number of usable channels */
- for (ui = 0; ui < tmp_int; ui++) {
- if (!(ch = sr_channel_new(ui, SR_CHANNEL_LOGIC, TRUE,
- p_ols_channel_names[ui])))
- return 0;
- sdi->channels = g_slist_append(sdi->channels, ch);
- }
+ for (ui = 0; ui < tmp_int; ui++)
+ sr_channel_new(sdi, ui, SR_CHANNEL_LOGIC, TRUE,
+ p_ols_channel_names[ui]);
break;
case 0x01:
/* Amount of sample memory available (bytes) */
/* what is this for? */
break;
case 0x03:
- /* Maximum sample rate (hz) */
+ /* Maximum sample rate (Hz) */
devc->max_samplerate = tmp_int;
break;
case 0x04:
switch (token) {
case 0x00:
/* Number of usable channels */
- for (ui = 0; ui < tmp_c; ui++) {
- if (!(ch = sr_channel_new(ui, SR_CHANNEL_LOGIC, TRUE,
- p_ols_channel_names[ui])))
- return 0;
- sdi->channels = g_slist_append(sdi->channels, ch);
- }
+ for (ui = 0; ui < tmp_c; ui++)
+ sr_channel_new(sdi, ui, SR_CHANNEL_LOGIC, TRUE,
+ p_ols_channel_names[ui]);
break;
case 0x01:
/* protocol version */
return SR_OK;
}
-
SR_PRIV int p_ols_receive_data(int fd, int revents, void *cb_data)
{
struct dev_context *devc;
num_channels++;
}
}
- sr_dbg("num_channels = %d", num_channels);
/* Get a block of data. */
bytes_read = ftdi_read_data(devc->ftdic, devc->ftdi_buf, FTDI_BUF_SIZE);
if (bytes_read < 0) {
sr_err("Failed to read FTDI data (%d): %s.",
bytes_read, ftdi_get_error_string(devc->ftdic));
- sdi->driver->dev_acquisition_stop(sdi, sdi);
+ sr_dev_acquisition_stop(sdi);
return FALSE;
}
if (bytes_read == 0) {
sr_spew("Received byte 0x%.2x.", byte);
if ((devc->flag_reg & FLAG_DEMUX) && (devc->flag_reg & FLAG_RLE)) {
- /* RLE in demux mode must be processed differently
+ /* RLE in demux mode must be processed differently
* since in this case the RLE encoder is operating on pairs of samples.
*/
if (devc->num_bytes == num_channels * 2) {
* sample.
*/
devc->tmp_sample[i] = devc->sample[j++];
- }
+ }
}
/* Clear out the most significant bit of the sample */
devc->tmp_sample[devc->num_bytes - 1] &= 0x7f;
- sr_spew("Expanded sample 1: 0x%.8x.", devc->tmp_sample);
+ sr_spew("Expanded sample 1: 0x%.2x%.2x%.2x%.2x.",
+ devc->tmp_sample[3], devc->tmp_sample[2],
+ devc->tmp_sample[1], devc->tmp_sample[0]);
/* expand second sample */
memset(devc->tmp_sample2, 0, 4);
* sample.
*/
devc->tmp_sample2[i] = devc->sample[j++];
- }
+ }
}
/* Clear out the most significant bit of the sample */
devc->tmp_sample2[devc->num_bytes - 1] &= 0x7f;
- sr_spew("Expanded sample 2: 0x%.8x.", devc->tmp_sample2);
+ sr_spew("Expanded sample 2: 0x%.2x%.2x%.2x%.2x.",
+ devc->tmp_sample2[3], devc->tmp_sample2[2],
+ devc->tmp_sample2[1], devc->tmp_sample2[0]);
/*
* OLS sends its sample buffer backwards.
* sample.
*/
devc->tmp_sample[i] = devc->sample[j++];
- }
+ }
}
memcpy(devc->sample, devc->tmp_sample, 4);
sr_spew("Expanded sample: 0x%.8x.", sample);
}
return TRUE;
} else {
- do bytes_read = ftdi_read_data(devc->ftdic, devc->ftdi_buf, FTDI_BUF_SIZE);
- while (bytes_read > 0);
+ do {
+ bytes_read = ftdi_read_data(devc->ftdic, devc->ftdi_buf, FTDI_BUF_SIZE);
+ } while (bytes_read > 0);
/*
* We've acquired all the samples we asked for -- we're done.
logic.unitsize = 4;
logic.data = devc->raw_sample_buf +
(devc->limit_samples - devc->num_samples) * 4;
- sr_session_send(cb_data, &packet);
+ sr_session_send(sdi, &packet);
}
/* Send the trigger. */
packet.type = SR_DF_TRIGGER;
- sr_session_send(cb_data, &packet);
+ sr_session_send(sdi, &packet);
/* Send post-trigger samples. */
packet.type = SR_DF_LOGIC;
logic.unitsize = 4;
logic.data = devc->raw_sample_buf + devc->trigger_at * 4 +
(devc->limit_samples - devc->num_samples) * 4;
- sr_session_send(cb_data, &packet);
+ sr_session_send(sdi, &packet);
} else {
/* no trigger was used */
packet.type = SR_DF_LOGIC;
logic.unitsize = 4;
logic.data = devc->raw_sample_buf +
(devc->limit_samples - devc->num_samples) * 4;
- sr_session_send(cb_data, &packet);
+ sr_session_send(sdi, &packet);
}
g_free(devc->raw_sample_buf);
- sdi->driver->dev_acquisition_stop(sdi, cb_data);
+ sr_dev_acquisition_stop(sdi);
}
return TRUE;