X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fhardware%2Fkingst-la2016%2Fapi.c;h=1163558e332b8662edf2586ea27e5c7130b2d877;hb=411ad77c05aca0fe83e9cde2f87ab476f8d7d2ff;hp=9ab2e564f944435750e44afdd5ef344a5bb0f512;hpb=84fe94bd277a8250fc6119f3681b0ca1b23d09ae;p=libsigrok.git diff --git a/src/hardware/kingst-la2016/api.c b/src/hardware/kingst-la2016/api.c index 9ab2e564..1163558e 100644 --- a/src/hardware/kingst-la2016/api.c +++ b/src/hardware/kingst-la2016/api.c @@ -20,15 +20,16 @@ * along with this program. If not, see . */ -/* mostly stolen from src/hardware/saleae-logic16/ */ +/* + * This driver implementation initially was derived from the + * src/hardware/saleae-logic16/ source code. + */ #include -#include -#include -#include -#include -#include + #include +#include + #include "libsigrok-internal.h" #include "protocol.h" @@ -124,7 +125,7 @@ static const char *logic_threshold[] = { "USER", }; -#define MAX_NUM_LOGIC_THRESHOLD_ENTRIES ARRAY_SIZE(logic_threshold) +#define LOGIC_THRESHOLD_IDX_USER (ARRAY_SIZE(logic_threshold) - 1) static GSList *scan(struct sr_dev_driver *di, GSList *options) { @@ -141,7 +142,7 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) unsigned int i, j; const char *conn; char connection_id[64]; - int64_t fw_updated; + uint64_t fw_uploaded; unsigned int dev_addr; drvc = di->context; @@ -160,7 +161,7 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) else conn_devices = NULL; - /* Find all LA2016 devices and upload firmware to them. */ + /* Find all LA2016 devices, optionally upload firmware to them. */ devices = NULL; libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); for (i = 0; devlist[i]; i++) { @@ -173,8 +174,10 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) break; } if (!l) { - /* This device matched none of the ones that - * matched the conn specification. */ + /* + * A connection parameter was specified and + * this device does not match the filter. + */ continue; } } @@ -187,25 +190,26 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) if (des.idVendor != LA2016_VID || des.idProduct != LA2016_PID) continue; - /* Already has the firmware */ - sr_dbg("Found a LA2016 device."); + /* USB identification matches, a device was found. */ + sr_dbg("Found a device (USB identification)."); sdi = g_malloc0(sizeof(struct sr_dev_inst)); sdi->status = SR_ST_INITIALIZING; sdi->connection_id = g_strdup(connection_id); - fw_updated = 0; + fw_uploaded = 0; dev_addr = libusb_get_device_address(devlist[i]); - if (des.iProduct != 2) { - sr_info("device at '%s' has no firmware loaded!", connection_id); + if (des.iProduct != LA2016_IPRODUCT_INDEX) { + sr_info("Device at '%s' has no firmware loaded.", connection_id); if (la2016_upload_firmware(drvc->sr_ctx, devlist[i], des.idProduct) != SR_OK) { - sr_err("uC firmware upload failed!"); + sr_err("MCU firmware upload failed."); g_free(sdi->connection_id); g_free(sdi); continue; } - fw_updated = g_get_monotonic_time(); - dev_addr = 0xff; /* to mark that we don't know address yet... ugly */ + fw_uploaded = g_get_monotonic_time(); + /* Will re-enumerate. Mark as "unknown address yet". */ + dev_addr = 0xff; } sdi->vendor = g_strdup("Kingst"); @@ -218,7 +222,7 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) devc = g_malloc0(sizeof(struct dev_context)); sdi->priv = devc; - devc->fw_updated = fw_updated; + devc->fw_uploaded = fw_uploaded; devc->threshold_voltage_idx = 0; devc->threshold_voltage = logic_threshold_value[devc->threshold_voltage_idx]; @@ -259,28 +263,30 @@ static int la2016_dev_open(struct sr_dev_inst *sdi) for (i = 0; i < device_count; i++) { libusb_get_device_descriptor(devlist[i], &des); - if (des.idVendor != LA2016_VID || des.idProduct != LA2016_PID || des.iProduct != 2) + if (des.idVendor != LA2016_VID || des.idProduct != LA2016_PID) + continue; + if (des.iProduct != LA2016_IPRODUCT_INDEX) continue; if ((sdi->status == SR_ST_INITIALIZING) || (sdi->status == SR_ST_INACTIVE)) { - /* - * Check device by its physical USB bus/port address. - */ + /* Check physical USB bus/port address. */ if (usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)) < 0) continue; - if (strcmp(sdi->connection_id, connection_id)) - /* This is not the one. */ + if (strcmp(sdi->connection_id, connection_id)) { + /* Not the device we looked up before. */ continue; + } } if (!(ret = libusb_open(devlist[i], &usb->devhdl))) { - if (usb->address == 0xff) + if (usb->address == 0xff) { /* - * First time we touch this device after FW - * upload, so we don't know the address yet. + * First encounter after firmware upload. + * Grab current address after enumeration. */ usb->address = libusb_get_device_address(devlist[i]); + } } else { sr_err("Failed to open device: %s.", libusb_error_name(ret)); ret = SR_ERR; @@ -289,8 +295,7 @@ static int la2016_dev_open(struct sr_dev_inst *sdi) ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE); if (ret == LIBUSB_ERROR_BUSY) { - sr_err("Unable to claim USB interface. Another " - "program or driver has already claimed it."); + sr_err("Cannot claim USB interface. Another program or driver using it?"); ret = SR_ERR; break; } else if (ret == LIBUSB_ERROR_NO_DEVICE) { @@ -298,13 +303,13 @@ static int la2016_dev_open(struct sr_dev_inst *sdi) ret = SR_ERR; break; } else if (ret != 0) { - sr_err("Unable to claim interface: %s.", libusb_error_name(ret)); + sr_err("Cannot claim USB interface: %s.", libusb_error_name(ret)); ret = SR_ERR; break; } if ((ret = la2016_init_device(sdi)) != SR_OK) { - sr_err("Failed to init device."); + sr_err("Cannot initialize device."); break; } @@ -333,47 +338,48 @@ static int la2016_dev_open(struct sr_dev_inst *sdi) static int dev_open(struct sr_dev_inst *sdi) { struct dev_context *devc; - int64_t timediff_us, timediff_ms; - uint64_t reset_done; - uint64_t now; + uint64_t reset_done, now, elapsed_ms; int ret; devc = sdi->priv; /* - * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS - * milliseconds for the FX2 to renumerate. + * When the sigrok driver recently has uploaded MCU firmware, + * then wait for the FX2 to re-enumerate. Allow the USB device + * to vanish before it reappears. Timeouts are rough estimates + * after all, the imprecise time of the last check (potentially + * executes after the total check period) simplifies code paths + * with optional diagnostics. And increases the probability of + * successfully detecting "late/slow" devices. */ - ret = SR_ERR; - if (devc->fw_updated > 0) { + if (devc->fw_uploaded) { sr_info("Waiting for device to reset after firmware upload."); - /* Takes >= 2000ms for the uC to be gone from the USB bus. */ - reset_done = devc->fw_updated + 18 * (uint64_t)1e5; /* 1.8 seconds */ now = g_get_monotonic_time(); - if (reset_done > now) + reset_done = devc->fw_uploaded + RENUM_GONE_DELAY_MS * 1000; + if (now < reset_done) g_usleep(reset_done - now); - timediff_ms = 0; - while (timediff_ms < MAX_RENUM_DELAY_MS) { - g_usleep(200 * 1000); - - timediff_us = g_get_monotonic_time() - devc->fw_updated; - timediff_ms = timediff_us / 1000; - - if ((ret = la2016_dev_open(sdi)) == SR_OK) + do { + now = g_get_monotonic_time(); + elapsed_ms = (now - devc->fw_uploaded) / 1000; + sr_spew("Waited %" PRIu64 "ms.", elapsed_ms); + ret = la2016_dev_open(sdi); + if (ret == SR_OK) { + devc->fw_uploaded = 0; break; - sr_spew("Waited %" PRIi64 "ms.", timediff_ms); - } + } + g_usleep(RENUM_POLL_INTERVAL_MS * 1000); + } while (elapsed_ms < RENUM_CHECK_PERIOD_MS); if (ret != SR_OK) { sr_err("Device failed to re-enumerate."); return SR_ERR; } - sr_info("Device came back after %" PRIi64 "ms.", timediff_ms); + sr_info("Device came back after %" PRIi64 "ms.", elapsed_ms); } else { ret = la2016_dev_open(sdi); } if (ret != SR_OK) { - sr_err("Unable to open device."); + sr_err("Cannot open device."); return SR_ERR; } @@ -406,6 +412,7 @@ static int config_get(uint32_t key, GVariant **data, struct dev_context *devc; struct sr_usb_dev_inst *usb; double rounded; + const char *label; (void)cg; @@ -418,9 +425,11 @@ static int config_get(uint32_t key, GVariant **data, if (!sdi->conn) return SR_ERR_ARG; usb = sdi->conn; - if (usb->address == 255) { - /* Device still needs to re-enumerate after firmware - * upload, so we don't know its (future) address. */ + if (usb->address == 0xff) { + /* + * Device still needs to re-enumerate after firmware + * upload, so we don't know its (future) address. + */ return SR_ERR; } *data = g_variant_new_printf("%d.%d", usb->bus, usb->address); @@ -439,7 +448,8 @@ static int config_get(uint32_t key, GVariant **data, *data = std_gvar_tuple_double(rounded, rounded + 0.1); return SR_OK; case SR_CONF_LOGIC_THRESHOLD: - *data = g_variant_new_string(logic_threshold[devc->threshold_voltage_idx]); + label = logic_threshold[devc->threshold_voltage_idx]; + *data = g_variant_new_string(label); break; case SR_CONF_LOGIC_THRESHOLD_CUSTOM: *data = g_variant_new_double(devc->threshold_voltage); @@ -476,14 +486,13 @@ static int config_set(uint32_t key, GVariant *data, case SR_CONF_VOLTAGE_THRESHOLD: g_variant_get(data, "(dd)", &low, &high); devc->threshold_voltage = (low + high) / 2.0; - devc->threshold_voltage_idx = MAX_NUM_LOGIC_THRESHOLD_ENTRIES - 1; /* USER */ + devc->threshold_voltage_idx = LOGIC_THRESHOLD_IDX_USER; break; case SR_CONF_LOGIC_THRESHOLD: { - if ((idx = std_str_idx(data, logic_threshold, MAX_NUM_LOGIC_THRESHOLD_ENTRIES)) < 0) + idx = std_str_idx(data, ARRAY_AND_SIZE(logic_threshold)); + if (idx < 0) return SR_ERR_ARG; - if (idx == MAX_NUM_LOGIC_THRESHOLD_ENTRIES - 1) { - /* user threshold */ - } else { + if (idx != LOGIC_THRESHOLD_IDX_USER) { devc->threshold_voltage = logic_threshold_value[idx]; } devc->threshold_voltage_idx = idx; @@ -504,22 +513,24 @@ static int config_list(uint32_t key, GVariant **data, { struct dev_context *devc; - devc = sdi->priv; - switch (key) { case SR_CONF_SCAN_OPTIONS: case SR_CONF_DEVICE_OPTIONS: - return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts); + return STD_CONFIG_LIST(key, data, sdi, cg, + scanopts, drvopts, devopts); case SR_CONF_SAMPLERATE: + if (!sdi) + return SR_ERR_ARG; + devc = sdi->priv; if (devc->max_samplerate == SR_MHZ(200)) { *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates_la2016)); - } - else { + } else { *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates_la1016)); } break; case SR_CONF_LIMIT_SAMPLES: - *data = std_gvar_tuple_u64(LA2016_NUM_SAMPLES_MIN, LA2016_NUM_SAMPLES_MAX); + *data = std_gvar_tuple_u64(LA2016_NUM_SAMPLES_MIN, + LA2016_NUM_SAMPLES_MAX); break; case SR_CONF_VOLTAGE_THRESHOLD: *data = std_gvar_min_max_step_thresholds( @@ -530,7 +541,7 @@ static int config_list(uint32_t key, GVariant **data, *data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches)); break; case SR_CONF_LOGIC_THRESHOLD: - *data = g_variant_new_strv(logic_threshold, MAX_NUM_LOGIC_THRESHOLD_ENTRIES); + *data = g_variant_new_strv(ARRAY_AND_SIZE(logic_threshold)); break; default: return SR_ERR_NA; @@ -539,202 +550,17 @@ static int config_list(uint32_t key, GVariant **data, return SR_OK; } -static void send_chunk(struct sr_dev_inst *sdi, - const uint8_t *packets, unsigned int num_tfers) -{ - struct dev_context *devc; - struct sr_datafeed_logic logic; - struct sr_datafeed_packet sr_packet; - unsigned int max_samples, n_samples, total_samples, free_n_samples; - unsigned int i, j, k; - int do_signal_trigger; - uint16_t *wp; - const uint8_t *rp; - uint16_t state; - uint8_t repetitions; - - devc = sdi->priv; - - logic.unitsize = 2; - logic.data = devc->convbuffer; - - sr_packet.type = SR_DF_LOGIC; - sr_packet.payload = &logic; - - max_samples = devc->convbuffer_size / 2; - n_samples = 0; - wp = (uint16_t *)devc->convbuffer; - total_samples = 0; - do_signal_trigger = 0; - - if (devc->had_triggers_configured && devc->reading_behind_trigger == 0 && devc->info.n_rep_packets_before_trigger == 0) { - std_session_send_df_trigger(sdi); - devc->reading_behind_trigger = 1; - } - - rp = packets; - for (i = 0; i < num_tfers; i++) { - for (k = 0; k < NUM_PACKETS_IN_CHUNK; k++) { - free_n_samples = max_samples - n_samples; - if (free_n_samples < 256 || do_signal_trigger) { - logic.length = n_samples * 2; - sr_session_send(sdi, &sr_packet); - n_samples = 0; - wp = (uint16_t *)devc->convbuffer; - if (do_signal_trigger) { - std_session_send_df_trigger(sdi); - do_signal_trigger = 0; - } - } - - state = read_u16le_inc(&rp); - repetitions = read_u8_inc(&rp); - for (j = 0; j < repetitions; j++) - *wp++ = state; - - n_samples += repetitions; - total_samples += repetitions; - devc->total_samples += repetitions; - if (!devc->reading_behind_trigger) { - devc->n_reps_until_trigger--; - if (devc->n_reps_until_trigger == 0) { - devc->reading_behind_trigger = 1; - do_signal_trigger = 1; - sr_dbg(" here is trigger position after %" PRIu64 " samples, %.6fms", - devc->total_samples, - (double)devc->total_samples / devc->cur_samplerate * 1e3); - } - } - } - (void)read_u8_inc(&rp); /* Skip sequence number. */ - } - if (n_samples) { - logic.length = n_samples * 2; - sr_session_send(sdi, &sr_packet); - if (do_signal_trigger) { - std_session_send_df_trigger(sdi); - } - } - sr_dbg("send_chunk done after %d samples", total_samples); -} - -static void LIBUSB_CALL receive_transfer(struct libusb_transfer *transfer) -{ - struct sr_dev_inst *sdi; - struct dev_context *devc; - struct sr_usb_dev_inst *usb; - int ret; - - sdi = transfer->user_data; - devc = sdi->priv; - usb = sdi->conn; - - sr_dbg("receive_transfer(): status %s received %d bytes.", - libusb_error_name(transfer->status), transfer->actual_length); - - if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) { - sr_err("bulk transfer timeout!"); - devc->transfer_finished = 1; - } - send_chunk(sdi, transfer->buffer, transfer->actual_length / TRANSFER_PACKET_LENGTH); - - devc->n_bytes_to_read -= transfer->actual_length; - if (devc->n_bytes_to_read) { - uint32_t to_read = devc->n_bytes_to_read; - if (to_read > LA2016_BULK_MAX) - to_read = LA2016_BULK_MAX; - libusb_fill_bulk_transfer( - transfer, usb->devhdl, - 0x86, transfer->buffer, to_read, - receive_transfer, (void *)sdi, DEFAULT_TIMEOUT_MS); - - if ((ret = libusb_submit_transfer(transfer)) == 0) - return; - sr_err("Failed to submit further transfer: %s.", libusb_error_name(ret)); - } - - g_free(transfer->buffer); - libusb_free_transfer(transfer); - devc->transfer_finished = 1; -} - -static int handle_event(int fd, int revents, void *cb_data) -{ - const struct sr_dev_inst *sdi; - struct dev_context *devc; - struct drv_context *drvc; - struct timeval tv; - - (void)fd; - (void)revents; - - sdi = cb_data; - devc = sdi->priv; - drvc = sdi->driver->context; - - if (devc->have_trigger == 0) { - if (la2016_has_triggered(sdi) == 0) { - /* not yet ready for download */ - return TRUE; - } - devc->have_trigger = 1; - devc->transfer_finished = 0; - devc->reading_behind_trigger = 0; - devc->total_samples = 0; - /* we can start retrieving data! */ - if (la2016_start_retrieval(sdi, receive_transfer) != SR_OK) { - sr_err("failed to start retrieval!"); - return FALSE; - } - sr_dbg("retrieval is started..."); - std_session_send_df_frame_begin(sdi); - - return TRUE; - } - - tv.tv_sec = tv.tv_usec = 0; - libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv); - - if (devc->transfer_finished) { - sr_dbg("transfer is finished!"); - std_session_send_df_frame_end(sdi); - - usb_source_remove(sdi->session, drvc->sr_ctx); - std_session_send_df_end(sdi); - - la2016_stop_acquisition(sdi); - - g_free(devc->convbuffer); - devc->convbuffer = NULL; - - devc->transfer = NULL; - - sr_dbg("transfer is now finished"); - } - - return TRUE; -} - -static void abort_acquisition(struct dev_context *devc) -{ - if (devc->transfer) - libusb_cancel_transfer(devc->transfer); -} - static int configure_channels(const struct sr_dev_inst *sdi) { struct dev_context *devc; devc = sdi->priv; devc->cur_channels = 0; - devc->num_channels = 0; - for (GSList *l = sdi->channels; l; l = l->next) { struct sr_channel *ch = (struct sr_channel*)l->data; if (ch->enabled == FALSE) continue; devc->cur_channels |= 1 << ch->index; - devc->num_channels++; } return SR_OK; @@ -752,17 +578,19 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi) devc = sdi->priv; if (configure_channels(sdi) != SR_OK) { - sr_err("Failed to configure channels."); + sr_err("Cannot configure channels."); return SR_ERR; } - devc->convbuffer_size = 4 * 1024 * 1024; - if (!(devc->convbuffer = g_try_malloc(devc->convbuffer_size))) { - sr_err("Conversion buffer malloc failed."); + devc->convbuffer_size = LA2016_CONVBUFFER_SIZE; + devc->convbuffer = g_try_malloc(devc->convbuffer_size); + if (!devc->convbuffer) { + sr_err("Cannot allocate conversion buffer."); return SR_ERR_MALLOC; } - if ((ret = la2016_setup_acquisition(sdi)) != SR_OK) { + ret = la2016_setup_acquisition(sdi); + if (ret != SR_OK) { g_free(devc->convbuffer); devc->convbuffer = NULL; return ret; @@ -770,13 +598,15 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi) devc->ctx = drvc->sr_ctx; - if ((ret = la2016_start_acquisition(sdi)) != SR_OK) { - abort_acquisition(devc); + ret = la2016_start_acquisition(sdi); + if (ret != SR_OK) { + la2016_abort_acquisition(sdi); return ret; } - devc->have_trigger = 0; - usb_source_add(sdi->session, drvc->sr_ctx, 50, handle_event, (void *)sdi); + devc->completion_seen = FALSE; + usb_source_add(sdi->session, drvc->sr_ctx, 50, + la2016_receive_data, (void *)sdi); std_session_send_df_header(sdi); @@ -788,7 +618,6 @@ static int dev_acquisition_stop(struct sr_dev_inst *sdi) int ret; ret = la2016_abort_acquisition(sdi); - abort_acquisition(sdi->priv); return ret; }