X-Git-Url: http://git.tdb.fi/?p=ext%2Fsubsurface.git;a=blobdiff_plain;f=libdivecomputer.c;h=d96d2769f7391afb3bccebb64df1de5fd21a33e5;hp=9d4c1065a3817ce046798448b7c7a39a2a10be2a;hb=HEAD;hpb=ff0209a5b42ced7d8b9ef9c5d84cbc5a4d84a0ac

diff --git a/libdivecomputer.c b/libdivecomputer.c
index 9d4c106..d96d276 100644
--- a/libdivecomputer.c
+++ b/libdivecomputer.c
@@ -10,7 +10,15 @@
 
 #include "libdivecomputer.h"
 
-static void error(const char *fmt, ...)
+/* Christ. Libdivecomputer has the worst configuration system ever. */
+#ifdef HW_FROG_H
+  #define NOT_FROG , 0
+  #define LIBDIVECOMPUTER_SUPPORTS_FROG
+#else
+  #define NOT_FROG
+#endif
+
+static GError *error(const char *fmt, ...)
 {
 	va_list args;
 	GError *error;
@@ -20,86 +28,25 @@ static void error(const char *fmt, ...)
 		g_quark_from_string("subsurface"),
 		DIVE_ERROR_PARSE, fmt, args);
 	va_end(args);
-	report_error(error);
-	g_error_free(error);
+	return error;
 }
 
-static parser_status_t create_parser(device_data_t *devdata, parser_t **parser)
+static dc_status_t create_parser(device_data_t *devdata, dc_parser_t **parser)
 {
-	switch (devdata->type) {
-	case DEVICE_TYPE_SUUNTO_SOLUTION:
-		return suunto_solution_parser_create(parser);
-
-	case DEVICE_TYPE_SUUNTO_EON:
-		return suunto_eon_parser_create(parser, 0);
-
-	case DEVICE_TYPE_SUUNTO_VYPER:
-		if (devdata->devinfo.model == 0x01)
-			return suunto_eon_parser_create(parser, 1);
-		return suunto_vyper_parser_create(parser);
-
-	case DEVICE_TYPE_SUUNTO_VYPER2:
-	case DEVICE_TYPE_SUUNTO_D9:
-		return suunto_d9_parser_create(parser, devdata->devinfo.model);
-
-	case DEVICE_TYPE_UWATEC_ALADIN:
-	case DEVICE_TYPE_UWATEC_MEMOMOUSE:
-		return uwatec_memomouse_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
-
-	case DEVICE_TYPE_UWATEC_SMART:
-		return uwatec_smart_parser_create(parser, devdata->devinfo.model, devdata->clock.devtime, devdata->clock.systime);
-
-	case DEVICE_TYPE_REEFNET_SENSUS:
-		return reefnet_sensus_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
-
-	case DEVICE_TYPE_REEFNET_SENSUSPRO:
-		return reefnet_sensuspro_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
-
-	case DEVICE_TYPE_REEFNET_SENSUSULTRA:
-		return reefnet_sensusultra_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
-
-	case DEVICE_TYPE_OCEANIC_VTPRO:
-		return oceanic_vtpro_parser_create(parser);
-
-	case DEVICE_TYPE_OCEANIC_VEO250:
-		return oceanic_veo250_parser_create(parser, devdata->devinfo.model);
-
-	case DEVICE_TYPE_OCEANIC_ATOM2:
-		return oceanic_atom2_parser_create(parser, devdata->devinfo.model);
-
-	case DEVICE_TYPE_MARES_NEMO:
-	case DEVICE_TYPE_MARES_PUCK:
-		return mares_nemo_parser_create(parser, devdata->devinfo.model);
-
-	case DEVICE_TYPE_MARES_ICONHD:
-		return mares_iconhd_parser_create(parser, devdata->devinfo.model);
-
-	case DEVICE_TYPE_HW_OSTC:
-		return hw_ostc_parser_create(parser);
-
-	case DEVICE_TYPE_CRESSI_EDY:
-	case DEVICE_TYPE_ZEAGLE_N2ITION3:
-		return cressi_edy_parser_create(parser, devdata->devinfo.model);
-
-	case DEVICE_TYPE_ATOMICS_COBALT:
-		return atomics_cobalt_parser_create(parser);
-
-	default:
-		return PARSER_STATUS_ERROR;
-	}
+	return dc_parser_new(parser, devdata->device);
 }
 
-static int parse_gasmixes(struct dive *dive, parser_t *parser, int ngases)
+static int parse_gasmixes(device_data_t *devdata, struct dive *dive, dc_parser_t *parser, int ngases)
 {
 	int i;
 
 	for (i = 0; i < ngases; i++) {
 		int rc;
-		gasmix_t gasmix = {0};
+		dc_gasmix_t gasmix = {0};
 		int o2, he;
 
-		rc = parser_get_field(parser, FIELD_TYPE_GASMIX, i, &gasmix);
-		if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED)
+		rc = dc_parser_get_field(parser, DC_FIELD_GASMIX, i, &gasmix);
+		if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED)
 			return rc;
 
 		if (i >= MAX_CYLINDERS)
@@ -109,7 +56,7 @@ static int parse_gasmixes(struct dive *dive, parser_t *parser, int ngases)
 		he = gasmix.helium * 1000 + 0.5;
 
 		/* Ignore bogus data - libdivecomputer does some crazy stuff */
-		if (o2 < 210 || o2 >= 1000)
+		if (o2 <= AIR_PERMILLE || o2 >= 1000)
 			o2 = 0;
 		if (he < 0 || he >= 800 || o2+he >= 1000)
 			he = 0;
@@ -117,10 +64,10 @@ static int parse_gasmixes(struct dive *dive, parser_t *parser, int ngases)
 		dive->cylinder[i].gasmix.o2.permille = o2;
 		dive->cylinder[i].gasmix.he.permille = he;
 	}
-	return PARSER_STATUS_SUCCESS;
+	return DC_STATUS_SUCCESS;
 }
 
-static void handle_event(struct dive *dive, struct sample *sample, parser_sample_value_t value)
+static void handle_event(struct dive *dive, struct sample *sample, dc_sample_value_t value)
 {
 	int type, time;
 	static const char *events[] = {
@@ -158,7 +105,7 @@ static void handle_event(struct dive *dive, struct sample *sample, parser_sample
 }
 
 void
-sample_cb(parser_sample_type_t type, parser_sample_value_t value, void *userdata)
+sample_cb(dc_sample_type_t type, dc_sample_value_t value, void *userdata)
 {
 	int i;
 	struct dive **divep = userdata;
@@ -166,40 +113,40 @@ sample_cb(parser_sample_type_t type, parser_sample_value_t value, void *userdata
 	struct sample *sample;
 
 	/*
-	 * We fill in the "previous" sample - except for SAMPLE_TYPE_TIME,
+	 * We fill in the "previous" sample - except for DC_SAMPLE_TIME,
 	 * which creates a new one.
 	 */
 	sample = dive->samples ? dive->sample+dive->samples-1 : NULL;
 
 	switch (type) {
-	case SAMPLE_TYPE_TIME:
+	case DC_SAMPLE_TIME:
 		sample = prepare_sample(divep);
 		sample->time.seconds = value.time;
-		finish_sample(*divep, sample);
+		finish_sample(*divep);
 		break;
-	case SAMPLE_TYPE_DEPTH:
+	case DC_SAMPLE_DEPTH:
 		sample->depth.mm = value.depth * 1000 + 0.5;
 		break;
-	case SAMPLE_TYPE_PRESSURE:
+	case DC_SAMPLE_PRESSURE:
 		sample->cylinderindex = value.pressure.tank;
 		sample->cylinderpressure.mbar = value.pressure.value * 1000 + 0.5;
 		break;
-	case SAMPLE_TYPE_TEMPERATURE:
+	case DC_SAMPLE_TEMPERATURE:
 		sample->temperature.mkelvin = (value.temperature + 273.15) * 1000 + 0.5;
 		break;
-	case SAMPLE_TYPE_EVENT:
+	case DC_SAMPLE_EVENT:
 		handle_event(dive, sample, value);
 		break;
-	case SAMPLE_TYPE_RBT:
+	case DC_SAMPLE_RBT:
 		printf("   <rbt>%u</rbt>\n", value.rbt);
 		break;
-	case SAMPLE_TYPE_HEARTBEAT:
+	case DC_SAMPLE_HEARTBEAT:
 		printf("   <heartbeat>%u</heartbeat>\n", value.heartbeat);
 		break;
-	case SAMPLE_TYPE_BEARING:
+	case DC_SAMPLE_BEARING:
 		printf("   <bearing>%u</bearing>\n", value.bearing);
 		break;
-	case SAMPLE_TYPE_VENDOR:
+	case DC_SAMPLE_VENDOR:
 		printf("   <vendor type=\"%u\" size=\"%u\">", value.vendor.type, value.vendor.size);
 		for (i = 0; i < value.vendor.size; ++i)
 			printf("%02X", ((unsigned char *) value.vendor.data)[i]);
@@ -210,12 +157,23 @@ sample_cb(parser_sample_type_t type, parser_sample_value_t value, void *userdata
 	}
 }
 
+static void dev_info(device_data_t *devdata, const char *fmt, ...)
+{
+	char buffer[32];
+	va_list ap;
+
+	va_start(ap, fmt);
+	vsnprintf(buffer, sizeof(buffer), fmt, ap);
+	va_end(ap);
+	update_progressbar_text(&devdata->progress, buffer);
+}
+
+static int import_dive_number = 0;
 
-static int parse_samples(struct dive **divep, parser_t *parser)
+static int parse_samples(device_data_t *devdata, struct dive **divep, dc_parser_t *parser)
 {
 	// Parse the sample data.
-	printf("Parsing the sample data.\n");
-	return parser_samples_foreach(parser, sample_cb, divep);
+	return dc_parser_samples_foreach(parser, sample_cb, divep);
 }
 
 /*
@@ -235,35 +193,45 @@ static int find_dive(struct dive *dive, device_data_t *devdata)
 	return 0;
 }
 
+static inline int year(int year)
+{
+	if (year < 70)
+		return year + 2000;
+	if (year < 100)
+		return year + 1900;
+	return year;
+}
+
 static int dive_cb(const unsigned char *data, unsigned int size,
 	const unsigned char *fingerprint, unsigned int fsize,
 	void *userdata)
 {
 	int rc;
-	parser_t *parser = NULL;
+	dc_parser_t *parser = NULL;
 	device_data_t *devdata = userdata;
 	dc_datetime_t dt = {0};
 	struct tm tm;
 	struct dive *dive;
 
 	rc = create_parser(devdata, &parser);
-	if (rc != PARSER_STATUS_SUCCESS) {
-		fprintf(stderr, "Unable to create parser for %s", devdata->name);
+	if (rc != DC_STATUS_SUCCESS) {
+		dev_info(devdata, "Unable to create parser for %s %s", devdata->vendor, devdata->product);
 		return rc;
 	}
 
-	rc = parser_set_data(parser, data, size);
-	if (rc != PARSER_STATUS_SUCCESS) {
-		fprintf(stderr, "Error registering the data.");
-		parser_destroy(parser);
+	rc = dc_parser_set_data(parser, data, size);
+	if (rc != DC_STATUS_SUCCESS) {
+		dev_info(devdata, "Error registering the data");
+		dc_parser_destroy(parser);
 		return rc;
 	}
 
+	import_dive_number++;
 	dive = alloc_dive();
-	rc = parser_get_datetime(parser, &dt);
-	if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
-		fprintf(stderr, "Error parsing the datetime.");
-		parser_destroy (parser);
+	rc = dc_parser_get_datetime(parser, &dt);
+	if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+		dev_info(devdata, "Error parsing the datetime");
+		dc_parser_destroy(parser);
 		return rc;
 	}
 
@@ -276,53 +244,52 @@ static int dive_cb(const unsigned char *data, unsigned int size,
 	dive->when = utc_mktime(&tm);
 
 	// Parse the divetime.
-	printf("Parsing the divetime.\n");
+	dev_info(devdata, "Dive %d: %s %d %04d", import_dive_number,
+		monthname(tm.tm_mon), tm.tm_mday, year(tm.tm_year));
 	unsigned int divetime = 0;
-	rc = parser_get_field (parser, FIELD_TYPE_DIVETIME, 0, &divetime);
-	if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
-		fprintf(stderr, "Error parsing the divetime.");
-		parser_destroy(parser);
+	rc = dc_parser_get_field (parser, DC_FIELD_DIVETIME, 0, &divetime);
+	if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+		dev_info(devdata, "Error parsing the divetime");
+		dc_parser_destroy(parser);
 		return rc;
 	}
 	dive->duration.seconds = divetime;
 
 	// Parse the maxdepth.
-	printf("Parsing the maxdepth.\n");
 	double maxdepth = 0.0;
-	rc = parser_get_field(parser, FIELD_TYPE_MAXDEPTH, 0, &maxdepth);
-	if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
-		fprintf(stderr, "Error parsing the maxdepth.");
-		parser_destroy(parser);
+	rc = dc_parser_get_field(parser, DC_FIELD_MAXDEPTH, 0, &maxdepth);
+	if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+		dev_info(devdata, "Error parsing the maxdepth");
+		dc_parser_destroy(parser);
 		return rc;
 	}
 	dive->maxdepth.mm = maxdepth * 1000 + 0.5;
 
 	// Parse the gas mixes.
-	printf("Parsing the gas mixes.\n");
 	unsigned int ngases = 0;
-	rc = parser_get_field(parser, FIELD_TYPE_GASMIX_COUNT, 0, &ngases);
-	if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
-		fprintf(stderr, "Error parsing the gas mix count.");
-		parser_destroy(parser);
+	rc = dc_parser_get_field(parser, DC_FIELD_GASMIX_COUNT, 0, &ngases);
+	if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+		dev_info(devdata, "Error parsing the gas mix count");
+		dc_parser_destroy(parser);
 		return rc;
 	}
 
-	rc = parse_gasmixes(dive, parser, ngases);
-	if (rc != PARSER_STATUS_SUCCESS) {
-		fprintf(stderr, "Error parsing the gas mix.");
-		parser_destroy(parser);
+	rc = parse_gasmixes(devdata, dive, parser, ngases);
+	if (rc != DC_STATUS_SUCCESS) {
+		dev_info(devdata, "Error parsing the gas mix");
+		dc_parser_destroy(parser);
 		return rc;
 	}
 
 	// Initialize the sample data.
-	rc = parse_samples(&dive, parser);
-	if (rc != PARSER_STATUS_SUCCESS) {
-		fprintf(stderr, "Error parsing the samples.");
-		parser_destroy(parser);
+	rc = parse_samples(devdata, &dive, parser);
+	if (rc != DC_STATUS_SUCCESS) {
+		dev_info(devdata, "Error parsing the samples");
+		dc_parser_destroy(parser);
 		return rc;
 	}
 
-	parser_destroy(parser);
+	dc_parser_destroy(parser);
 
 	/* If we already saw this dive, abort. */
 	if (find_dive(dive, devdata))
@@ -333,109 +300,35 @@ static int dive_cb(const unsigned char *data, unsigned int size,
 }
 
 
-static device_status_t import_device_data(device_t *device, device_data_t *devicedata)
+static dc_status_t import_device_data(dc_device_t *device, device_data_t *devicedata)
 {
-	return device_foreach(device, dive_cb, devicedata);
+	return dc_device_foreach(device, dive_cb, devicedata);
 }
 
-static device_status_t device_open(const char *devname,
-	device_type_t type,
-	device_t **device)
-{
-	switch (type) {
-	case DEVICE_TYPE_SUUNTO_SOLUTION:
-		return suunto_solution_device_open(device, devname);
-
-	case DEVICE_TYPE_SUUNTO_EON:
-		return suunto_eon_device_open(device, devname);
-
-	case DEVICE_TYPE_SUUNTO_VYPER:
-		return suunto_vyper_device_open(device, devname);
-
-	case DEVICE_TYPE_SUUNTO_VYPER2:
-		return suunto_vyper2_device_open(device, devname);
-
-	case DEVICE_TYPE_SUUNTO_D9:
-		return suunto_d9_device_open(device, devname);
-
-	case DEVICE_TYPE_UWATEC_ALADIN:
-		return uwatec_aladin_device_open(device, devname);
 
-	case DEVICE_TYPE_UWATEC_MEMOMOUSE:
-		return uwatec_memomouse_device_open(device, devname);
-
-	case DEVICE_TYPE_UWATEC_SMART:
-		return uwatec_smart_device_open(device);
-
-	case DEVICE_TYPE_REEFNET_SENSUS:
-		return reefnet_sensus_device_open(device, devname);
-
-	case DEVICE_TYPE_REEFNET_SENSUSPRO:
-		return reefnet_sensuspro_device_open(device, devname);
-
-	case DEVICE_TYPE_REEFNET_SENSUSULTRA:
-		return reefnet_sensusultra_device_open(device, devname);
-
-	case DEVICE_TYPE_OCEANIC_VTPRO:
-		return oceanic_vtpro_device_open(device, devname);
-
-	case DEVICE_TYPE_OCEANIC_VEO250:
-		return oceanic_veo250_device_open(device, devname);
-
-	case DEVICE_TYPE_OCEANIC_ATOM2:
-		return oceanic_atom2_device_open(device, devname);
-
-	case DEVICE_TYPE_MARES_NEMO:
-		return mares_nemo_device_open(device, devname);
-
-	case DEVICE_TYPE_MARES_PUCK:
-		return mares_puck_device_open(device, devname);
-
-	case DEVICE_TYPE_MARES_ICONHD:
-		return mares_iconhd_device_open(device, devname);
-
-	case DEVICE_TYPE_HW_OSTC:
-		return hw_ostc_device_open(device, devname);
-
-	case DEVICE_TYPE_CRESSI_EDY:
-		return cressi_edy_device_open(device, devname);
-
-	case DEVICE_TYPE_ZEAGLE_N2ITION3:
-		return zeagle_n2ition3_device_open(device, devname);
-
-	case DEVICE_TYPE_ATOMICS_COBALT:
-		return atomics_cobalt_device_open(device);
-
-	default:
-		return DEVICE_STATUS_ERROR;
-	}
-}
-
-static void event_cb(device_t *device, device_event_t event, const void *data, void *userdata)
+static void event_cb(dc_device_t *device, dc_event_type_t event, const void *data, void *userdata)
 {
-	const device_progress_t *progress = data;
-	const device_devinfo_t *devinfo = data;
-	const device_clock_t *clock = data;
+	const dc_event_progress_t *progress = data;
+	const dc_event_devinfo_t *devinfo = data;
+	const dc_event_clock_t *clock = data;
 	device_data_t *devdata = userdata;
 
 	switch (event) {
-	case DEVICE_EVENT_WAITING:
-		printf("Event: waiting for user action\n");
+	case DC_EVENT_WAITING:
+		dev_info(devdata, "Event: waiting for user action");
 		break;
-	case DEVICE_EVENT_PROGRESS:
+	case DC_EVENT_PROGRESS:
 		update_progressbar(&devdata->progress,
 			(double) progress->current / (double) progress->maximum);
 		break;
-	case DEVICE_EVENT_DEVINFO:
-		devdata->devinfo = *devinfo;
-		printf("Event: model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)\n",
+	case DC_EVENT_DEVINFO:
+		dev_info(devdata, "model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)",
 			devinfo->model, devinfo->model,
 			devinfo->firmware, devinfo->firmware,
 			devinfo->serial, devinfo->serial);
 		break;
-	case DEVICE_EVENT_CLOCK:
-		devdata->clock = *clock;
-		printf("Event: systime=%"PRId64", devtime=%u\n",
+	case DC_EVENT_CLOCK:
+		dev_info(devdata, "Event: systime=%"PRId64", devtime=%u\n",
 			(uint64_t)clock->systime, clock->devtime);
 		break;
 	default:
@@ -451,40 +344,53 @@ cancel_cb(void *userdata)
 	return import_thread_cancelled;
 }
 
-static const char *do_libdivecomputer_import(device_data_t *data)
+static const char *do_device_import(device_data_t *data)
 {
-	device_t *device = NULL;
-	device_status_t rc;
-
-	rc = device_open(data->devname, data->type, &device);
-	if (rc != DEVICE_STATUS_SUCCESS)
-		return "Unable to open %s (%s)";
+	dc_status_t rc;
+	dc_device_t *device = data->device;
 
 	// Register the event handler.
-	int events = DEVICE_EVENT_WAITING | DEVICE_EVENT_PROGRESS | DEVICE_EVENT_DEVINFO | DEVICE_EVENT_CLOCK;
-	rc = device_set_events(device, events, event_cb, data);
-	if (rc != DEVICE_STATUS_SUCCESS) {
-		device_close(device);
+	int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK;
+	rc = dc_device_set_events(device, events, event_cb, data);
+	if (rc != DC_STATUS_SUCCESS)
 		return "Error registering the event handler.";
-	}
 
 	// Register the cancellation handler.
-	rc = device_set_cancel(device, cancel_cb, data);
-	if (rc != DEVICE_STATUS_SUCCESS) {
-		device_close(device);
+	rc = dc_device_set_cancel(device, cancel_cb, data);
+	if (rc != DC_STATUS_SUCCESS)
 		return "Error registering the cancellation handler.";
-	}
 
 	rc = import_device_data(device, data);
-	if (rc != DEVICE_STATUS_SUCCESS) {
-		device_close(device);
+	if (rc != DC_STATUS_SUCCESS)
 		return "Dive data import error";
-	}
 
-	device_close(device);
+	/* All good */
 	return NULL;
 }
 
+static const char *do_libdivecomputer_import(device_data_t *data)
+{
+	dc_status_t rc;
+	const char *err;
+
+	import_dive_number = 0;
+	data->device = NULL;
+	data->context = NULL;
+
+	rc = dc_context_new(&data->context);
+	if (rc != DC_STATUS_SUCCESS)
+		return "Unable to create libdivecomputer context";
+
+	err = "Unable to open %s %s (%s)";
+	rc = dc_device_open(&data->device, data->context, data->descriptor, data->devname);
+	if (rc == DC_STATUS_SUCCESS) {
+		err = do_device_import(data);
+		dc_device_close(data->device);
+	}
+	dc_context_free(data->context);
+	return err;
+}
+
 static void *pthread_wrapper(void *_data)
 {
 	device_data_t *data = _data;
@@ -493,7 +399,7 @@ static void *pthread_wrapper(void *_data)
 	return (void *)err_string;
 }
 
-void do_import(device_data_t *data)
+GError *do_import(device_data_t *data)
 {
 	pthread_t pthread;
 	void *retval;
@@ -508,37 +414,6 @@ void do_import(device_data_t *data)
 	if (pthread_join(pthread, &retval) < 0)
 		retval = "Odd pthread error return";
 	if (retval)
-		error(retval, data->name, data->devname);
+		return error(retval, data->vendor, data->product, data->devname);
+	return NULL;
 }
-
-/*
- * Taken from 'example.c' in libdivecomputer.
- *
- * I really wish there was some way to just have
- * libdivecomputer tell us what devices it supports,
- * rather than have the application have to know..
- */
-struct device_list device_list[] = {
-	{ "Suunto Solution",	DEVICE_TYPE_SUUNTO_SOLUTION },
-	{ "Suunto Eon",		DEVICE_TYPE_SUUNTO_EON },
-	{ "Suunto Vyper",	DEVICE_TYPE_SUUNTO_VYPER },
-	{ "Suunto Vyper Air",	DEVICE_TYPE_SUUNTO_VYPER2 },
-	{ "Suunto D9",		DEVICE_TYPE_SUUNTO_D9 },
-	{ "Uwatec Aladin",	DEVICE_TYPE_UWATEC_ALADIN },
-	{ "Uwatec Memo Mouse",	DEVICE_TYPE_UWATEC_MEMOMOUSE },
-	{ "Uwatec Smart",	DEVICE_TYPE_UWATEC_SMART },
-	{ "ReefNet Sensus",	DEVICE_TYPE_REEFNET_SENSUS },
-	{ "ReefNet Sensus Pro",	DEVICE_TYPE_REEFNET_SENSUSPRO },
-	{ "ReefNet Sensus Ultra",DEVICE_TYPE_REEFNET_SENSUSULTRA },
-	{ "Oceanic VT Pro",	DEVICE_TYPE_OCEANIC_VTPRO },
-	{ "Oceanic Veo250",	DEVICE_TYPE_OCEANIC_VEO250 },
-	{ "Oceanic Atom 2",	DEVICE_TYPE_OCEANIC_ATOM2 },
-	{ "Mares Nemo",		DEVICE_TYPE_MARES_NEMO },
-	{ "Mares Puck",		DEVICE_TYPE_MARES_PUCK },
-	{ "Mares Icon HD",	DEVICE_TYPE_MARES_ICONHD },
-	{ "OSTC",		DEVICE_TYPE_HW_OSTC },
-	{ "Cressi Edy",		DEVICE_TYPE_CRESSI_EDY },
-	{ "Zeagle N2iTiON 3",	DEVICE_TYPE_ZEAGLE_N2ITION3 },
-	{ "Atomics Cobalt",	DEVICE_TYPE_ATOMICS_COBALT },
-	{ NULL }
-};