X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fchronovu-la8%2Fchronovu-la8.c;h=e63e3a5069a21178c2f1e44750a92ea200151f25;hb=25a605d187e9661757a1e5d4bd15fac2b533c296;hp=42eea79dae49f674b045bf7e70079f2b62c140a6;hpb=ecaf59db8d79286b69a489273f4262901c0588f8;p=libsigrok.git diff --git a/hardware/chronovu-la8/chronovu-la8.c b/hardware/chronovu-la8/chronovu-la8.c index 42eea79d..e63e3a50 100644 --- a/hardware/chronovu-la8/chronovu-la8.c +++ b/hardware/chronovu-la8/chronovu-la8.c @@ -20,6 +20,7 @@ #include #include +#include #include #include @@ -35,6 +36,9 @@ #define SDRAM_SIZE (8 * 1024 * 1024) #define MIN_NUM_SAMPLES 1 +#define BS 4096 /* Block size */ +#define NUM_BLOCKS 2048 /* Number of blocks */ + static GSList *device_instances = NULL; struct la8 { @@ -44,23 +48,23 @@ struct la8 { /** The currently configured samplerate of the device. */ uint64_t cur_samplerate; + /** period in picoseconds corresponding to the samplerate */ + uint64_t period_ps; + /** The current sampling limit (in ms). */ uint64_t limit_msec; /** The current sampling limit (in number of samples). */ uint64_t limit_samples; - /** The number of probes. */ - int num_probes; - /** TODO */ gpointer session_id; /** - * An 8MB buffer containing the (mangled) samples from the device. + * A buffer containing some (mangled) samples from the device. * Format: Pretty mangled-up (due to hardware reasons), see code. */ - uint8_t *mangled_buf; + uint8_t mangled_buf[BS]; /** * An 8MB buffer where we'll store the de-mangled samples. @@ -84,10 +88,13 @@ struct la8 { /** Time (in seconds) before the trigger times out. */ uint64_t trigger_timeout; + /** Tells us whether an SR_DF_TRIGGER packet was already sent. */ + int trigger_found; + /** TODO */ time_t done; - /** Counter/index for the data block (0..2047) to be read. */ + /** Counter/index for the data block to be read. */ int block_counter; /** The divcount value (determines the sample period) for the LA8. */ @@ -119,7 +126,7 @@ static int capabilities[] = { /* Function prototypes. */ static int la8_close_usb_reset_sequencer(struct la8 *la8); -static void hw_stop_acquisition(int device_index, gpointer session_device_id); +static void hw_stop_acquisition(int device_index, gpointer session_data); static int la8_reset(struct la8 *la8); static void fill_supported_samplerates_if_needed(void) @@ -172,13 +179,13 @@ static int is_valid_samplerate(uint64_t samplerate) static uint8_t samplerate_to_divcount(uint64_t samplerate) { if (samplerate == 0) { - sr_warn("la8: %s: samplerate was 0", __func__); + sr_err("la8: %s: samplerate was 0", __func__); return 0xff; } if (!is_valid_samplerate(samplerate)) { - sr_warn("la8: %s: can't get divcount, samplerate invalid", - __func__); + sr_err("la8: %s: can't get divcount, samplerate invalid", + __func__); return 0xff; } @@ -198,22 +205,22 @@ static int la8_write(struct la8 *la8, uint8_t *buf, int size) int bytes_written; if (!la8) { - sr_warn("la8: %s: la8 was NULL", __func__); + sr_err("la8: %s: la8 was NULL", __func__); return SR_ERR_ARG; } if (!la8->ftdic) { - sr_warn("la8: %s: la8->ftdic was NULL", __func__); + sr_err("la8: %s: la8->ftdic was NULL", __func__); return SR_ERR_ARG; } if (!buf) { - sr_warn("la8: %s: buf was NULL", __func__); + sr_err("la8: %s: buf was NULL", __func__); return SR_ERR_ARG; } if (size < 0) { - sr_warn("la8: %s: size was < 0", __func__); + sr_err("la8: %s: size was < 0", __func__); return SR_ERR_ARG; } @@ -245,22 +252,22 @@ static int la8_read(struct la8 *la8, uint8_t *buf, int size) int bytes_read; if (!la8) { - sr_warn("la8: %s: la8 was NULL", __func__); + sr_err("la8: %s: la8 was NULL", __func__); return SR_ERR_ARG; } if (!la8->ftdic) { - sr_warn("la8: %s: la8->ftdic was NULL", __func__); + sr_err("la8: %s: la8->ftdic was NULL", __func__); return SR_ERR_ARG; } if (!buf) { - sr_warn("la8: %s: buf was NULL", __func__); + sr_err("la8: %s: buf was NULL", __func__); return SR_ERR_ARG; } if (size <= 0) { - sr_warn("la8: %s: size was <= 0", __func__); + sr_err("la8: %s: size was <= 0", __func__); return SR_ERR_ARG; } @@ -282,12 +289,12 @@ static int la8_close(struct la8 *la8) int ret; if (!la8) { - sr_warn("la8: %s: la8 was NULL", __func__); + sr_err("la8: %s: la8 was NULL", __func__); return SR_ERR_ARG; } if (!la8->ftdic) { - sr_warn("la8: %s: la8->ftdic was NULL", __func__); + sr_err("la8: %s: la8->ftdic was NULL", __func__); return SR_ERR_ARG; } @@ -311,15 +318,15 @@ static int la8_close_usb_reset_sequencer(struct la8 *la8) uint8_t buf[8] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}; int ret; - sr_dbg("la8: entering %s", __func__); + sr_spew("la8: entering %s", __func__); if (!la8) { - sr_warn("la8: %s: la8 was NULL", __func__); + sr_err("la8: %s: la8 was NULL", __func__); return SR_ERR_ARG; } if (!la8->ftdic) { - sr_warn("la8: %s: la8->ftdic was NULL", __func__); + sr_err("la8: %s: la8->ftdic was NULL", __func__); return SR_ERR_ARG; } @@ -343,7 +350,7 @@ static int la8_close_usb_reset_sequencer(struct la8 *la8) sr_warn("la8: %s: ftdi_usb_close: (%d) %s", __func__, ret, ftdi_get_error_string(la8->ftdic)); } else { - sr_dbg("la8: %s: usb_dev was NULL, nothing to do", __func__); + sr_spew("la8: %s: usb_dev was NULL, nothing to do", __func__); } ftdi_free(la8->ftdic); /* Returns void. */ @@ -362,17 +369,17 @@ static int la8_close_usb_reset_sequencer(struct la8 *la8) */ static int la8_reset(struct la8 *la8) { - uint8_t buf[4096]; + uint8_t buf[BS]; time_t done, now; int bytes_read; if (!la8) { - sr_warn("la8: %s: la8 was NULL", __func__); + sr_err("la8: %s: la8 was NULL", __func__); return SR_ERR_ARG; } if (!la8->ftdic) { - sr_warn("la8: %s: la8->ftdic was NULL", __func__); + sr_err("la8: %s: la8->ftdic was NULL", __func__); return SR_ERR_ARG; } @@ -385,7 +392,7 @@ static int la8_reset(struct la8 *la8) done = 20 + time(NULL); do { /* TODO: Ignore errors? Check for < 0 at least! */ - bytes_read = la8_read(la8, (uint8_t *)&buf, 4096); + bytes_read = la8_read(la8, (uint8_t *)&buf, BS); now = time(NULL); } while ((done > now) && (bytes_read > 0)); @@ -460,62 +467,52 @@ static int hw_init(const char *deviceinfo) struct sr_device_instance *sdi; struct la8 *la8; - sr_dbg("la8: entering %s", __func__); + sr_spew("la8: entering %s", __func__); /* Avoid compiler errors. */ - deviceinfo = deviceinfo; + (void)deviceinfo; /* Allocate memory for our private driver context. */ if (!(la8 = g_try_malloc(sizeof(struct la8)))) { - sr_warn("la8: %s: struct la8 malloc failed", __func__); - ret = SR_ERR_MALLOC; + sr_err("la8: %s: struct la8 malloc failed", __func__); goto err_free_nothing; } /* Set some sane defaults. */ la8->ftdic = NULL; la8->cur_samplerate = SR_MHZ(100); /* 100MHz == max. samplerate */ + la8->period_ps = 10000; la8->limit_msec = 0; la8->limit_samples = 0; - la8->num_probes = NUM_PROBES; la8->session_id = NULL; - la8->mangled_buf = NULL; + memset(la8->mangled_buf, 0, BS); la8->final_buf = NULL; la8->trigger_pattern = 0x00; /* Value irrelevant, see trigger_mask. */ la8->trigger_mask = 0x00; /* All probes are "don't care". */ la8->trigger_timeout = 10; /* Default to 10s trigger timeout. */ + la8->trigger_found = 0; la8->done = 0; la8->block_counter = 0; la8->divcount = 0; /* 10ns sample period == 100MHz samplerate */ - /* Allocate memory for the raw (mangled) data from the LA8. */ - if (!(la8->mangled_buf = g_try_malloc(SDRAM_SIZE))) { - sr_warn("la8: %s: mangled_buf malloc failed", __func__); - ret = SR_ERR_MALLOC; - goto err_free_la8; - } - /* Allocate memory where we'll store the de-mangled data. */ if (!(la8->final_buf = g_try_malloc(SDRAM_SIZE))) { - sr_warn("la8: %s: final_buf malloc failed", __func__); - ret = SR_ERR_MALLOC; - goto err_free_mangled_buf; + sr_err("la8: %s: final_buf malloc failed", __func__); + goto err_free_la8; } /* Allocate memory for the FTDI context (ftdic) and initialize it. */ if (!(la8->ftdic = ftdi_new())) { - sr_warn("la8: %s: ftdi_new failed", __func__); - ret = SR_ERR; /* TODO: More specific error? */ + sr_err("la8: %s: ftdi_new failed", __func__); goto err_free_final_buf; } /* Check for the device and temporarily open it. */ if ((ret = ftdi_usb_open_desc(la8->ftdic, USB_VENDOR_ID, USB_PRODUCT_ID, USB_DESCRIPTION, NULL)) < 0) { - sr_warn("la8: %s: ftdi_usb_open_desc: (%d) %s", - __func__, ret, ftdi_get_error_string(la8->ftdic)); + sr_dbg("la8: %s: ftdi_usb_open_desc: (%d) %s", + __func__, ret, ftdi_get_error_string(la8->ftdic)); (void) la8_close_usb_reset_sequencer(la8); /* Ignore errors. */ - ret = SR_ERR; /* TODO: More specific error? */ goto err_free_ftdic; } sr_dbg("la8: found device"); @@ -524,8 +521,7 @@ static int hw_init(const char *deviceinfo) sdi = sr_device_instance_new(0, SR_ST_INITIALIZING, USB_VENDOR_NAME, USB_MODEL_NAME, USB_MODEL_VERSION); if (!sdi) { - sr_warn("la8: %s: sr_device_instance_new failed", __func__); - ret = SR_ERR; /* TODO: More specific error? */ + sr_err("la8: %s: sr_device_instance_new failed", __func__); goto err_close_ftdic; } @@ -533,12 +529,11 @@ static int hw_init(const char *deviceinfo) device_instances = g_slist_append(device_instances, sdi); - sr_dbg("la8: %s finished successfully", __func__); + sr_spew("la8: %s finished successfully", __func__); /* Close device. We'll reopen it again when we need it. */ (void) la8_close(la8); /* Log, but ignore errors. */ - // return SR_OK; /* TODO */ return 1; err_close_ftdic: @@ -547,12 +542,10 @@ err_free_ftdic: free(la8->ftdic); /* NOT g_free()! */ err_free_final_buf: g_free(la8->final_buf); -err_free_mangled_buf: - g_free(la8->mangled_buf); err_free_la8: g_free(la8); err_free_nothing: - // return ret; /* TODO */ + return 0; } @@ -563,12 +556,12 @@ static int hw_opendev(int device_index) struct la8 *la8; if (!(sdi = sr_get_device_instance(device_instances, device_index))) { - sr_warn("la8: %s: sdi was NULL", __func__); + sr_err("la8: %s: sdi was NULL", __func__); return SR_ERR; /* TODO: SR_ERR_ARG? */ } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_err("la8: %s: sdi->priv was NULL", __func__); return SR_ERR; /* TODO: SR_ERR_ARG? */ } @@ -577,8 +570,8 @@ static int hw_opendev(int device_index) /* Open the device. */ if ((ret = ftdi_usb_open_desc(la8->ftdic, USB_VENDOR_ID, USB_PRODUCT_ID, USB_DESCRIPTION, NULL)) < 0) { - sr_warn("la8: %s: ftdi_usb_open_desc: (%d) %s", - __func__, ret, ftdi_get_error_string(la8->ftdic)); + sr_err("la8: %s: ftdi_usb_open_desc: (%d) %s", + __func__, ret, ftdi_get_error_string(la8->ftdic)); (void) la8_close_usb_reset_sequencer(la8); /* Ignore errors. */ return SR_ERR; } @@ -586,8 +579,8 @@ static int hw_opendev(int device_index) /* Purge RX/TX buffers in the FTDI chip. */ if ((ret = ftdi_usb_purge_buffers(la8->ftdic)) < 0) { - sr_warn("la8: %s: ftdi_usb_purge_buffers: (%d) %s", - __func__, ret, ftdi_get_error_string(la8->ftdic)); + sr_err("la8: %s: ftdi_usb_purge_buffers: (%d) %s", + __func__, ret, ftdi_get_error_string(la8->ftdic)); (void) la8_close_usb_reset_sequencer(la8); /* Ignore errors. */ goto err_opendev_close_ftdic; } @@ -595,8 +588,8 @@ static int hw_opendev(int device_index) /* Enable flow control in the FTDI chip. */ if ((ret = ftdi_setflowctrl(la8->ftdic, SIO_RTS_CTS_HS)) < 0) { - sr_warn("la8: %s: ftdi_setflowcontrol: (%d) %s", - __func__, ret, ftdi_get_error_string(la8->ftdic)); + sr_err("la8: %s: ftdi_setflowcontrol: (%d) %s", + __func__, ret, ftdi_get_error_string(la8->ftdic)); (void) la8_close_usb_reset_sequencer(la8); /* Ignore errors. */ goto err_opendev_close_ftdic; } @@ -619,16 +612,16 @@ static int set_samplerate(struct sr_device_instance *sdi, uint64_t samplerate) struct la8 *la8; if (!sdi) { - sr_warn("la8: %s: sdi was NULL", __func__); + sr_err("la8: %s: sdi was NULL", __func__); return SR_ERR_ARG; } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_err("la8: %s: sdi->priv was NULL", __func__); return SR_ERR_ARG; } - sr_dbg("la8: setting samplerate"); + sr_spew("la8: setting samplerate"); fill_supported_samplerates_if_needed(); @@ -638,41 +631,44 @@ static int set_samplerate(struct sr_device_instance *sdi, uint64_t samplerate) /* Set the new samplerate. */ la8->cur_samplerate = samplerate; + la8->period_ps = 1000000000000 / samplerate; sr_dbg("la8: samplerate set to %" PRIu64 "Hz", la8->cur_samplerate); return SR_OK; } -static void hw_closedev(int device_index) +static int hw_closedev(int device_index) { struct sr_device_instance *sdi; struct la8 *la8; if (!(sdi = sr_get_device_instance(device_instances, device_index))) { - sr_warn("la8: %s: sdi was NULL", __func__); - return; + sr_err("la8: %s: sdi was NULL", __func__); + return SR_ERR; /* TODO: SR_ERR_ARG? */ } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); - return; + sr_err("la8: %s: sdi->priv was NULL", __func__); + return SR_ERR; /* TODO: SR_ERR_ARG? */ } sr_dbg("la8: closing device"); if (sdi->status == SR_ST_ACTIVE) { sr_dbg("la8: %s: status ACTIVE, closing device", __func__); + /* TODO: Really ignore errors here, or return SR_ERR? */ (void) la8_close_usb_reset_sequencer(la8); /* Ignore errors. */ } else { - sr_dbg("la8: %s: status not ACTIVE, nothing to do", __func__); + sr_spew("la8: %s: status not ACTIVE, nothing to do", __func__); } sdi->status = SR_ST_INACTIVE; sr_dbg("la8: %s: freeing sample buffers", __func__); - free(la8->mangled_buf); - free(la8->final_buf); + g_free(la8->final_buf); + + return SR_OK; } static void hw_cleanup(void) @@ -680,18 +676,25 @@ static void hw_cleanup(void) GSList *l; struct sr_device_instance *sdi; - sr_dbg("la8: entering %s", __func__); + sr_spew("la8: entering %s", __func__); /* Properly close all devices. */ for (l = device_instances; l; l = l->next) { if ((sdi = l->data) == NULL) { - sr_warn("la8: %s: sdi was NULL", __func__); + sr_warn("la8: %s: sdi was NULL, continuing", __func__); continue; } +#if 0 + /* + * Fixes a segfault as it's free()d elsewhere already. + * TODO: Document who is supposed to free this, and when. + */ if (sdi->priv != NULL) free(sdi->priv); else - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_warn("la8: %s: sdi->priv was NULL, nothing " + "to do", __func__); +#endif sr_device_instance_free(sdi); /* Returns void. */ } g_slist_free(device_instances); /* Returns void. */ @@ -704,15 +707,15 @@ static void *hw_get_device_info(int device_index, int device_info_id) struct la8 *la8; void *info; - sr_dbg("la8: entering %s", __func__); + sr_spew("la8: entering %s", __func__); if (!(sdi = sr_get_device_instance(device_instances, device_index))) { - sr_warn("la8: %s: sdi was NULL", __func__); + sr_err("la8: %s: sdi was NULL", __func__); return NULL; } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_err("la8: %s: sdi->priv was NULL", __func__); return NULL; } @@ -735,7 +738,7 @@ static void *hw_get_device_info(int device_index, int device_info_id) break; default: /* Unknown device info ID, return NULL. */ - sr_warn("la8: %s: Unknown device info ID", __func__); + sr_err("la8: %s: Unknown device info ID", __func__); info = NULL; break; } @@ -759,7 +762,7 @@ static int hw_get_status(int device_index) static int *hw_get_capabilities(void) { - sr_dbg("la8: entering %s", __func__); + sr_spew("la8: entering %s", __func__); return capabilities; } @@ -769,15 +772,15 @@ static int hw_set_configuration(int device_index, int capability, void *value) struct sr_device_instance *sdi; struct la8 *la8; - sr_dbg("la8: entering %s", __func__); + sr_spew("la8: entering %s", __func__); if (!(sdi = sr_get_device_instance(device_instances, device_index))) { - sr_warn("la8: %s: sdi was NULL", __func__); + sr_err("la8: %s: sdi was NULL", __func__); return SR_ERR; /* TODO: SR_ERR_ARG? */ } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_err("la8: %s: sdi->priv was NULL", __func__); return SR_ERR; /* TODO: SR_ERR_ARG? */ } @@ -795,7 +798,7 @@ static int hw_set_configuration(int device_index, int capability, void *value) break; case SR_HWCAP_LIMIT_MSEC: if (*(uint64_t *)value == 0) { - sr_warn("la8: %s: LIMIT_MSEC can't be 0", __func__); + sr_err("la8: %s: LIMIT_MSEC can't be 0", __func__); return SR_ERR; } la8->limit_msec = *(uint64_t *)value; @@ -803,7 +806,7 @@ static int hw_set_configuration(int device_index, int capability, void *value) break; case SR_HWCAP_LIMIT_SAMPLES: if (*(uint64_t *)value < MIN_NUM_SAMPLES) { - sr_warn("la8: %s: LIMIT_SAMPLES too small", __func__); + sr_err("la8: %s: LIMIT_SAMPLES too small", __func__); return SR_ERR; } la8->limit_samples = *(uint64_t *)value; @@ -811,7 +814,7 @@ static int hw_set_configuration(int device_index, int capability, void *value) break; default: /* Unknown capability, return SR_ERR. */ - sr_warn("la8: %s: Unknown capability", __func__); + sr_err("la8: %s: Unknown capability", __func__); return SR_ERR; break; } @@ -820,7 +823,7 @@ static int hw_set_configuration(int device_index, int capability, void *value) } /** - * Get a block of 4096 bytes of data from the LA8. + * Get a block of data from the LA8. * * @param la8 The LA8 struct containing private per-device-instance data. * @return SR_OK upon success, or SR_ERR upon errors. @@ -831,42 +834,42 @@ static int la8_read_block(struct la8 *la8) time_t now; if (!la8) { - sr_warn("la8: %s: la8 was NULL", __func__); + sr_err("la8: %s: la8 was NULL", __func__); return SR_ERR_ARG; } if (!la8->ftdic) { - sr_warn("la8: %s: la8->ftdic was NULL", __func__); + sr_err("la8: %s: la8->ftdic was NULL", __func__); return SR_ERR_ARG; } - // sr_dbg("la8: %s: reading block %d", __func__, la8->block_counter); + sr_spew("la8: %s: reading block %d", __func__, la8->block_counter); - bytes_read = la8_read(la8, la8->mangled_buf, 4096); + bytes_read = la8_read(la8, la8->mangled_buf, BS); /* If first block read got 0 bytes, retry until success or timeout. */ if ((bytes_read == 0) && (la8->block_counter == 0)) { do { - // sr_dbg("la8: %s: reading block 0 again", __func__); - bytes_read = la8_read(la8, la8->mangled_buf, 4096); + sr_spew("la8: %s: reading block 0 again", __func__); + bytes_read = la8_read(la8, la8->mangled_buf, BS); /* TODO: How to handle read errors here? */ now = time(NULL); } while ((la8->done > now) && (bytes_read == 0)); } /* Check if block read was successful or a timeout occured. */ - if (bytes_read != 4096) { + if (bytes_read != BS) { sr_warn("la8: %s: trigger timed out", __func__); (void) la8_reset(la8); /* Ignore errors. */ return SR_ERR; } /* De-mangle the data. */ - // sr_dbg("la8: de-mangling samples of block %d", la8->block_counter); - byte_offset = la8->block_counter * 4096; + sr_spew("la8: de-mangling samples of block %d", la8->block_counter); + byte_offset = la8->block_counter * BS; m = byte_offset / (1024 * 1024); mi = m * (1024 * 1024); - for (i = 0; i < 4096; i++) { + for (i = 0; i < BS; i++) { p = i & (1 << 0); index = m * 2 + (((byte_offset + i) - mi) / 2) * 16; index += (la8->divcount == 0) ? p : (1 - p); @@ -876,36 +879,136 @@ static int la8_read_block(struct la8 *la8) return SR_OK; } -static int receive_data(int fd, int revents, void *user_data) +static void send_block_to_session_bus(struct la8 *la8, int block) +{ + int i; + uint8_t sample, expected_sample; + struct sr_datafeed_packet packet; + struct sr_datafeed_logic logic; + int trigger_point; /* Relative trigger point (in this block). */ + + /* Note: No sanity checks on la8/block, caller is responsible. */ + + /* Check if we can find the trigger condition in this block. */ + trigger_point = -1; + expected_sample = la8->trigger_pattern & la8->trigger_mask; + for (i = 0; i < BS; i++) { + /* Don't continue if the trigger was found previously. */ + if (la8->trigger_found) + break; + + /* + * Also, don't continue if triggers are "don't care", i.e. if + * no trigger conditions were specified by the user. In that + * case we don't want to send an SR_DF_TRIGGER packet at all. + */ + if (la8->trigger_mask == 0x00) + break; + + sample = *(la8->final_buf + (block * BS) + i); + + if ((sample & la8->trigger_mask) == expected_sample) { + trigger_point = i; + la8->trigger_found = 1; + break; + } + } + + /* If no trigger was found, send one SR_DF_LOGIC packet. */ + if (trigger_point == -1) { + /* Send an SR_DF_LOGIC packet to the session bus. */ + sr_spew("la8: sending SR_DF_LOGIC packet (%d bytes) for " + "block %d", BS, block); + packet.type = SR_DF_LOGIC; + packet.timeoffset = block * BS * la8->period_ps; + packet.duration = BS * la8->period_ps; + packet.payload = &logic; + logic.length = BS; + logic.unitsize = 1; + logic.data = la8->final_buf + (block * BS); + sr_session_bus(la8->session_id, &packet); + return; + } + + /* + * We found the trigger, so some special handling is needed. We have + * to send an SR_DF_LOGIC packet with the samples before the trigger + * (if any), then the SD_DF_TRIGGER packet itself, then another + * SR_DF_LOGIC packet with the samples after the trigger (if any). + */ + + /* TODO: Send SR_DF_TRIGGER packet before or after the actual sample? */ + + /* If at least one sample is located before the trigger... */ + if (trigger_point > 0) { + /* Send pre-trigger SR_DF_LOGIC packet to the session bus. */ + sr_spew("la8: sending pre-trigger SR_DF_LOGIC packet, " + "start = %d, length = %d", block * BS, trigger_point); + packet.type = SR_DF_LOGIC; + packet.timeoffset = block * BS * la8->period_ps; + packet.duration = trigger_point * la8->period_ps; + packet.payload = &logic; + logic.length = trigger_point; + logic.unitsize = 1; + logic.data = la8->final_buf + (block * BS); + sr_session_bus(la8->session_id, &packet); + } + + /* Send the SR_DF_TRIGGER packet to the session bus. */ + sr_spew("la8: sending SR_DF_TRIGGER packet, sample = %d", + (block * BS) + trigger_point); + packet.type = SR_DF_TRIGGER; + packet.timeoffset = (block * BS + trigger_point) * la8->period_ps; + packet.duration = 0; + packet.payload = NULL; + sr_session_bus(la8->session_id, &packet); + + /* If at least one sample is located after the trigger... */ + if (trigger_point < (BS - 1)) { + /* Send post-trigger SR_DF_LOGIC packet to the session bus. */ + sr_spew("la8: sending post-trigger SR_DF_LOGIC packet, " + "start = %d, length = %d", + (block * BS) + trigger_point, BS - trigger_point); + packet.type = SR_DF_LOGIC; + packet.timeoffset = (block * BS + trigger_point) * la8->period_ps; + packet.duration = (BS - trigger_point) * la8->period_ps; + packet.payload = &logic; + logic.length = BS - trigger_point; + logic.unitsize = 1; + logic.data = la8->final_buf + (block * BS) + trigger_point; + sr_session_bus(la8->session_id, &packet); + } +} + +static int receive_data(int fd, int revents, void *session_data) { int i, ret; struct sr_device_instance *sdi; - struct sr_datafeed_packet packet; struct la8 *la8; /* Avoid compiler errors. */ - fd = fd; - revents = revents; + (void)fd; + (void)revents; - if (!(sdi = user_data)) { - sr_warn("la8: %s: user_data was NULL", __func__); + if (!(sdi = session_data)) { + sr_err("la8: %s: user_data was NULL", __func__); return FALSE; } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_err("la8: %s: sdi->priv was NULL", __func__); return FALSE; } - /* Get one block of data (4096 bytes). */ + /* Get one block of data. */ if ((ret = la8_read_block(la8)) < 0) { - sr_warn("la8: %s: la8_read_block error: %d", __func__, ret); - hw_stop_acquisition(sdi->index, user_data); + sr_err("la8: %s: la8_read_block error: %d", __func__, ret); + hw_stop_acquisition(sdi->index, session_data); return FALSE; } - /* We need to get exactly 2048 blocks (i.e. 8MB) of data. */ - if (la8->block_counter != 2047) { + /* We need to get exactly NUM_BLOCKS blocks (i.e. 8MB) of data. */ + if (la8->block_counter != (NUM_BLOCKS - 1)) { la8->block_counter++; return TRUE; } @@ -913,23 +1016,16 @@ static int receive_data(int fd, int revents, void *user_data) sr_dbg("la8: sampling finished, sending data to session bus now"); /* All data was received and demangled, send it to the session bus. */ - for (i = 0; i < 2048; i++) { - /* Send a 4096 byte SR_DF_LOGIC packet to the session bus. */ - // sr_dbg("la8: %s: sending SR_DF_LOGIC packet", __func__); - packet.type = SR_DF_LOGIC; - packet.length = 4096; - packet.unitsize = 1; - packet.payload = la8->final_buf + (i * 4096); - sr_session_bus(la8->session_id, &packet); - } + for (i = 0; i < NUM_BLOCKS; i++) + send_block_to_session_bus(la8, i); - hw_stop_acquisition(sdi->index, user_data); + hw_stop_acquisition(sdi->index, session_data); // return FALSE; /* FIXME? */ return TRUE; } -static int hw_start_acquisition(int device_index, gpointer session_device_id) +static int hw_start_acquisition(int device_index, gpointer session_data) { struct sr_device_instance *sdi; struct la8 *la8; @@ -938,26 +1034,26 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) uint8_t buf[4]; int bytes_written; - sr_dbg("la8: entering %s", __func__); + sr_spew("la8: entering %s", __func__); if (!(sdi = sr_get_device_instance(device_instances, device_index))) { - sr_warn("la8: %s: sdi was NULL", __func__); + sr_err("la8: %s: sdi was NULL", __func__); return SR_ERR; /* TODO: SR_ERR_ARG? */ } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_err("la8: %s: sdi->priv was NULL", __func__); return SR_ERR; /* TODO: SR_ERR_ARG? */ } if (!la8->ftdic) { - sr_warn("la8: %s: la8->ftdic was NULL", __func__); + sr_err("la8: %s: la8->ftdic was NULL", __func__); return SR_ERR_ARG; } la8->divcount = samplerate_to_divcount(la8->cur_samplerate); if (la8->divcount == 0xff) { - sr_warn("la8: %s: invalid divcount/samplerate", __func__); + sr_err("la8: %s: invalid divcount/samplerate", __func__); return SR_ERR; } @@ -971,35 +1067,33 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) bytes_written = la8_write(la8, buf, 4); if (bytes_written < 0) { - sr_warn("la8: acquisition failed to start"); + sr_err("la8: acquisition failed to start"); return SR_ERR; } else if (bytes_written != 4) { - sr_warn("la8: acquisition failed to start"); + sr_err("la8: acquisition failed to start"); return SR_ERR; /* TODO: Other error and return code? */ } sr_dbg("la8: acquisition started successfully"); - la8->session_id = session_device_id; + la8->session_id = session_data; /* Send header packet to the session bus. */ sr_dbg("la8: %s: sending SR_DF_HEADER", __func__); packet.type = SR_DF_HEADER; - packet.length = sizeof(struct sr_datafeed_header); - packet.unitsize = 0; packet.payload = &header; header.feed_version = 1; gettimeofday(&header.starttime, NULL); header.samplerate = la8->cur_samplerate; - header.protocol_id = SR_PROTO_RAW; - header.num_logic_probes = la8->num_probes; + header.num_logic_probes = NUM_PROBES; header.num_analog_probes = 0; - sr_session_bus(session_device_id, &packet); + sr_session_bus(session_data, &packet); /* Time when we should be done (for detecting trigger timeouts). */ la8->done = (la8->divcount + 1) * 0.08388608 + time(NULL) + la8->trigger_timeout; la8->block_counter = 0; + la8->trigger_found = 0; /* Hook up a dummy handler to receive data from the LA8. */ sr_source_add(-1, G_IO_IN, 0, receive_data, sdi); @@ -1007,7 +1101,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) return SR_OK; } -static void hw_stop_acquisition(int device_index, gpointer session_device_id) +static void hw_stop_acquisition(int device_index, gpointer session_data) { struct sr_device_instance *sdi; struct la8 *la8; @@ -1016,22 +1110,19 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id) sr_dbg("la8: stopping acquisition"); if (!(sdi = sr_get_device_instance(device_instances, device_index))) { - sr_warn("la8: %s: sdi was NULL", __func__); + sr_err("la8: %s: sdi was NULL", __func__); return; } if (!(la8 = sdi->priv)) { - sr_warn("la8: %s: sdi->priv was NULL", __func__); + sr_err("la8: %s: sdi->priv was NULL", __func__); return; } /* Send end packet to the session bus. */ sr_dbg("la8: %s: sending SR_DF_END", __func__); packet.type = SR_DF_END; - packet.length = 0; - packet.unitsize = 0; - packet.payload = NULL; - sr_session_bus(session_device_id, &packet); + sr_session_bus(session_data, &packet); } struct sr_device_plugin chronovu_la8_plugin_info = { @@ -1040,8 +1131,8 @@ struct sr_device_plugin chronovu_la8_plugin_info = { .api_version = 1, .init = hw_init, .cleanup = hw_cleanup, - .open = hw_opendev, - .close = hw_closedev, + .opendev = hw_opendev, + .closedev = hw_closedev, .get_device_info = hw_get_device_info, .get_status = hw_get_status, .get_capabilities = hw_get_capabilities,