[libsigrok.git] / hardware / nexus-osciprime / api.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
 *
 * 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
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <string.h>
#include <glib.h>
#include "libsigrok.h"
#include "libsigrok-internal.h"
#include "protocol.h"

#define OSCI_VENDOR "Nexus Computing"
#define OSCI_MODEL "OsciPrime"
#define OSCI_VERSION "1.0"
#define OSCI_FIRMWARE FIRMWARE_DIR "/nexus-osciprime.fw"
#define OSCI_VIDPID "04b4.1004"

static const int hwopts[] = {
	SR_CONF_CONN,
	SR_CONF_SERIALCOMM,
	0,
};

static const int hwcaps[] = {
	SR_CONF_OSCILLOSCOPE,
	SR_CONF_LIMIT_SAMPLES,
	SR_CONF_CONTINUOUS,
	SR_CONF_TIMEBASE,
	SR_CONF_VDIV,
	0,
};

static const struct sr_rational timebases[] = {
	/* 24 MHz */
	{ 42, 1e9 },
	/* 12 MHz */
	{ 83, 1e9 },
	/* 6 MHz */
	{ 167, 1e9 },
	/* 3 MHz */
	{ 333, 1e9 },
	/* 1.5 MHz */
	{ 667, 1e9 },
	/* 750 kHz */
	{ 1333, 1e9 },
	/* 375 kHz */
	{ 2667, 1e9 },
	/* 187.5 kHz */
	{ 5333, 1e9 },
	/* 93.25 kHz */
	{ 10724, 1e9 },
	/* 46.875 kHz */
	{ 21333, 1e9 },
	/* 23.4375 kHz */
	{ 42666, 1e9 },
	/* 11.718 kHz */
	{ 85339, 1e9 },
	/* 5.859 kHz */
	{ 170678, 1e9 },
	/* 2.929 kHz */
	{ 341413, 1e9 },
	/* 1.465 kHz */
	{ 682594, 1e9 },
	/* 732 Hz */
	{ 1366, 1e6 },
	/* 366 Hz */
	{ 2732, 1e6 },
	/* 183 Hz */
	{ 5464, 1e6 },
	/* 91 Hz */
	{ 10989, 1e6 },
	/* 46 Hz */
	{ 21739, 1e6 },
	/* 23 Hz */
	{ 43478, 1e6 },
	/* 12 Hz */
	{ 83333, 1e6 },
};

static const char *probe_names[] = {
	"CHA", "CHB",
	NULL,
};

static const struct sr_rational vdivs[] = {
	{ 1, 1 },
	{ 2, 1 },
	{ 5, 2 },
	{ 5, 1 },
	{ 10, 1 },
};


SR_PRIV struct sr_dev_driver nexus_osciprime_driver_info;
static struct sr_dev_driver *di = &nexus_osciprime_driver_info;
static int hw_dev_close(struct sr_dev_inst *sdi);

/* Properly close and free all devices. */
static int clear_instances(void)
{
	struct sr_dev_inst *sdi;
	struct drv_context *drvc;
	struct dev_context *devc;
	GSList *l;

	if (!(drvc = di->priv))
		return SR_OK;

	for (l = drvc->instances; l; l = l->next) {
		if (!(sdi = l->data))
			continue;
		if (!(devc = sdi->priv))
			continue;

		hw_dev_close(sdi);
		sr_usb_dev_inst_free(devc->usb);
		sr_dev_inst_free(sdi);
	}

	g_slist_free(drvc->instances);
	drvc->instances = NULL;

	return SR_OK;
}

static int hw_init(struct sr_context *sr_ctx)
{
	return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
}

static GSList *hw_scan(GSList *options)
{
	struct drv_context *drvc;
	struct dev_context *devc;
	struct sr_dev_inst *sdi;
	struct sr_usb_dev_inst *usb;
	struct sr_config *src;
	struct sr_probe *probe;
	libusb_device *dev;
	GSList *usb_devices, *devices, *l;
	int i;
	const char *conn;

	(void)options;

	drvc = di->priv;

	/* USB scan is always authoritative. */
	clear_instances();

	conn = NULL;
	for (l = options; l; l = l->next) {
		src = l->data;
		switch (src->key) {
		case SR_CONF_CONN:
			conn = src->value;
			break;
		}
	}
	if (!conn)
		conn = OSCI_VIDPID;

	devices = NULL;
	if ((usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn))) {
		for (l = usb_devices; l; l = l->next) {
			usb = l->data;
			if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE,
					OSCI_VENDOR, OSCI_MODEL, OSCI_VERSION)))
				return NULL;
			sdi->driver = di;
			for (i = 0; probe_names[i]; i++) {
				if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
						probe_names[i])))
					return NULL;
				sdi->probes = g_slist_append(sdi->probes, probe);
			}

			if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
				return NULL;
			sdi->priv = devc;
			devc->usb = usb;

			if (strcmp(conn, OSCI_VIDPID)) {
				if (sr_usb_open(drvc->sr_ctx->libusb_ctx, usb) != SR_OK)
					break;
				dev = libusb_get_device(usb->devhdl);
				if (ezusb_upload_firmware(dev, 0, OSCI_FIRMWARE) == SR_OK)
					/* Remember when the firmware on this device was updated */
					devc->fw_updated = g_get_monotonic_time();
				else
					sr_err("Firmware upload failed for device "
							"at bus %d address %d.", usb->bus, usb->address);
			}

			drvc->instances = g_slist_append(drvc->instances, sdi);
			devices = g_slist_append(devices, sdi);
		}
		g_slist_free(usb_devices);
	} else
		g_slist_free_full(usb_devices, g_free);

	return devices;
}

static GSList *hw_dev_list(void)
{
	struct drv_context *drvc;

	drvc = di->priv;

	return drvc->instances;
}

static int hw_dev_open(struct sr_dev_inst *sdi)
{

	/* TODO */
	(void)sdi;

	return SR_OK;
}

static int hw_dev_close(struct sr_dev_inst *sdi)
{

	/* TODO */
	(void)sdi;

	return SR_OK;
}

static int hw_cleanup(void)
{
	clear_instances();

	/* TODO */

	return SR_OK;
}

static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
{
	int ret;

	/* TODO */
	(void)value;

	if (sdi->status != SR_ST_ACTIVE) {
		sr_err("Device inactive, can't set config options.");
		return SR_ERR;
	}

	ret = SR_OK;
	switch (id) {

	default:
		sr_err("Unknown hardware capability: %d.", id);
		ret = SR_ERR_ARG;
	}

	return ret;
}

static int config_list(int key, const void **data, const struct sr_dev_inst *sdi)
{

	(void)sdi;

	switch (key) {
	default:
		return SR_ERR_ARG;
	}

	return SR_OK;
}

static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
				    void *cb_data)
{
	/* TODO */
	(void)sdi;
	(void)cb_data;

	return SR_OK;
}

static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
{
	(void)cb_data;

	if (sdi->status != SR_ST_ACTIVE) {
		sr_err("Device inactive, can't stop acquisition.");
		return SR_ERR;
	}

	/* TODO */

	return SR_OK;
}

SR_PRIV struct sr_dev_driver nexus_osciprime_driver_info = {
	.name = "nexus-osciprime",
	.longname = "Nexus OsciPrime",
	.api_version = 1,
	.init = hw_init,
	.cleanup = hw_cleanup,
	.scan = hw_scan,
	.dev_list = hw_dev_list,
	.dev_clear = clear_instances,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = hw_dev_open,
	.dev_close = hw_dev_close,
	.dev_acquisition_start = hw_dev_acquisition_start,
	.dev_acquisition_stop = hw_dev_acquisition_stop,
	.priv = NULL,
};
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <string.h>
	21	#include <glib.h>
	22	#include "libsigrok.h"
	23	#include "libsigrok-internal.h"
	24	#include "protocol.h"
	25
	26	#define OSCI_VENDOR "Nexus Computing"
	27	#define OSCI_MODEL "OsciPrime"
	28	#define OSCI_VERSION "1.0"
	29	#define OSCI_FIRMWARE FIRMWARE_DIR "/nexus-osciprime.fw"
	30	#define OSCI_VIDPID "04b4.1004"
	31
	32	static const int hwopts[] = {
	33	SR_CONF_CONN,
	34	SR_CONF_SERIALCOMM,
	35	0,
	36	};
	37
	38	static const int hwcaps[] = {
	39	SR_CONF_OSCILLOSCOPE,
	40	SR_CONF_LIMIT_SAMPLES,
	41	SR_CONF_CONTINUOUS,
	42	SR_CONF_TIMEBASE,
	43	SR_CONF_VDIV,
	44	0,
	45	};
	46
	47	static const struct sr_rational timebases[] = {
	48	/* 24 MHz */
	49	{ 42, 1e9 },
	50	/* 12 MHz */
	51	{ 83, 1e9 },
	52	/* 6 MHz */
	53	{ 167, 1e9 },
	54	/* 3 MHz */
	55	{ 333, 1e9 },
	56	/* 1.5 MHz */
	57	{ 667, 1e9 },
	58	/* 750 kHz */
	59	{ 1333, 1e9 },
	60	/* 375 kHz */
	61	{ 2667, 1e9 },
	62	/* 187.5 kHz */
	63	{ 5333, 1e9 },
	64	/* 93.25 kHz */
	65	{ 10724, 1e9 },
	66	/* 46.875 kHz */
	67	{ 21333, 1e9 },
	68	/* 23.4375 kHz */
	69	{ 42666, 1e9 },
	70	/* 11.718 kHz */
	71	{ 85339, 1e9 },
	72	/* 5.859 kHz */
	73	{ 170678, 1e9 },
	74	/* 2.929 kHz */
	75	{ 341413, 1e9 },
	76	/* 1.465 kHz */
	77	{ 682594, 1e9 },
	78	/* 732 Hz */
	79	{ 1366, 1e6 },
	80	/* 366 Hz */
	81	{ 2732, 1e6 },
	82	/* 183 Hz */
	83	{ 5464, 1e6 },
	84	/* 91 Hz */
	85	{ 10989, 1e6 },
	86	/* 46 Hz */
	87	{ 21739, 1e6 },
	88	/* 23 Hz */
	89	{ 43478, 1e6 },
	90	/* 12 Hz */
	91	{ 83333, 1e6 },
	92	};
	93
	94	static const char *probe_names[] = {
	95	"CHA", "CHB",
	96	NULL,
	97	};
	98
	99	static const struct sr_rational vdivs[] = {
	100	{ 1, 1 },
	101	{ 2, 1 },
	102	{ 5, 2 },
	103	{ 5, 1 },
	104	{ 10, 1 },
	105	};
	106
	107
	108	SR_PRIV struct sr_dev_driver nexus_osciprime_driver_info;
	109	static struct sr_dev_driver *di = &nexus_osciprime_driver_info;
	110	static int hw_dev_close(struct sr_dev_inst *sdi);
	111
	112	/* Properly close and free all devices. */
	113	static int clear_instances(void)
	114	{
	115	struct sr_dev_inst *sdi;
	116	struct drv_context *drvc;
	117	struct dev_context *devc;
	118	GSList *l;
	119
	120	if (!(drvc = di->priv))
	121	return SR_OK;
	122
	123	for (l = drvc->instances; l; l = l->next) {
	124	if (!(sdi = l->data))
	125	continue;
	126	if (!(devc = sdi->priv))
	127	continue;
	128
	129	hw_dev_close(sdi);
	130	sr_usb_dev_inst_free(devc->usb);
	131	sr_dev_inst_free(sdi);
	132	}
	133
	134	g_slist_free(drvc->instances);
	135	drvc->instances = NULL;
	136
	137	return SR_OK;
	138	}
	139
	140	static int hw_init(struct sr_context *sr_ctx)
	141	{
	142	return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
	143	}
	144
	145	static GSList hw_scan(GSList options)
	146	{
	147	struct drv_context *drvc;
	148	struct dev_context *devc;
	149	struct sr_dev_inst *sdi;
	150	struct sr_usb_dev_inst *usb;
	151	struct sr_config *src;
	152	struct sr_probe *probe;
	153	libusb_device *dev;
	154	GSList usb_devices, devices, *l;
	155	int i;
	156	const char *conn;
	157
	158	(void)options;
	159
	160	drvc = di->priv;
	161
	162	/* USB scan is always authoritative. */
	163	clear_instances();
	164
	165	conn = NULL;
	166	for (l = options; l; l = l->next) {
	167	src = l->data;
	168	switch (src->key) {
	169	case SR_CONF_CONN:
	170	conn = src->value;
	171	break;
	172	}
	173	}
	174	if (!conn)
	175	conn = OSCI_VIDPID;
	176
	177	devices = NULL;
	178	if ((usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn))) {
	179	for (l = usb_devices; l; l = l->next) {
	180	usb = l->data;
	181	if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE,
	182	OSCI_VENDOR, OSCI_MODEL, OSCI_VERSION)))
	183	return NULL;
	184	sdi->driver = di;
	185	for (i = 0; probe_names[i]; i++) {
	186	if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
	187	probe_names[i])))
	188	return NULL;
	189	sdi->probes = g_slist_append(sdi->probes, probe);
	190	}
	191
	192	if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
	193	return NULL;
	194	sdi->priv = devc;
	195	devc->usb = usb;
	196
	197	if (strcmp(conn, OSCI_VIDPID)) {
	198	if (sr_usb_open(drvc->sr_ctx->libusb_ctx, usb) != SR_OK)
	199	break;
	200	dev = libusb_get_device(usb->devhdl);
	201	if (ezusb_upload_firmware(dev, 0, OSCI_FIRMWARE) == SR_OK)
	202	/* Remember when the firmware on this device was updated */
	203	devc->fw_updated = g_get_monotonic_time();
	204	else
	205	sr_err("Firmware upload failed for device "
	206	"at bus %d address %d.", usb->bus, usb->address);
	207	}
	208
	209	drvc->instances = g_slist_append(drvc->instances, sdi);
	210	devices = g_slist_append(devices, sdi);
	211	}
	212	g_slist_free(usb_devices);
	213	} else
	214	g_slist_free_full(usb_devices, g_free);
	215
	216	return devices;
	217	}
	218
	219	static GSList *hw_dev_list(void)
	220	{
	221	struct drv_context *drvc;
	222
	223	drvc = di->priv;
	224
	225	return drvc->instances;
	226	}
	227
	228	static int hw_dev_open(struct sr_dev_inst *sdi)
	229	{
	230
	231	/* TODO */
	232	(void)sdi;
	233
	234	return SR_OK;
	235	}
	236
	237	static int hw_dev_close(struct sr_dev_inst *sdi)
	238	{
	239
	240	/* TODO */
	241	(void)sdi;
	242
	243	return SR_OK;
	244	}
	245
	246	static int hw_cleanup(void)
	247	{
	248	clear_instances();
	249
	250	/* TODO */
	251
	252	return SR_OK;
	253	}
	254
	255	static int config_set(int id, const void value, const struct sr_dev_inst sdi)
	256	{
	257	int ret;
	258
	259	/* TODO */
	260	(void)value;
	261
	262	if (sdi->status != SR_ST_ACTIVE) {
	263	sr_err("Device inactive, can't set config options.");
	264	return SR_ERR;
	265	}
	266
	267	ret = SR_OK;
	268	switch (id) {
	269
	270	default:
	271	sr_err("Unknown hardware capability: %d.", id);
	272	ret = SR_ERR_ARG;
	273	}
	274
	275	return ret;
	276	}
	277
	278	static int config_list(int key, const void *data, const struct sr_dev_inst sdi)
	279	{
	280
	281	(void)sdi;
	282
	283	switch (key) {
	284	default:
	285	return SR_ERR_ARG;
	286	}
	287
	288	return SR_OK;
	289	}
	290
	291	static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
	292	void *cb_data)
	293	{
	294	/* TODO */
	295	(void)sdi;
	296	(void)cb_data;
	297
	298	return SR_OK;
	299	}
	300
	301	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	302	{
	303	(void)cb_data;
	304
	305	if (sdi->status != SR_ST_ACTIVE) {
	306	sr_err("Device inactive, can't stop acquisition.");
	307	return SR_ERR;
	308	}
	309
	310	/* TODO */
	311
	312	return SR_OK;
	313	}
	314
	315	SR_PRIV struct sr_dev_driver nexus_osciprime_driver_info = {
	316	.name = "nexus-osciprime",
	317	.longname = "Nexus OsciPrime",
	318	.api_version = 1,
	319	.init = hw_init,
	320	.cleanup = hw_cleanup,
	321	.scan = hw_scan,
	322	.dev_list = hw_dev_list,
	323	.dev_clear = clear_instances,
	324	.config_set = config_set,
	325	.config_list = config_list,
	326	.dev_open = hw_dev_open,
	327	.dev_close = hw_dev_close,
	328	.dev_acquisition_start = hw_dev_acquisition_start,
	329	.dev_acquisition_stop = hw_dev_acquisition_stop,
	330	.priv = NULL,
	331	};