X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=session_driver.c;h=d5f9d5549b7577772f5e286bd092cfea9d25f965;hb=c09f0b578c0e9c03590cb814f66004bb3f6815ff;hp=f0b4b0f98529f12a4d857497a05359d08018d71b;hpb=9c939c5132d82575cc1ce8f8fef5b6c4289aec5b;p=libsigrok.git diff --git a/session_driver.c b/session_driver.c index f0b4b0f9..d5f9d554 100644 --- a/session_driver.c +++ b/session_driver.c @@ -1,7 +1,7 @@ /* * This file is part of the sigrok project. * - * Copyright (C) 2011 Bert Vermeulen + * Copyright (C) 2010-2012 Bert Vermeulen * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -23,89 +23,109 @@ #include #include #include -#include -#include +#include "sigrok.h" +#include "sigrok-internal.h" /* size of payloads sent across the session bus */ -#define CHUNKSIZE 4096 +#define CHUNKSIZE (512 * 1024) -struct session_vdevice { +struct session_vdev { char *capturefile; struct zip *archive; struct zip_file *capfile; + int bytes_read; uint64_t samplerate; int unitsize; int num_probes; }; static char *sessionfile = NULL; -static GSList *device_instances = NULL; -static int capabilities[] = { +static GSList *dev_insts = NULL; +static int hwcaps[] = { SR_HWCAP_CAPTUREFILE, SR_HWCAP_CAPTURE_UNITSIZE, 0, }; - -static struct session_vdevice *get_vdevice_by_index(int device_index) +/** + * TODO. + * + * @param dev_index TODO. + */ +static struct session_vdev *get_vdev_by_index(int dev_index) { - struct sr_device_instance *sdi; - struct session_vdevice *vdevice; + struct sr_dev_inst *sdi; + struct session_vdev *vdev; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) + /* TODO: Sanity checks on dev_index. */ + + if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) { + sr_err("session driver: %s: device instance with device " + "index %d was not found", __func__, dev_index); return NULL; + } + + /* TODO: Is sdi->priv == NULL valid? */ - vdevice = sdi->priv; + vdev = sdi->priv; - return vdevice; + return vdev; } +/** + * TODO. + * + * @param fd TODO. + * @param revents TODO. + * @param session_data TODO. + * + * @return TODO. + */ static int feed_chunk(int fd, int revents, void *session_data) { - struct sr_device_instance *sdi; - struct session_vdevice *vdevice; + struct sr_dev_inst *sdi; + struct session_vdev *vdev; struct sr_datafeed_packet packet; struct sr_datafeed_logic logic; GSList *l; void *buf; int ret, got_data; - /* avoid compiler warning */ - fd = fd; - revents = revents; + /* Avoid compiler warnings. */ + (void)fd; + (void)revents; sr_dbg("session_driver: feed chunk"); got_data = FALSE; - for (l = device_instances; l; l = l->next) { + for (l = dev_insts; l; l = l->next) { sdi = l->data; - vdevice = sdi->priv; - if (!vdevice) + vdev = sdi->priv; + if (!vdev) /* already done with this instance */ continue; if (!(buf = g_try_malloc(CHUNKSIZE))) { - sr_err("session: %s: buf malloc failed", __func__); - // return SR_ERR_MALLOC; - return FALSE; + sr_err("session driver: %s: buf malloc failed", + __func__); + return FALSE; /* TODO: SR_ERR_MALLOC */ } - ret = zip_fread(vdevice->capfile, buf, CHUNKSIZE); + ret = zip_fread(vdev->capfile, buf, CHUNKSIZE); if (ret > 0) { got_data = TRUE; packet.type = SR_DF_LOGIC; - packet.timeoffset = 0; - packet.duration = 0; packet.payload = &logic; logic.length = ret; - logic.unitsize = vdevice->unitsize; + logic.unitsize = vdev->unitsize; logic.data = buf; + vdev->bytes_read += ret; sr_session_bus(session_data, &packet); } else { /* done with this capture file */ - zip_fclose(vdevice->capfile); - g_free(vdevice->capturefile); - g_free(vdevice); + zip_fclose(vdev->capfile); + g_free(vdev->capturefile); + g_free(vdev); sdi->priv = NULL; } } @@ -119,155 +139,181 @@ static int feed_chunk(int fd, int revents, void *session_data) } /* driver callbacks */ +static int hw_cleanup(void); -static int hw_init(const char *deviceinfo) +/** + * TODO. + * + * @param devinfo TODO. + * + * @return TODO. + */ +static int hw_init(const char *devinfo) { - - sessionfile = g_strdup(deviceinfo); + sessionfile = g_strdup(devinfo); return 0; } -static void hw_cleanup(void) +/** + * TODO. + * + */ +static int hw_cleanup(void) { GSList *l; - for (l = device_instances; l; l = l->next) - sr_device_instance_free(l->data); + for (l = dev_insts; l; l = l->next) + sr_dev_inst_free(l->data); + g_slist_free(dev_insts); + dev_insts = NULL; + + sr_session_source_remove(-1); g_free(sessionfile); + return SR_OK; } -static int hw_opendev(int device_index) +static int hw_dev_open(int dev_index) { - struct sr_device_instance *sdi; + struct sr_dev_inst *sdi; - sdi = sr_device_instance_new(device_index, SR_ST_INITIALIZING, - NULL, NULL, NULL); + sdi = sr_dev_inst_new(dev_index, SR_ST_INITIALIZING, + NULL, NULL, NULL); if (!sdi) return SR_ERR; - if (!(sdi->priv = g_try_malloc0(sizeof(struct session_vdevice)))) { - sr_err("session: %s: sdi->priv malloc failed", __func__); + if (!(sdi->priv = g_try_malloc0(sizeof(struct session_vdev)))) { + sr_err("session driver: %s: sdi->priv malloc failed", __func__); return SR_ERR_MALLOC; } - device_instances = g_slist_append(device_instances, sdi); + dev_insts = g_slist_append(dev_insts, sdi); return SR_OK; } -static void *hw_get_device_info(int device_index, int device_info_id) +static void *hw_dev_info_get(int dev_index, int dev_info_id) { - struct session_vdevice *vdevice; + struct session_vdev *vdev; void *info; - if (device_info_id != SR_DI_CUR_SAMPLERATE) + if (dev_info_id != SR_DI_CUR_SAMPLERATE) return NULL; - if (!(vdevice = get_vdevice_by_index(device_index))) + if (!(vdev = get_vdev_by_index(dev_index))) return NULL; - info = &vdevice->samplerate; + info = &vdev->samplerate; return info; } -static int hw_get_status(int device_index) +static int hw_dev_status_get(int dev_index) { + /* Avoid compiler warnings. */ + (void)dev_index; - /* avoid compiler warning */ - device_index = device_index; - - if (devices) + if (sr_dev_list() != NULL) return SR_OK; else return SR_ERR; } -static int *hw_get_capabilities(void) +/** + * Get the list of hardware capabilities. + * + * @return A pointer to the (hardware) capabilities of this virtual session + * driver. This could be NULL, if no such capabilities exist. + */ +static int *hw_hwcap_get_all(void) { - - return capabilities; + return hwcaps; } -static int hw_set_configuration(int device_index, int capability, void *value) +static int hw_dev_config_set(int dev_index, int hwcap, void *value) { - struct session_vdevice *vdevice; + struct session_vdev *vdev; uint64_t *tmp_u64; - if (!(vdevice = get_vdevice_by_index(device_index))) + if (!(vdev = get_vdev_by_index(dev_index))) return SR_ERR; - switch (capability) { + switch (hwcap) { case SR_HWCAP_SAMPLERATE: tmp_u64 = value; - vdevice->samplerate = *tmp_u64; + vdev->samplerate = *tmp_u64; + sr_info("session driver: setting samplerate to %" PRIu64, + vdev->samplerate); break; case SR_HWCAP_CAPTUREFILE: - vdevice->capturefile = g_strdup(value); + vdev->capturefile = g_strdup(value); + sr_info("session driver: setting capturefile to %s", + vdev->capturefile); break; case SR_HWCAP_CAPTURE_UNITSIZE: tmp_u64 = value; - vdevice->unitsize = *tmp_u64; + vdev->unitsize = *tmp_u64; break; case SR_HWCAP_CAPTURE_NUM_PROBES: tmp_u64 = value; - vdevice->num_probes = *tmp_u64; + vdev->num_probes = *tmp_u64; break; default: + sr_err("session driver: %s: unknown capability %d requested", + __func__, hwcap); return SR_ERR; } return SR_OK; } -static int hw_start_acquisition(int device_index, gpointer session_device_id) +static int hw_dev_acquisition_start(int dev_index, gpointer session_dev_id) { struct zip_stat zs; - struct session_vdevice *vdevice; + struct session_vdev *vdev; struct sr_datafeed_header *header; struct sr_datafeed_packet *packet; int err; - /* avoid compiler warning */ - session_device_id = session_device_id; + /* Avoid compiler warnings. */ + (void)session_dev_id; - if (!(vdevice = get_vdevice_by_index(device_index))) + if (!(vdev = get_vdev_by_index(dev_index))) return SR_ERR; sr_info("session_driver: opening archive %s file %s", sessionfile, - vdevice->capturefile); + vdev->capturefile); - if (!(vdevice->archive = zip_open(sessionfile, 0, &err))) { - sr_warn("Failed to open session file '%s': zip error %d\n", - sessionfile, err); + if (!(vdev->archive = zip_open(sessionfile, 0, &err))) { + sr_err("session driver: Failed to open session file '%s': " + "zip error %d\n", sessionfile, err); return SR_ERR; } - if (zip_stat(vdevice->archive, vdevice->capturefile, 0, &zs) == -1) { - sr_warn("Failed to check capture file '%s' in session file '%s'.", - vdevice->capturefile, sessionfile); + if (zip_stat(vdev->archive, vdev->capturefile, 0, &zs) == -1) { + sr_err("session driver: Failed to check capture file '%s' in " + "session file '%s'.", vdev->capturefile, sessionfile); return SR_ERR; } - if (!(vdevice->capfile = zip_fopen(vdevice->archive, vdevice->capturefile, 0))) { - sr_warn("Failed to open capture file '%s' in session file '%s'.", - vdevice->capturefile, sessionfile); + if (!(vdev->capfile = zip_fopen(vdev->archive, vdev->capturefile, 0))) { + sr_err("session driver: Failed to open capture file '%s' in " + "session file '%s'.", vdev->capturefile, sessionfile); return SR_ERR; } /* freewheeling source */ - sr_session_source_add(-1, 0, 0, feed_chunk, session_device_id); + sr_session_source_add(-1, 0, 0, feed_chunk, session_dev_id); if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) { - sr_err("session: %s: packet malloc failed", __func__); + sr_err("session driver: %s: packet malloc failed", __func__); return SR_ERR_MALLOC; } if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) { - sr_err("session: %s: header malloc failed", __func__); + sr_err("session driver: %s: header malloc failed", __func__); return SR_ERR_MALLOC; } @@ -276,28 +322,27 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) packet->payload = (unsigned char *)header; header->feed_version = 1; gettimeofday(&header->starttime, NULL); - header->samplerate = 0; - header->num_logic_probes = vdevice->num_probes; - header->num_analog_probes = 0; - sr_session_bus(session_device_id, packet); + header->samplerate = vdev->samplerate; + header->num_logic_probes = vdev->num_probes; + sr_session_bus(session_dev_id, packet); g_free(header); g_free(packet); return SR_OK; } -struct sr_device_plugin session_driver = { - "session", - "Session-emulating driver", - 1, - hw_init, - hw_cleanup, - hw_opendev, - NULL, - hw_get_device_info, - hw_get_status, - hw_get_capabilities, - hw_set_configuration, - hw_start_acquisition, - NULL, +SR_PRIV struct sr_dev_driver session_driver = { + .name = "session", + .longname = "Session-emulating driver", + .api_version = 1, + .init = hw_init, + .cleanup = hw_cleanup, + .dev_open = hw_dev_open, + .dev_close = NULL, + .dev_info_get = hw_dev_info_get, + .dev_status_get = hw_dev_status_get, + .hwcap_get_all = hw_hwcap_get_all, + .dev_config_set = hw_dev_config_set, + .dev_acquisition_start = hw_dev_acquisition_start, + .dev_acquisition_stop = NULL, };