shearwater: remove stale remnants of manual string interface code

Minimize unnecessary differences with Jef's upstream code.

The shearwater parser uses the generif field-cache code, and doesn't
need to have the snprintf workarounds for MSC, or include stdio.h etc.
The field-cache code takes care of this.

[ To be precise: the field-cache code _should_ have taken care of this,
  but didn't: it used 'memcpy()' in a macro, but didn't include the
  required header. Removing it from the shearwater code exposed this
  issue with the field-cache header, and this fixes that ]

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

.gitignore

@@ -41,6 +41,7 @@ Makefile.in
 /examples/atom2
 /examples/d9
 /examples/darwin
+/examples/dctool
 /examples/edy
 /examples/eon
 /examples/frog
@@ -82,3 +83,5 @@ Makefile.in
 /src/libdivecomputer.la
 /src/libdivecomputer.rc
 /src/revision.h
+
+/build

configure.ac

@@ -2,7 +2,7 @@
 m4_define([dc_version_major],[0])
 m4_define([dc_version_minor],[7])
 m4_define([dc_version_micro],[0])
-m4_define([dc_version_suffix],[devel])
+m4_define([dc_version_suffix],[devel-Subsurface-NG])
 m4_define([dc_version],dc_version_major.dc_version_minor.dc_version_micro[]m4_ifset([dc_version_suffix],-[dc_version_suffix]))
 
 # Libtool versioning.
@@ -175,19 +175,21 @@ AC_CHECK_FUNCS([getopt_long])
 
 # Checks for supported compiler options.
 AX_APPEND_COMPILE_FLAGS([ \
-	-pedantic \
 	-Wall \
-	-Wextra \
 	-Wshadow \
 	-Wrestrict \
 	-Wformat=2 \
 	-Wwrite-strings \
-	-Wcast-qual \
 	-Wpointer-arith \
 	-Wstrict-prototypes \
 	-Wmissing-prototypes \
 	-Wmissing-declarations \
 	-Wno-unused-parameter \
+	-Wno-unused-function \
+	-Wno-unused-variable \
+	-Wno-unused-but-set-variable \
+	-Wno-pointer-sign \
+	-Wno-shadow \
 	-fmacro-prefix-map='$(top_srcdir)/'= \
 ])
 

examples/common.c

@@ -90,6 +90,8 @@ static const backend_table_t g_backends[] = {
 	{"idive",       DC_FAMILY_DIVESYSTEM_IDIVE,    0x03},
 	{"cochran",     DC_FAMILY_COCHRAN_COMMANDER,   0},
 	{"divecomputereu", DC_FAMILY_TECDIVING_DIVECOMPUTEREU, 0},
+	{"descentmk1",  DC_FAMILY_GARMIN, 0},
+	{"cosmiq",      DC_FAMILY_DEEPBLU,             0},
 };
 
 static const transport_table_t g_transports[] = {
@@ -99,6 +101,7 @@ static const transport_table_t g_transports[] = {
 	{"irda",      DC_TRANSPORT_IRDA},
 	{"bluetooth", DC_TRANSPORT_BLUETOOTH},
 	{"ble",       DC_TRANSPORT_BLE},
+	{"usbstorage",DC_TRANSPORT_USBSTORAGE},
 };
 
 const char *
@@ -537,6 +540,8 @@ dctool_iostream_open (dc_iostream_t **iostream, dc_context_t *context, dc_descri
 		return dctool_irda_open (iostream, context, descriptor, devname);
 	case DC_TRANSPORT_BLUETOOTH:
 		return dctool_bluetooth_open (iostream, context, descriptor, devname);
+	case DC_TRANSPORT_USBSTORAGE:
+		return dc_usb_storage_open (iostream, context, devname);
 	default:
 		return DC_STATUS_UNSUPPORTED;
 	}

examples/output_xml.c

@@ -414,6 +414,24 @@ dctool_xml_output_write (dctool_output_t *abstract, dc_parser_t *parser, const u
 			convert_pressure(atmospheric, output->units));
 	}
 
+	message ("Parsing strings.\n");
+	int idx;
+	for (idx = 0; idx < 100; idx++) {
+		dc_field_string_t str = { NULL };
+		status = dc_parser_get_field(parser, DC_FIELD_STRING, idx, &str);
+		if (status != DC_STATUS_SUCCESS && status != DC_STATUS_UNSUPPORTED) {
+			ERROR ("Error parsing strings");
+			goto cleanup;
+		}
+		if (status == DC_STATUS_UNSUPPORTED)
+			break;
+		if (!str.desc || !str.value)
+			break;
+		fprintf (output->ostream, "<extradata key='%s' value='%s' />\n",
+			str.desc, str.value);
+
+	}
+
 	// Parse the sample data.
 	message ("Parsing the sample data.\n");
 	status = dc_parser_samples_foreach (parser, sample_cb, &sampledata);

include/libdivecomputer/common.h

@@ -48,9 +48,13 @@ typedef enum dc_transport_t {
 	DC_TRANSPORT_USBHID    = (1 << 2),
 	DC_TRANSPORT_IRDA      = (1 << 3),
 	DC_TRANSPORT_BLUETOOTH = (1 << 4),
-	DC_TRANSPORT_BLE       = (1 << 5)
+	DC_TRANSPORT_BLE       = (1 << 5),
+	DC_TRANSPORT_USBSTORAGE= (1 << 6),
 } dc_transport_t;
 
+// Idiotic enums can't be queried
+#define DC_TRANSPORT_USBSTORAGE DC_TRANSPORT_USBSTORAGE
+
 typedef enum dc_family_t {
 	DC_FAMILY_NULL = 0,
 	/* Suunto */
@@ -104,6 +108,10 @@ typedef enum dc_family_t {
 	DC_FAMILY_COCHRAN_COMMANDER = (14 << 16),
 	/* Tecdiving */
 	DC_FAMILY_TECDIVING_DIVECOMPUTEREU = (15 << 16),
+	/* Garmin */
+	DC_FAMILY_GARMIN = (16 << 16),
+	/* Deepblu */
+	DC_FAMILY_DEEPBLU = (17 << 16),
 } dc_family_t;
 
 #ifdef __cplusplus

include/libdivecomputer/iostream.h

@@ -310,6 +310,9 @@ dc_iostream_sleep (dc_iostream_t *iostream, unsigned int milliseconds);
 dc_status_t
 dc_iostream_close (dc_iostream_t *iostream);
 
+dc_status_t
+dc_usb_storage_open (dc_iostream_t **out, dc_context_t *context, const char *name);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

include/libdivecomputer/parser.h

@@ -46,9 +46,13 @@ typedef enum dc_sample_type_t {
 	DC_SAMPLE_PPO2,
 	DC_SAMPLE_CNS,
 	DC_SAMPLE_DECO,
-	DC_SAMPLE_GASMIX
+	DC_SAMPLE_GASMIX,
+	DC_SAMPLE_TTS,		// time to surface in seconds
 } dc_sample_type_t;
 
+// Make it easy to test support compile-time with "#ifdef DC_SAMPLE_TTS"
+#define DC_SAMPLE_TTS DC_SAMPLE_TTS
+
 typedef enum dc_field_type_t {
 	DC_FIELD_DIVETIME,
 	DC_FIELD_MAXDEPTH,
@@ -62,9 +66,13 @@ typedef enum dc_field_type_t {
 	DC_FIELD_TEMPERATURE_MAXIMUM,
 	DC_FIELD_TANK_COUNT,
 	DC_FIELD_TANK,
-	DC_FIELD_DIVEMODE
+	DC_FIELD_DIVEMODE,
+	DC_FIELD_STRING,
 } dc_field_type_t;
 
+// Make it easy to test support compile-time with "#ifdef DC_FIELD_STRING"
+#define DC_FIELD_STRING DC_FIELD_STRING
+
 typedef enum parser_sample_event_t {
 	SAMPLE_EVENT_NONE,
 	SAMPLE_EVENT_DECOSTOP,
@@ -92,17 +100,41 @@ typedef enum parser_sample_event_t {
 	SAMPLE_EVENT_HEADING,
 	SAMPLE_EVENT_TISSUELEVEL,
 	SAMPLE_EVENT_GASCHANGE2, /* Deprecated: replaced by DC_SAMPLE_GASMIX. */
+	SAMPLE_EVENT_STRING,
 } parser_sample_event_t;
 
+/* To let the compile know we have this */
+#define SAMPLE_EVENT_STRING SAMPLE_EVENT_STRING
+
 /* For backwards compatibility */
 #define SAMPLE_EVENT_UNKNOWN SAMPLE_EVENT_FLOOR
 
 typedef enum parser_sample_flags_t {
 	SAMPLE_FLAGS_NONE = 0,
 	SAMPLE_FLAGS_BEGIN = (1 << 0),
-	SAMPLE_FLAGS_END = (1 << 1)
+	SAMPLE_FLAGS_END = (1 << 1),
+	SAMPLE_FLAGS_SEVERITY_MASK = (7 << 2),
 } parser_sample_flags_t;
 
+#define SAMPLE_FLAGS_SEVERITY_SHIFT 2
+
+#define SAMPLE_FLAGS_SEVERITY_MISSING (0 << SAMPLE_FLAGS_SEVERITY_SHIFT)
+#define SAMPLE_FLAGS_SEVERITY_STATE   (1 << SAMPLE_FLAGS_SEVERITY_SHIFT)
+#define SAMPLE_FLAGS_SEVERITY_INFO    (2 << SAMPLE_FLAGS_SEVERITY_SHIFT)
+#define SAMPLE_FLAGS_SEVERITY_WARN    (3 << SAMPLE_FLAGS_SEVERITY_SHIFT)
+#define SAMPLE_FLAGS_SEVERITY_ALARM   (4 << SAMPLE_FLAGS_SEVERITY_SHIFT)
+
+/* these are used for the types of TAGs in Shearwater PNF info events */
+#define SAMPLE_FLAGS_TYPE_SHIFT 5
+#define SAMPLE_FLAGS_TYPE_MASK        (7 << SAMPLE_FLAGS_TYPE_SHIFT)
+#define SAMPLE_FLAGS_TYPE_NONE        (0 << SAMPLE_FLAGS_TYPE_SHIFT)
+#define SAMPLE_FLAGS_TYPE_INTEREST    (1 << SAMPLE_FLAGS_TYPE_SHIFT)
+#define SAMPLE_FLAGS_TYPE_NAVPOINT    (2 << SAMPLE_FLAGS_TYPE_SHIFT)
+#define SAMPLE_FLAGS_TYPE_DANGER      (3 << SAMPLE_FLAGS_TYPE_SHIFT)
+#define SAMPLE_FLAGS_TYPE_ANIMAL      (4 << SAMPLE_FLAGS_TYPE_SHIFT)
+#define SAMPLE_FLAGS_TYPE_ISSUE       (5 << SAMPLE_FLAGS_TYPE_SHIFT)
+#define SAMPLE_FLAGS_TYPE_INJURY      (6 << SAMPLE_FLAGS_TYPE_SHIFT)
+
 typedef enum parser_sample_vendor_t {
 	SAMPLE_VENDOR_NONE,
 	SAMPLE_VENDOR_UWATEC_ALADIN,
@@ -148,11 +180,16 @@ typedef struct dc_gasmix_t {
 
 #define DC_GASMIX_UNKNOWN 0xFFFFFFFF
 
-typedef enum dc_tankvolume_t {
+typedef unsigned int dc_tankinfo_t;
-    DC_TANKVOLUME_NONE,
+#define DC_TANKINFO_METRIC	1
-    DC_TANKVOLUME_METRIC,
+#define DC_TANKINFO_IMPERIAL	2
-    DC_TANKVOLUME_IMPERIAL,
+#define DC_TANKINFO_CC_DILUENT	4
-} dc_tankvolume_t;
+#define DC_TANKINFO_CC_O2	8
+
+// For backwards compatibility
+#define DC_TANKVOLUME_NONE	0
+#define DC_TANKVOLUME_METRIC	DC_TANKINFO_METRIC
+#define DC_TANKVOLUME_IMPERIAL	DC_TANKINFO_IMPERIAL
 
 /*
  * Tank volume
@@ -179,13 +216,18 @@ typedef enum dc_tankvolume_t {
 
 typedef struct dc_tank_t {
     unsigned int gasmix;  /* Gas mix index, or DC_GASMIX_UNKNOWN */
-    dc_tankvolume_t type; /* Tank type */
+    dc_tankinfo_t type;   /* Tank type - metric/imperial and oc/cc */
     double volume;        /* Volume (liter) */
     double workpressure;  /* Work pressure (bar) */
     double beginpressure; /* Begin pressure (bar) */
     double endpressure;   /* End pressure (bar) */
 } dc_tank_t;
 
+typedef struct dc_field_string_t {
+	const char *desc;
+	const char *value;
+} dc_field_string_t;
+
 typedef union dc_sample_value_t {
 	unsigned int time;
 	double depth;
@@ -199,6 +241,7 @@ typedef union dc_sample_value_t {
 		unsigned int time;
 		unsigned int flags;
 		unsigned int value;
+		const char *name;
 	} event;
 	unsigned int rbt;
 	unsigned int heartbeat;

msvc/libdivecomputer.vcproj

@@ -498,6 +498,26 @@
 				RelativePath="..\src\tecdiving_divecomputereu_parser.c"
 				>
 			</File>
+			<File
+				RelativePath="..\src\garmin.c"
+				>
+			</File>
+			<File
+				RelativePath="..\src\garmin_parser.c"
+				>
+			</File>
+			<File
+				RelativePath="..\src\deepblu.c"
+				>
+			</File>
+			<File
+				RelativePath="..\src\deepblu_parser.c"
+				>
+			</File>
+			<File
+				RelativePath="..\src\field-cache.c"
+				>
+			</File>
 			<File
 				RelativePath="..\src\timer.c"
 				>
@@ -840,6 +860,14 @@
 				RelativePath="..\src\tecdiving_divecomputereu.h"
 				>
 			</File>
+			<File
+				RelativePath="..\src\garmin.h"
+				>
+			</File>
+			<File
+				RelativePath="..\src\deepblu.h"
+				>
+			</File>
 			<File
 				RelativePath="..\src\timer.h"
 				>

src/Makefile.am

@@ -69,13 +69,17 @@ libdivecomputer_la_SOURCES = \
 	rbstream.h rbstream.c \
 	checksum.h checksum.c \
 	array.h array.c \
+	field-cache.h field-cache.c \
 	buffer.c \
 	cochran_commander.h cochran_commander.c cochran_commander_parser.c \
 	tecdiving_divecomputereu.h tecdiving_divecomputereu.c tecdiving_divecomputereu_parser.c \
+	garmin.h garmin.c garmin_parser.c \
+	deepblu.h deepblu.c deepblu_parser.c \
 	socket.h socket.c \
 	irda.c \
 	usbhid.c \
 	bluetooth.c \
+	usb_storage.c \
 	custom.c
 
 if OS_WIN32

src/atomics_cobalt_parser.c

@@ -20,6 +20,12 @@
  */
 
 #include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
 
 #include <libdivecomputer/units.h>
 
@@ -129,6 +135,9 @@ atomics_cobalt_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *dateti
 }
 
 
+#define BUFLEN 16
+
+
 static dc_status_t
 atomics_cobalt_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value)
 {
@@ -143,6 +152,9 @@ atomics_cobalt_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, un
 	dc_tank_t *tank = (dc_tank_t *) value;
 
 	double atmospheric = 0.0;
+	char buf[BUFLEN];
+	dc_field_string_t *string = (dc_field_string_t *) value;
+
 	if (parser->atmospheric)
 		atmospheric = parser->atmospheric;
 	else
@@ -208,6 +220,29 @@ atomics_cobalt_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, un
 				return DC_STATUS_DATAFORMAT;
 			}
 			break;
+		case DC_FIELD_STRING:
+			switch(flags) {
+			case 0: // Serialnr
+				string->desc = "Serial";
+				snprintf(buf, BUFLEN, "%c%c%c%c-%c%c%c%c", p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11]);
+				break;
+			case 1: // Program Version
+				string->desc = "Program Version";
+				snprintf(buf, BUFLEN, "%.2f", array_uint16_le(p + 30) / 100.0);
+				break;
+			case 2: // Boot Version
+				string->desc = "Boot Version";
+				snprintf(buf, BUFLEN, "%.2f", array_uint16_le(p + 32) / 100.0);
+				break;
+			case 3: // Nofly
+				string->desc = "NoFly Time";
+				snprintf(buf, BUFLEN, "%0u:%02u", p[0x52], p[0x53]);
+				break;
+			default:
+				return DC_STATUS_UNSUPPORTED;
+			}
+			string->value = strdup(buf);
+			break;
 		default:
 			return DC_STATUS_UNSUPPORTED;
 		}

src/context.c

@@ -334,6 +334,7 @@ dc_context_get_transports (dc_context_t *context)
 #elif defined(HAVE_LIBUSB) && !defined(__APPLE__)
 		| DC_TRANSPORT_USBHID
 #endif
+		| DC_TRANSPORT_USBSTORAGE
 #ifdef _WIN32
 #ifdef HAVE_AF_IRDA_H
 		| DC_TRANSPORT_IRDA

src/deepblu.c

@@ -0,0 +1,500 @@
+/*
+ * Deepblu Cosmiq+ downloading
+ *
+ * Copyright (C) 2019 Linus Torvalds
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "deepblu.h"
+#include "context-private.h"
+#include "device-private.h"
+#include "array.h"
+
+// "Write state"
+#define CMD_SETTIME	0x20	// Send 6 byte date-time, get single-byte 00x00 ack
+#define CMD_23		0x23	// Send 00/01 byte, get ack back? Some metric/imperial setting?
+
+// "Read dives"?
+#define CMD_GETDIVENR	0x40	// Send empty byte, get single-byte number of dives back
+#define CMD_GETDIVE	0x41	// Send dive number (1-nr) byte, get dive stat length byte back
+  #define RSP_DIVESTAT	0x42	//  .. followed by packets of dive stat for that dive of that length
+#define CMD_GETPROFILE	0x43	// Send dive number (1-nr) byte, get dive profile length BE word back
+  #define RSP_DIVEPROF  0x44	//  .. followed by packets of dive profile of that length
+
+// "Read state"
+#define CMD_GETTIME	0x50	// Send empty byte, get six-byte bcd date-time back
+#define CMD_51		0x51	// Send empty byte, get four bytes back (03 dc 00 e3)
+#define CMD_52		0x52	// Send empty byte, get two bytes back (bf 8d)
+#define CMD_53		0x53	// Send empty byte, get six bytes back (0e 81 00 03 00 00)
+#define CMD_54		0x54	// Send empty byte, get byte back (00)
+#define CMD_55		0x55	// Send empty byte, get byte back (00)
+#define CMD_56		0x56	// Send empty byte, get byte back (00)
+#define CMD_57		0x57	// Send empty byte, get byte back (00)
+#define CMD_58		0x58	// Send empty byte, get byte back (52)
+#define CMD_59		0x59	// Send empty byte, get six bytes back (00 00 07 00 00 00)
+				//                                     (00 00 00 00 00 00)
+#define CMD_5a		0x5a	// Send empty byte, get six bytes back (23 1b 09 d8 37 c0)
+#define CMD_5b		0x5b	// Send empty byte, get six bytes back (00 21 00 14 00 01)
+				//                                     (00 00 00 14 00 01)
+#define CMD_5c		0x5c	// Send empty byte, get six bytes back (13 88 00 46 20 00)
+				//                                     (13 88 00 3c 15 00)
+#define CMD_5d		0x5d	// Send empty byte, get six bytes back (19 00 23 0C 02 0E)
+				//                                     (14 14 14 0c 01 0e)
+#define CMD_5f		0x5f	// Send empty byte, get six bytes back (00 00 07 00 00 00)
+
+#define COSMIQ_HDR_SIZE	36
+
+typedef struct deepblu_device_t {
+	dc_device_t base;
+	dc_iostream_t *iostream;
+	unsigned char fingerprint[COSMIQ_HDR_SIZE];
+} deepblu_device_t;
+
+static dc_status_t deepblu_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size);
+static dc_status_t deepblu_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata);
+static dc_status_t deepblu_device_timesync(dc_device_t *abstract, const dc_datetime_t *datetime);
+static dc_status_t deepblu_device_close (dc_device_t *abstract);
+
+static const dc_device_vtable_t deepblu_device_vtable = {
+	sizeof(deepblu_device_t),
+	DC_FAMILY_DEEPBLU,
+	deepblu_device_set_fingerprint, /* set_fingerprint */
+	NULL, /* read */
+	NULL, /* write */
+	NULL, /* dump */
+	deepblu_device_foreach, /* foreach */
+	deepblu_device_timesync, /* timesync */
+	deepblu_device_close, /* close */
+};
+
+// Maximum data in a packet. It's actually much
+// less than this, since BLE packets are small and
+// with the 7 bytes of headers and final newline
+// and the HEX encoding, the actual maximum is
+// just something like 6 bytes.
+//
+// But in theory the data could be done over
+// multiple packets. That doesn't seem to be
+// the case in anything I've seen so far.
+//
+// Pick something small and easy to use for
+// stack buffers.
+#define MAX_DATA 20
+
+static char *
+write_hex_byte(unsigned char data, char *p)
+{
+	static const char hex[16] = "0123456789ABCDEF";
+	*p++ = hex[data >> 4];
+	*p++ = hex[data & 0xf];
+	return p;
+}
+
+//
+// Send a cmd packet.
+//
+// The format of the cmd on the "wire" is:
+//  - byte '#'
+//  - HEX char of cmd
+//  - HEX char two's complement modular sum of packet data (including cmd/size)
+//  - HEX char size of data as encoded in HEX
+//  - n * HEX char data
+//  - byte '\n'
+// so you end up having 8 bytes of header/trailer overhead, and two bytes
+// for every byte of data sent due to the HEX encoding.
+//
+static dc_status_t
+deepblu_send_cmd(deepblu_device_t *device, const unsigned char cmd, const unsigned char data[], size_t size)
+{
+	char buffer[8+2*MAX_DATA], *p;
+	unsigned char csum;
+	int i;
+
+	if (size > MAX_DATA)
+		return DC_STATUS_INVALIDARGS;
+
+	// Calculate packet csum
+	csum = cmd + 2*size;
+	for (i = 0; i < size; i++)
+		csum += data[i];
+	csum = -csum;
+
+	// Fill the data buffer
+	p = buffer;
+	*p++ = '#';
+	p = write_hex_byte(cmd, p);
+	p = write_hex_byte(csum, p);
+	p = write_hex_byte(size*2, p);
+	for (i = 0; i < size; i++)
+		p = write_hex_byte(data[i], p);
+	*p++ = '\n';
+
+	// .. and send it out
+	return dc_iostream_write(device->iostream, buffer, p-buffer, NULL);
+}
+
+//
+// Receive one 'line' of data
+//
+// The deepblu BLE protocol is ASCII line based and packetized.
+// Normally one packet is one line, but it looks like the Nordic
+// Semi BLE chip will sometimes send packets early (some internal
+// serial buffer timeout?) with incompete data.
+//
+// So read packets until you get newline.
+static dc_status_t
+deepblu_recv_line(deepblu_device_t *device, unsigned char *buf, size_t size)
+{
+	while (1) {
+		unsigned char buffer[20];
+		size_t transferred = 0;
+		dc_status_t status;
+
+		status = dc_iostream_read(device->iostream, buffer, sizeof(buffer), &transferred);
+		if (status != DC_STATUS_SUCCESS) {
+			ERROR(device->base.context, "Failed to receive Deepblu reply packet.");
+			return status;
+		}
+		if (transferred > size) {
+			ERROR(device->base.context, "Deepblu reply packet with too much data (got %zu, expected %zu)", transferred, size);
+			return DC_STATUS_IO;
+		}
+		if (!transferred) {
+			ERROR(device->base.context, "Empty Deepblu reply packet");
+			return DC_STATUS_IO;
+		}
+		memcpy(buf, buffer, transferred);
+		buf += transferred;
+		size -= transferred;
+		if (buf[-1] == '\n')
+			break;
+	}
+	buf[-1] = 0;
+	return DC_STATUS_SUCCESS;
+}
+
+static int
+hex_nibble(char c)
+{
+	if (c >= '0' && c <= '9')
+		return c - '0';
+	if (c >= 'a' && c <= 'f')
+		return c - 'a' + 10;
+	if (c >= 'A' && c <= 'F')
+		return c - 'A' + 10;
+	return -1;
+}
+
+static int
+read_hex_byte(char *p)
+{
+	// This is negative if either of the nibbles is invalid
+	return (hex_nibble(p[0]) << 4) | hex_nibble(p[1]);
+}
+
+
+//
+// Receive a reply packet
+//
+// The reply packet has the same format as the cmd packet we
+// send, except the first byte is '$' instead of '#'.
+static dc_status_t
+deepblu_recv_data(deepblu_device_t *device, const unsigned char expected, unsigned char *buf, size_t size, size_t *received)
+{
+	int len, i;
+	dc_status_t status;
+	char buffer[8+2*MAX_DATA];
+	int cmd, csum, ndata;
+
+	status = deepblu_recv_line(device, buffer, sizeof(buffer));
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+
+	// deepblu_recv_line() always zero-terminates the result
+	// if it returned success, and has removed the final newline.
+	len = strlen(buffer);
+	HEXDUMP(device->base.context, DC_LOGLEVEL_DEBUG, "rcv", buffer, len);
+
+	// A valid reply should always be at least 7 characters: the
+	// initial '$' and the three header HEX bytes.
+	if (len < 8 || buffer[0] != '$') {
+		ERROR(device->base.context, "Invalid Deepblu reply packet");
+		return DC_STATUS_IO;
+	}
+
+	cmd = read_hex_byte(buffer+1);
+	csum = read_hex_byte(buffer+3);
+	ndata = read_hex_byte(buffer+5);
+	if ((cmd | csum | ndata) < 0) {
+		ERROR(device->base.context, "non-hex Deepblu reply packet header");
+		return DC_STATUS_IO;
+	}
+
+	// Verify the data length: it's the size of the HEX data,
+	// and should also match the line length we got (the 7
+	// is for the header data we already decoded above).
+	if ((ndata & 1) || ndata != len - 7) {
+		ERROR(device->base.context, "Deepblu reply packet data length does not match (claimed %d, got %d)", ndata, len-7);
+		return DC_STATUS_IO;
+	}
+
+	if (ndata >> 1 > size) {
+		ERROR(device->base.context, "Deepblu reply packet too big for buffer (ndata=%d, size=%zu)", ndata, size);
+		return DC_STATUS_IO;
+	}
+
+	csum += cmd + ndata;
+
+	for (i = 7; i < len; i += 2) {
+		int byte = read_hex_byte(buffer + i);
+		if (byte < 0) {
+			ERROR(device->base.context, "Deepblu reply packet data not valid hex");
+			return DC_STATUS_IO;
+		}
+		*buf++ = byte;
+		csum += byte;
+	}
+
+	if (csum & 255) {
+		ERROR(device->base.context, "Deepblu reply packet csum not valid (%x)", csum);
+		return DC_STATUS_IO;
+	}
+
+	*received = ndata >> 1;
+	return DC_STATUS_SUCCESS;
+}
+
+// Common communication pattern: send a command, expect data back with the same
+// command byte.
+static dc_status_t
+deepblu_send_recv(deepblu_device_t *device, const unsigned char cmd,
+	const unsigned char *data, size_t data_size,
+	unsigned char *result, size_t result_size)
+{
+	dc_status_t status;
+	size_t got;
+
+	status = deepblu_send_cmd(device, cmd, data, data_size);
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+	status = deepblu_recv_data(device, cmd, result, result_size, &got);
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+	if (got != result_size) {
+		ERROR(device->base.context, "Deepblu result size didn't match expected (expected %zu, got %zu)",
+			result_size, got);
+		return DC_STATUS_IO;
+	}
+	return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t
+deepblu_recv_bulk(deepblu_device_t *device, const unsigned char cmd, unsigned char *buf, size_t len)
+{
+	while (len) {
+		dc_status_t status;
+		size_t got;
+
+		status = deepblu_recv_data(device, cmd, buf, len, &got);
+		if (status != DC_STATUS_SUCCESS)
+			return status;
+		if (got > len) {
+			ERROR(device->base.context, "Deepblu bulk receive overflow");
+			return DC_STATUS_IO;
+		}
+		buf += got;
+		len -= got;
+	}
+	return DC_STATUS_SUCCESS;
+}
+
+dc_status_t
+deepblu_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_t *iostream)
+{
+	deepblu_device_t *device;
+
+	if (out == NULL)
+		return DC_STATUS_INVALIDARGS;
+
+	// Allocate memory.
+	device = (deepblu_device_t *) dc_device_allocate (context, &deepblu_device_vtable);
+	if (device == NULL) {
+		ERROR (context, "Failed to allocate memory.");
+		return DC_STATUS_NOMEMORY;
+	}
+
+	// Set the default values.
+	device->iostream = iostream;
+	memset(device->fingerprint, 0, sizeof(device->fingerprint));
+
+	*out = (dc_device_t *) device;
+	return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t
+deepblu_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size)
+{
+	deepblu_device_t *device = (deepblu_device_t *)abstract;
+
+	HEXDUMP(device->base.context, DC_LOGLEVEL_DEBUG, "set_fingerprint", data, size);
+
+	if (size && size != sizeof (device->fingerprint))
+		return DC_STATUS_INVALIDARGS;
+
+	if (size)
+		memcpy (device->fingerprint, data, sizeof (device->fingerprint));
+	else
+		memset (device->fingerprint, 0, sizeof (device->fingerprint));
+
+	return DC_STATUS_SUCCESS;
+}
+
+static unsigned char bcd(int val)
+{
+	if (val >= 0 && val < 100) {
+		int high = val / 10;
+		int low = val % 10;
+		return (high << 4) | low;
+	}
+	return 0;
+}
+
+static dc_status_t
+deepblu_device_timesync(dc_device_t *abstract, const dc_datetime_t *datetime)
+{
+	deepblu_device_t *device = (deepblu_device_t *)abstract;
+	unsigned char result[1], data[6];
+	dc_status_t status;
+	size_t len;
+
+	data[0] = bcd(datetime->year - 2000);
+	data[1] = bcd(datetime->month);
+	data[2] = bcd(datetime->day);
+	data[3] = bcd(datetime->hour);
+	data[4] = bcd(datetime->minute);
+	data[5] = bcd(datetime->second);
+
+	// Maybe also check that we received one zero byte (ack?)
+	return deepblu_send_recv(device, CMD_SETTIME,
+			data, sizeof(data),
+			result, sizeof(result));
+}
+
+static dc_status_t
+deepblu_device_close (dc_device_t *abstract)
+{
+	deepblu_device_t *device = (deepblu_device_t *) abstract;
+
+	return DC_STATUS_SUCCESS;
+}
+
+static const char zero[MAX_DATA];
+
+static dc_status_t
+deepblu_download_dive(deepblu_device_t *device, unsigned char nr, dc_dive_callback_t callback, void *userdata)
+{
+	unsigned char header_len;
+	unsigned char profilebytes[2];
+	unsigned int profile_len;
+	dc_status_t status;
+	char header[256];
+	unsigned char *profile;
+
+	status = deepblu_send_recv(device,  CMD_GETDIVE, &nr, 1, &header_len, 1);
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+	status = deepblu_recv_bulk(device, RSP_DIVESTAT, header, header_len);
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+	memset(header + header_len, 0, 256 - header_len);
+
+	/* The header is the fingerprint. If we've already seen this header, we're done */
+	if (memcmp(header, device->fingerprint, sizeof (device->fingerprint)) == 0)
+		return DC_STATUS_DONE;
+
+	status = deepblu_send_recv(device,  CMD_GETPROFILE, &nr, 1, profilebytes, sizeof(profilebytes));
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+	profile_len = (profilebytes[0] << 8) | profilebytes[1];
+
+	profile = malloc(256 + profile_len);
+	if (!profile) {
+		ERROR (device->base.context, "Insufficient buffer space available.");
+		return DC_STATUS_NOMEMORY;
+	}
+
+	// We make the dive data be 256 bytes of header, followed by the profile data
+	memcpy(profile, header, 256);
+
+	status = deepblu_recv_bulk(device, RSP_DIVEPROF, profile+256, profile_len);
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+
+	if (callback) {
+		if (!callback(profile, profile_len+256, header, header_len, userdata))
+			return DC_STATUS_DONE;
+	}
+
+	return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t
+deepblu_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
+{
+	dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
+	deepblu_device_t *device = (deepblu_device_t *) abstract;
+	unsigned char nrdives, val;
+	dc_status_t status;
+	int i;
+
+	val = 0;
+	status = deepblu_send_recv(device,  CMD_GETDIVENR, &val, 1, &nrdives, 1);
+	if (status != DC_STATUS_SUCCESS)
+		return status;
+
+	if (!nrdives)
+		return DC_STATUS_SUCCESS;
+
+	progress.maximum = nrdives;
+	progress.current = 0;
+	device_event_emit(abstract, DC_EVENT_PROGRESS, &progress);
+
+	for (i = 1; i <= nrdives; i++) {
+		if (device_is_cancelled(abstract)) {
+			dc_status_set_error(&status, DC_STATUS_CANCELLED);
+			break;
+		}
+
+		status = deepblu_download_dive(device, i, callback, userdata);
+		switch (status) {
+		case DC_STATUS_DONE:
+			i = nrdives;
+			break;
+		case DC_STATUS_SUCCESS:
+			break;
+		default:
+			return status;
+		}
+		progress.current = i;
+		device_event_emit(abstract, DC_EVENT_PROGRESS, &progress);
+	}
+
+	return DC_STATUS_SUCCESS;
+}

src/deepblu.h

@@ -0,0 +1,43 @@
+/*
+ * Deepblu Cosmiq+ downloading/parsing
+ *
+ * Copyright (C) 2018 Linus Torvalds
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#ifndef DEEPBLU_H
+#define DEEPBLU_H
+
+#include <libdivecomputer/context.h>
+#include <libdivecomputer/iostream.h>
+#include <libdivecomputer/device.h>
+#include <libdivecomputer/parser.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+dc_status_t
+deepblu_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
+
+dc_status_t
+deepblu_parser_create (dc_parser_t **parser, dc_context_t *context);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* DEEPBLU_H */

src/deepblu_parser.c

@@ -0,0 +1,278 @@
+/*
+ * Deeplu Cosmiq+ parsing
+ *
+ * Copyright (C) 2019 Linus Torvalds
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "deepblu.h"
+#include "context-private.h"
+#include "parser-private.h"
+#include "array.h"
+#include "field-cache.h"
+
+#define C_ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
+
+#define MAXFIELDS 128
+
+struct msg_desc;
+
+typedef struct deepblu_parser_t {
+	dc_parser_t base;
+
+	dc_sample_callback_t callback;
+	void *userdata;
+
+	// 20 sec for scuba, 1 sec for freedives
+	int sample_interval;
+
+	// Common fields
+	struct dc_field_cache cache;
+} deepblu_parser_t;
+
+static dc_status_t deepblu_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size);
+static dc_status_t deepblu_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime);
+static dc_status_t deepblu_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value);
+static dc_status_t deepblu_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata);
+
+static const dc_parser_vtable_t deepblu_parser_vtable = {
+	sizeof(deepblu_parser_t),
+	DC_FAMILY_DEEPBLU,
+	deepblu_parser_set_data, /* set_data */
+	deepblu_parser_get_datetime, /* datetime */
+	deepblu_parser_get_field, /* fields */
+	deepblu_parser_samples_foreach, /* samples_foreach */
+	NULL /* destroy */
+};
+
+dc_status_t
+deepblu_parser_create (dc_parser_t **out, dc_context_t *context)
+{
+	deepblu_parser_t *parser = NULL;
+
+	if (out == NULL)
+		return DC_STATUS_INVALIDARGS;
+
+	// Allocate memory.
+	parser = (deepblu_parser_t *) dc_parser_allocate (context, &deepblu_parser_vtable);
+	if (parser == NULL) {
+		ERROR (context, "Failed to allocate memory.");
+		return DC_STATUS_NOMEMORY;
+	}
+
+	*out = (dc_parser_t *) parser;
+
+	return DC_STATUS_SUCCESS;
+}
+
+static double
+pressure_to_depth(unsigned int mbar)
+{
+	// Specific weight of seawater (millibar to cm)
+	const double specific_weight = 1.024 * 0.980665;
+
+	// Absolute pressure, subtract surface pressure
+	if (mbar < 1013)
+		return 0.0;
+	mbar -= 1013;
+	return mbar / specific_weight / 100.0;
+}
+
+static dc_status_t
+deepblu_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size)
+{
+	deepblu_parser_t *deepblu = (deepblu_parser_t *) abstract;
+	const unsigned char *hdr = data;
+	const unsigned char *profile = data + 256;
+	unsigned int divetime, maxpressure;
+	dc_gasmix_t gasmix = {0, };
+
+	if (size < 256)
+		return DC_STATUS_IO;
+
+	deepblu->callback = NULL;
+	deepblu->userdata = NULL;
+	memset(&deepblu->cache, 0, sizeof(deepblu->cache));
+
+	// LE16 at 0 is 'dive number'
+
+	// LE16 at 12 is the dive time
+	// It's in seconds for freedives, minutes for scuba/gauge
+	divetime = hdr[12] + 256*hdr[13];
+
+	// Byte at 2 is 'activity type' (2 = scuba, 3 = gauge, 4 = freedive)
+	// Byte at 3 is O2 percentage
+	switch (data[2]) {
+	case 2:
+		// SCUBA - divetime in minutes
+		divetime *= 60;
+		gasmix.oxygen = data[3] / 100.0;
+		DC_ASSIGN_IDX(deepblu->cache, GASMIX, 0, gasmix);
+		DC_ASSIGN_FIELD(deepblu->cache, GASMIX_COUNT, 1);
+		DC_ASSIGN_FIELD(deepblu->cache, DIVEMODE, DC_DIVEMODE_OC);
+		break;
+	case 3:
+		// GAUGE - divetime in minutes
+		divetime *= 60;
+		DC_ASSIGN_FIELD(deepblu->cache, DIVEMODE, DC_DIVEMODE_GAUGE);
+		break;
+	case 4:
+		// FREEDIVE - divetime in seconds
+		DC_ASSIGN_FIELD(deepblu->cache, DIVEMODE, DC_DIVEMODE_FREEDIVE);
+		deepblu->sample_interval = 1;
+		break;
+	default:
+		ERROR (abstract->context, "Deepblu: unknown activity type '%02x'", data[2]);
+		break;
+	}
+
+	// Seems to be fixed at 20s for scuba, 1s for freedive
+	deepblu->sample_interval = hdr[26];
+
+	maxpressure = hdr[22] + 256*hdr[23];	// Maxpressure in millibar
+
+	DC_ASSIGN_FIELD(deepblu->cache, DIVETIME, divetime);
+	DC_ASSIGN_FIELD(deepblu->cache, MAXDEPTH, pressure_to_depth(maxpressure));
+
+	return DC_STATUS_SUCCESS;
+}
+
+// The layout of the header in the 'data' is
+//  0: LE16 dive number
+//  2: dive type byte?
+//  3: O2 percentage byte
+//  4: unknown
+//  5: unknown
+//  6: LE16 year
+//  8: day of month
+//  9: month
+// 10: minute
+// 11: hour
+// 12: LE16 dive time
+// 14: LE16 ??
+// 16: LE16 surface pressure?
+// 18: LE16 ??
+// 20: LE16 ??
+// 22: LE16 max depth pressure
+// 24: LE16 water temp
+// 26: LE16 ??
+// 28: LE16 ??
+// 30: LE16 ??
+// 32: LE16 ??
+// 34: LE16 ??
+static dc_status_t
+deepblu_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime)
+{
+	deepblu_parser_t *deepblu = (deepblu_parser_t *) abstract;
+	const unsigned char *data = deepblu->base.data;
+	int len = deepblu->base.size;
+
+	if (len < 256)
+		return DC_STATUS_IO;
+	datetime->year = data[6] + (data[7] << 8);
+	datetime->day = data[8];
+	datetime->month = data[9];
+	datetime->minute = data[10];
+	datetime->hour = data[11];
+	datetime->second = 0;
+	datetime->timezone = DC_TIMEZONE_NONE;
+
+	return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t
+deepblu_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value)
+{
+	deepblu_parser_t *deepblu = (deepblu_parser_t *) abstract;
+
+	if (!value)
+		return DC_STATUS_INVALIDARGS;
+
+	/* This whole sequence should be standardized */
+	if (!(deepblu->cache.initialized & (1 << type)))
+		return DC_STATUS_UNSUPPORTED;
+
+	switch (type) {
+	case DC_FIELD_DIVETIME:
+		return DC_FIELD_VALUE(deepblu->cache, value, DIVETIME);
+	case DC_FIELD_MAXDEPTH:
+		return DC_FIELD_VALUE(deepblu->cache, value, MAXDEPTH);
+	case DC_FIELD_AVGDEPTH:
+		return DC_FIELD_VALUE(deepblu->cache, value, AVGDEPTH);
+	case DC_FIELD_GASMIX_COUNT:
+	case DC_FIELD_TANK_COUNT:
+		return DC_FIELD_VALUE(deepblu->cache, value, GASMIX_COUNT);
+	case DC_FIELD_GASMIX:
+		if (flags >= MAXGASES)
+			return DC_STATUS_UNSUPPORTED;
+		return DC_FIELD_INDEX(deepblu->cache, value, GASMIX, flags);
+	case DC_FIELD_SALINITY:
+		return DC_FIELD_VALUE(deepblu->cache, value, SALINITY);
+	case DC_FIELD_ATMOSPHERIC:
+		return DC_FIELD_VALUE(deepblu->cache, value, ATMOSPHERIC);
+	case DC_FIELD_DIVEMODE:
+		return DC_FIELD_VALUE(deepblu->cache, value, DIVEMODE);
+	case DC_FIELD_TANK:
+		return DC_STATUS_UNSUPPORTED;
+	case DC_FIELD_STRING:
+		return dc_field_get_string(&deepblu->cache, flags, (dc_field_string_t *)value);
+	default:
+		return DC_STATUS_UNSUPPORTED;
+	}
+	return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t
+deepblu_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata)
+{
+	deepblu_parser_t *deepblu = (deepblu_parser_t *) abstract;
+	const unsigned char *data = deepblu->base.data;
+	int len = deepblu->base.size, i;
+
+	deepblu->callback = callback;
+	deepblu->userdata = userdata;
+
+	// Skip the header information
+	if (len < 256)
+		return DC_STATUS_IO;
+	data += 256;
+	len -= 256;
+
+	// The rest should be samples every 20s with temperature and depth
+	for (i = 0; i < len/4; i++) {
+		dc_sample_value_t sample = {0};
+		unsigned int temp = data[0]+256*data[1];
+		unsigned int pressure = data[2]+256*data[3];
+
+		data += 4;
+		sample.time = (i+1)*deepblu->sample_interval;
+		if (callback) callback (DC_SAMPLE_TIME, sample, userdata);
+
+		sample.depth = pressure_to_depth(pressure);
+		if (callback) callback (DC_SAMPLE_DEPTH, sample, userdata);
+
+		sample.temperature = temp / 10.0;
+		if (callback) callback (DC_SAMPLE_TEMPERATURE, sample, userdata);
+	}
+
+	return DC_STATUS_SUCCESS;
+}

src/descriptor.c

@@ -45,9 +45,11 @@ static int dc_filter_suunto (dc_transport_t transport, const void *userdata);
 static int dc_filter_shearwater (dc_transport_t transport, const void *userdata);
 static int dc_filter_hw (dc_transport_t transport, const void *userdata);
 static int dc_filter_tecdiving (dc_transport_t transport, const void *userdata);
+static int dc_filter_garmin (dc_transport_t transport, const void *userdata);
 static int dc_filter_mares (dc_transport_t transport, const void *userdata);
 static int dc_filter_divesystem (dc_transport_t transport, const void *userdata);
 static int dc_filter_oceanic (dc_transport_t transport, const void *userdata);
+static int dc_filter_deepblu (dc_transport_t transport, const void *userdata);
 
 static dc_status_t dc_descriptor_iterator_next (dc_iterator_t *iterator, void *item);
 
@@ -234,7 +236,7 @@ static const dc_descriptor_t g_descriptors[] = {
 	{"Sherwood", "Vision",              DC_FAMILY_OCEANIC_ATOM2, 0x4556, DC_TRANSPORT_SERIAL, NULL},
 	{"Oceanic",  "VTX",                 DC_FAMILY_OCEANIC_ATOM2, 0x4557, DC_TRANSPORT_SERIAL, NULL},
 	{"Aqualung", "i300",                DC_FAMILY_OCEANIC_ATOM2, 0x4559, DC_TRANSPORT_SERIAL, NULL},
-	{"Aqualung", "i750TC",              DC_FAMILY_OCEANIC_ATOM2, 0x455A, DC_TRANSPORT_SERIAL, NULL},
+	{"Aqualung", "i750TC",              DC_FAMILY_OCEANIC_ATOM2, 0x455A, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLUETOOTH, NULL},
 	{"Aqualung", "i450T",               DC_FAMILY_OCEANIC_ATOM2, 0x4641, DC_TRANSPORT_SERIAL, NULL},
 	{"Aqualung", "i550",                DC_FAMILY_OCEANIC_ATOM2, 0x4642, DC_TRANSPORT_SERIAL, NULL},
 	{"Aqualung", "i200",                DC_FAMILY_OCEANIC_ATOM2, 0x4646, DC_TRANSPORT_SERIAL, NULL},
@@ -304,8 +306,8 @@ static const dc_descriptor_t g_descriptors[] = {
 	{"Cressi", "Newton",   DC_FAMILY_CRESSI_LEONARDO, 5, DC_TRANSPORT_SERIAL, NULL},
 	{"Cressi", "Drake",    DC_FAMILY_CRESSI_LEONARDO, 6, DC_TRANSPORT_SERIAL, NULL},
 	/* Cressi Goa */
-	{"Cressi", "Cartesio", DC_FAMILY_CRESSI_GOA, 1, DC_TRANSPORT_SERIAL, NULL},
+	{"Cressi", "Cartesio", DC_FAMILY_CRESSI_GOA, 1, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLE, NULL},
-	{"Cressi", "Goa",      DC_FAMILY_CRESSI_GOA, 2, DC_TRANSPORT_SERIAL, NULL},
+	{"Cressi", "Goa",      DC_FAMILY_CRESSI_GOA, 2, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLE, NULL},
 	/* Zeagle N2iTiON3 */
 	{"Zeagle",    "N2iTiON3",   DC_FAMILY_ZEAGLE_N2ITION3, 0, DC_TRANSPORT_SERIAL, NULL},
 	{"Apeks",     "Quantum X",  DC_FAMILY_ZEAGLE_N2ITION3, 0, DC_TRANSPORT_SERIAL, NULL},
@@ -376,6 +378,10 @@ static const dc_descriptor_t g_descriptors[] = {
 	{"Cochran", "EMC-20H",      DC_FAMILY_COCHRAN_COMMANDER, 5, DC_TRANSPORT_SERIAL, NULL},
 	/* Tecdiving DiveComputer.eu */
 	{"Tecdiving", "DiveComputer.eu", DC_FAMILY_TECDIVING_DIVECOMPUTEREU, 0, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLUETOOTH, dc_filter_tecdiving},
+	/* Garmin */
+	{"Garmin", "Descent Mk1", DC_FAMILY_GARMIN, 2859, DC_TRANSPORT_USBSTORAGE, dc_filter_garmin},
+	/* Deepblu */
+	{"Deepblu", "Cosmiq+", DC_FAMILY_DEEPBLU, 0, DC_TRANSPORT_BLE, dc_filter_deepblu},
 };
 
 static int
@@ -581,6 +587,19 @@ static int dc_filter_tecdiving (dc_transport_t transport, const void *userdata)
 	return 1;
 }
 
+static int dc_filter_garmin (dc_transport_t transport, const void *userdata)
+{
+	static const dc_usb_desc_t usbhid[] = {
+		{0x091e, 0x2b2b}, // Garmin Descent Mk1
+	};
+
+	if (transport == DC_TRANSPORT_USBSTORAGE) {
+		return DC_FILTER_INTERNAL (userdata, usbhid, 0, dc_match_usb);
+	}
+
+	return 1;
+}
+
 static int dc_filter_mares (dc_transport_t transport, const void *userdata)
 {
 	static const char * const bluetooth[] = {
@@ -629,6 +648,19 @@ static int dc_filter_oceanic (dc_transport_t transport, const void *userdata)
 	return 1;
 }
 
+static int dc_filter_deepblu (dc_transport_t transport, const void *userdata)
+{
+	static const char * const bluetooth[] = {
+		"COSMIQ",
+	};
+
+	if (transport == DC_TRANSPORT_BLE) {
+		return DC_FILTER_INTERNAL (userdata, bluetooth, 0, dc_match_name);
+	}
+
+	return 1;
+}
+
 dc_status_t
 dc_descriptor_iterator (dc_iterator_t **out)
 {

src/device.c

@@ -57,6 +57,8 @@
 #include "divesystem_idive.h"
 #include "cochran_commander.h"
 #include "tecdiving_divecomputereu.h"
+#include "garmin.h"
+#include "deepblu.h"
 
 #include "device-private.h"
 #include "context-private.h"
@@ -211,6 +213,12 @@ dc_device_open (dc_device_t **out, dc_context_t *context, dc_descriptor_t *descr
 	case DC_FAMILY_TECDIVING_DIVECOMPUTEREU:
 		rc = tecdiving_divecomputereu_device_open (&device, context, iostream);
 		break;
+	case DC_FAMILY_GARMIN:
+		rc = garmin_device_open (&device, context, iostream);
+		break;
+	case DC_FAMILY_DEEPBLU:
+		rc = deepblu_device_open (&device, context, iostream);
+		break;
 	default:
 		return DC_STATUS_INVALIDARGS;
 	}

src/field-cache.c

@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "parser-private.h"
+#include "field-cache.h"
+
+/*
+ * The field cache 'string' interface has some simple rules:
+ * the "descriptor" part is assumed to be a static allocation,
+ * while the "value" is something that this interface will
+ * alway sallocate with 'strdup()', so you can generate it
+ * dynamically on the stack or whatever without having to
+ * worry about it.
+ */
+dc_status_t dc_field_add_string(dc_field_cache_t *cache, const char *desc, const char *value)
+{
+	int i;
+
+	cache->initialized |= 1 << DC_FIELD_STRING;
+	for (i = 0; i < MAXSTRINGS; i++) {
+		dc_field_string_t *str = cache->strings+i;
+		if (str->desc)
+			continue;
+		str->value = strdup(value);
+		if (!str->value)
+			return DC_STATUS_NOMEMORY;
+		str->desc = desc;
+		return DC_STATUS_SUCCESS;
+	}
+	return DC_STATUS_INVALIDARGS;
+}
+
+dc_status_t dc_field_add_string_fmt(dc_field_cache_t *cache, const char *desc, const char *fmt, ...)
+{
+	char buffer[256];
+	va_list ap;
+
+	/*
+	 * We ignore the return value from vsnprintf, and we
+	 * always NUL-terminate the destination buffer ourselves.
+	 *
+	 * That way we don't have to worry about random bad legacy
+	 * implementations.
+	 */
+	va_start(ap, fmt);
+	buffer[sizeof(buffer)-1] = 0;
+	(void) vsnprintf(buffer, sizeof(buffer)-1, fmt, ap);
+	va_end(ap);
+
+	return dc_field_add_string(cache, desc, buffer);
+}
+
+dc_status_t dc_field_get_string(dc_field_cache_t *cache, unsigned idx, dc_field_string_t *value)
+{
+	if (idx < MAXSTRINGS) {
+		dc_field_string_t *res = cache->strings+idx;
+		if (res->desc && res->value) {
+			*value = *res;
+			return DC_STATUS_SUCCESS;
+		}
+	}
+	return DC_STATUS_UNSUPPORTED;
+}

src/field-cache.h

@@ -0,0 +1,63 @@
+#include <string.h>
+
+#define MAXGASES 16
+#define MAXSTRINGS 32
+
+// dc_get_field() data
+typedef struct dc_field_cache {
+	unsigned int initialized;
+
+	// DC_GET_FIELD_xyz
+	unsigned int DIVETIME;
+	double MAXDEPTH;
+	double AVGDEPTH;
+	double ATMOSPHERIC;
+	dc_divemode_t DIVEMODE;
+	unsigned int GASMIX_COUNT;
+	dc_salinity_t SALINITY;
+	dc_gasmix_t GASMIX[MAXGASES];
+
+	// misc - clean me up!
+	double lowsetpoint;
+	double highsetpoint;
+	double customsetpoint;
+
+	// This (slong with GASMIX) should be something like
+	//     dc_tank_t TANK[MAXGASES]
+	// but that's for later
+	dc_tankinfo_t tankinfo[MAXGASES];
+	double tanksize[MAXGASES];
+	double tankworkingpressure[MAXGASES];
+
+	// DC_GET_FIELD_STRING
+	dc_field_string_t strings[MAXSTRINGS];
+} dc_field_cache_t;
+
+dc_status_t dc_field_add_string(dc_field_cache_t *, const char *desc, const char *data);
+dc_status_t dc_field_add_string_fmt(dc_field_cache_t *, const char *desc, const char *fmt, ...);
+dc_status_t dc_field_get_string(dc_field_cache_t *, unsigned idx, dc_field_string_t *value);
+
+/*
+ * Macro to make it easy to set DC_FIELD_xyz values.
+ *
+ * This explains why dc_field_cache member names are
+ * those odd all-capitalized names: they match the
+ * names of the DC_FIELD_xyz enums.
+ */
+#define DC_ASSIGN_FIELD(cache, name, value) do { \
+	(cache).initialized |= 1u << DC_FIELD_##name; \
+	(cache).name = (value); \
+} while (0)
+
+#define DC_ASSIGN_IDX(cache, name, idx, value) do { \
+	(cache).initialized |= 1u << DC_FIELD_##name; \
+	(cache).name[idx] = (value); \
+} while (0)
+
+// Ugly define thing makes the code much easier to read
+// I'd love to use __typeof__, but that's a gcc'ism
+#define DC_FIELD_VALUE(cache, p, NAME) \
+	(memcpy((p), &(cache).NAME, sizeof((cache).NAME)), DC_STATUS_SUCCESS)
+
+#define DC_FIELD_INDEX(cache, p, NAME, idx) \
+	(memcpy((p), (cache).NAME+idx, sizeof((cache).NAME[0])), DC_STATUS_SUCCESS)

src/garmin.c

@@ -0,0 +1,338 @@
+/*
+ * Garmin Descent Mk1 USB storage downloading
+ *
+ * Copyright (C) 2018 Linus Torvalds
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "garmin.h"
+#include "context-private.h"
+#include "device-private.h"
+#include "array.h"
+
+typedef struct garmin_device_t {
+	dc_device_t base;
+	dc_iostream_t *iostream;
+	unsigned char fingerprint[FIT_NAME_SIZE];
+} garmin_device_t;
+
+static dc_status_t garmin_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size);
+static dc_status_t garmin_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata);
+static dc_status_t garmin_device_close (dc_device_t *abstract);
+
+static const dc_device_vtable_t garmin_device_vtable = {
+	sizeof(garmin_device_t),
+	DC_FAMILY_GARMIN,
+	garmin_device_set_fingerprint, /* set_fingerprint */
+	NULL, /* read */
+	NULL, /* write */
+	NULL, /* dump */
+	garmin_device_foreach, /* foreach */
+	NULL, /* timesync */
+	garmin_device_close, /* close */
+};
+
+dc_status_t
+garmin_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_t *iostream)
+{
+	dc_status_t status = DC_STATUS_SUCCESS;
+	garmin_device_t *device = NULL;
+
+	if (out == NULL)
+		return DC_STATUS_INVALIDARGS;
+
+	// Allocate memory.
+	device = (garmin_device_t *) dc_device_allocate (context, &garmin_device_vtable);
+	if (device == NULL) {
+		ERROR (context, "Failed to allocate memory.");
+		return DC_STATUS_NOMEMORY;
+	}
+
+	// Set the default values.
+	device->iostream = iostream;
+	memset(device->fingerprint, 0, sizeof(device->fingerprint));
+
+	*out = (dc_device_t *) device;
+
+	return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t
+garmin_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size)
+{
+	garmin_device_t *device = (garmin_device_t *)abstract;
+
+	if (size && size != sizeof (device->fingerprint))
+		return DC_STATUS_INVALIDARGS;
+
+	if (size)
+		memcpy (device->fingerprint, data, sizeof (device->fingerprint));
+	else
+		memset (device->fingerprint, 0, sizeof (device->fingerprint));
+
+	return DC_STATUS_SUCCESS;
+}
+
+
+static dc_status_t
+garmin_device_close (dc_device_t *abstract)
+{
+	dc_status_t status = DC_STATUS_SUCCESS;
+	garmin_device_t *device = (garmin_device_t *) abstract;
+
+	return DC_STATUS_SUCCESS;
+}
+
+struct file_list {
+	int nr, allocated;
+	struct fit_name *array;
+};
+
+static int name_cmp(const void *a, const void *b)
+{
+	// Sort reverse string ordering (newest first), so use 'b,a'
+	return strcmp(b,a);
+}
+
+/*
+ * Get the FIT file list and sort it.
+ *
+ * Return number of files found.
+*/
+static int get_file_list(dc_device_t *abstract, DIR *dir, struct file_list *files)
+{
+	struct dirent *de;
+
+	DEBUG (abstract->context, "Iterating over Garmin files");
+	while ((de = readdir(dir)) != NULL) {
+		int len = strlen(de->d_name);
+		struct fit_name *entry;
+		const char *explain = NULL;
+
+		DEBUG (abstract->context, "  %s", de->d_name);
+
+		if (len < 5)
+			explain = "name too short";
+		if (len >= FIT_NAME_SIZE)
+			explain = "name too long";
+		if (strncasecmp(de->d_name + len - 4, ".FIT", 4))
+			explain = "name lacks FIT suffix";
+
+		DEBUG (abstract->context, "  %s - %s", de->d_name, explain ? explain : "adding to list");
+		if (explain)
+			continue;
+
+		if (files->nr == files->allocated) {
+			struct fit_name *array;
+			int n = 3*(files->allocated + 8)/2;
+			size_t new_size;
+
+			new_size = n * sizeof(array[0]);
+			array = realloc(files->array, new_size);
+			if (!array)
+				return DC_STATUS_NOMEMORY;
+
+			files->array = array;
+			files->allocated = n;
+		}
+
+		/*
+		 * NOTE! This depends on the zero-padding that strncpy does.
+		 *
+		 * strncpy() doesn't just limit the size of the copy, it
+		 * will zero-pad the end of the result buffer.
+		 */
+		entry = files->array + files->nr++;
+		strncpy(entry->name, de->d_name, FIT_NAME_SIZE);
+	}
+	DEBUG (abstract->context, "Found %d files", files->nr);
+
+	qsort(files->array, files->nr, sizeof(struct fit_name), name_cmp);
+	return DC_STATUS_SUCCESS;
+}
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+static dc_status_t
+read_file(char *pathname, int pathlen, const char *name, dc_buffer_t *file)
+{
+	int fd, rc;
+
+	pathname[pathlen] = '/';
+	memcpy(pathname+pathlen+1, name, FIT_NAME_SIZE);
+	fd = open(pathname, O_RDONLY | O_BINARY);
+
+	if (fd < 0)
+		return DC_STATUS_IO;
+
+	rc = DC_STATUS_SUCCESS;
+	for (;;) {
+		char buffer[4096];
+		int n;
+
+		n = read(fd, buffer, sizeof(buffer));
+		if (!n)
+			break;
+		if (n > 0) {
+			dc_buffer_append(file, buffer, n);
+			continue;
+		}
+		rc = DC_STATUS_IO;
+		break;
+	}
+
+	close(fd);
+	return rc;
+}
+
+static dc_status_t
+garmin_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
+{
+	dc_status_t status = DC_STATUS_SUCCESS;
+	garmin_device_t *device = (garmin_device_t *) abstract;
+	dc_parser_t *parser;
+	char pathname[PATH_MAX];
+	size_t pathlen;
+	struct file_list files = { 0, 0, NULL };
+	dc_buffer_t *file;
+	DIR *dir;
+	int rc;
+
+	// Read the directory name from the iostream
+	rc = dc_iostream_read(device->iostream, &pathname, sizeof(pathname)-1, &pathlen);
+	if (rc != DC_STATUS_SUCCESS)
+		return rc;
+	pathname[pathlen] = 0;
+
+	// The actual dives are under the "Garmin/Activity/" directory
+	// as FIT files, with names like "2018-08-20-10-23-30.fit".
+	// Make sure our buffer is big enough.
+	if (pathlen + strlen("/Garmin/Activity/") + FIT_NAME_SIZE + 2 > PATH_MAX) {
+		ERROR (abstract->context, "Invalid Garmin base directory '%s'", pathname);
+		return DC_STATUS_IO;
+	}
+
+	if (pathlen && pathname[pathlen-1] != '/')
+		pathname[pathlen++] = '/';
+	strcpy(pathname + pathlen, "Garmin/Activity");
+	pathlen += strlen("Garmin/Activity");
+
+	dir = opendir(pathname);
+	if (!dir) {
+		ERROR (abstract->context, "Failed to open directory '%s'.", pathname);
+		return DC_STATUS_IO;
+	}
+
+	// Get the list of FIT files
+	rc = get_file_list(abstract, dir, &files);
+	closedir(dir);
+	if (rc != DC_STATUS_SUCCESS || !files.nr) {
+		free(files.array);
+		return rc;
+	}
+
+	// Can we find the fingerprint entry?
+	for (int i = 0; i < files.nr; i++) {
+		const char *name = files.array[i].name;
+
+		if (memcmp(name, device->fingerprint, sizeof (device->fingerprint)))
+			continue;
+
+		// Found fingerprint, just cut the array short here
+		files.nr = i;
+		DEBUG (abstract->context, "Ignoring '%s' and older", name);
+		break;
+	}
+
+	// Enable progress notifications.
+	dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
+	progress.maximum = files.nr;
+	progress.current = 0;
+	device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
+
+	file = dc_buffer_new (16384);
+	if (file == NULL) {
+		ERROR (abstract->context, "Insufficient buffer space available.");
+		free(files.array);
+		return DC_STATUS_NOMEMORY;
+	}
+	if ((rc = garmin_parser_create(&parser, abstract->context) != DC_STATUS_SUCCESS)) {
+		ERROR (abstract->context, "Failed to create parser for dive verification.");
+		free(files.array);
+		return rc;
+	}
+
+	dc_event_devinfo_t devinfo;
+	dc_event_devinfo_t *devinfo_p = &devinfo;
+	for (int i = 0; i < files.nr; i++) {
+		const char *name = files.array[i].name;
+		const unsigned char *data;
+		unsigned int size;
+		short is_dive = 0;
+
+		if (device_is_cancelled(abstract)) {
+			status = DC_STATUS_CANCELLED;
+			break;
+		}
+
+		// Reset the membuffer, read the data
+		dc_buffer_clear(file);
+		dc_buffer_append(file, name, FIT_NAME_SIZE);
+
+		status = read_file(pathname, pathlen, name, file);
+		if (status != DC_STATUS_SUCCESS)
+			break;
+
+		data = dc_buffer_get_data(file);
+		size = dc_buffer_get_size(file);
+
+		is_dive = garmin_parser_is_dive(parser, data, size, devinfo_p);
+		if (devinfo_p) {
+			// first time we came through here, let's emit the
+			// devinfo and vendor events
+			device_event_emit (abstract, DC_EVENT_DEVINFO, devinfo_p);
+			devinfo_p = NULL;
+		}
+		if (!is_dive) {
+			DEBUG (abstract->context, "decided %s isn't a dive.", name);
+			continue;
+		}
+
+		if (callback && !callback(data, size, name, FIT_NAME_SIZE, userdata))
+			break;
+
+		progress.current++;
+		device_event_emit(abstract, DC_EVENT_PROGRESS, &progress);
+	}
+
+	free(files.array);
+	dc_parser_destroy(parser);
+	return status;
+}

src/garmin.h

@@ -0,0 +1,59 @@
+/*
+ * Garmin Descent Mk1
+ *
+ * Copyright (C) 2018 Linus Torvalds
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#ifndef GARMIN_H
+#define GARMIN_H
+
+#include <libdivecomputer/context.h>
+#include <libdivecomputer/iostream.h>
+#include <libdivecomputer/device.h>
+#include <libdivecomputer/parser.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+dc_status_t
+garmin_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
+
+dc_status_t
+garmin_parser_create (dc_parser_t **parser, dc_context_t *context);
+
+// we need to be able to call into the parser to check if the
+// files that we find are actual dives
+int
+garmin_parser_is_dive (dc_parser_t *abstract, const unsigned char *data, unsigned int size, dc_event_devinfo_t *devinfo_p);
+
+// The dive names are of the form "2018-08-20-10-23-30.fit"
+// With the terminating zero, that's 24 bytes.
+//
+// We use this as the fingerprint, but it ends up being a
+// special fixed header in the parser data too.
+#define FIT_NAME_SIZE 24
+
+struct fit_name {
+	char name[FIT_NAME_SIZE];
+};
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* GARMIN_H */

src/hw_ostc.h

@@ -36,7 +36,7 @@ dc_status_t
 hw_ostc_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
 
 dc_status_t
-hw_ostc_parser_create (dc_parser_t **parser, dc_context_t *context);
+hw_ostc_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int serial);
 
 #ifdef __cplusplus
 }

src/hw_ostc3.h

@@ -36,7 +36,7 @@ dc_status_t
 hw_ostc3_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
 
 dc_status_t
-hw_ostc3_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model);
+hw_ostc3_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int serial, unsigned int model);
 
 #ifdef __cplusplus
 }

src/hw_ostc_parser.c

@@ -20,6 +20,12 @@
  */
 
 #include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
 
 #include "libdivecomputer/units.h"
 
@@ -69,8 +75,14 @@
 #define OSTC3_APNEA 3
 #define OSTC3_PSCR  4
 
+#define OSTC3_ZHL16    0
+#define OSTC3_ZHL16_GF 1
+#define OSTC4_VPM      2
+
 #define OSTC4      0x3B
 
+#define UNSUPPORTED 0xFFFFFFFF
+
 #define OSTC3FW(major,minor) ( \
 		(((major) & 0xFF) << 8) | \
 		((minor) & 0xFF))
@@ -96,7 +108,13 @@ typedef struct hw_ostc_layout_t {
 	unsigned int salinity;
 	unsigned int duration;
 	unsigned int temperature;
+	unsigned int battery;
+	unsigned int desat;
 	unsigned int firmware;
+	unsigned int deco_info1;
+	unsigned int deco_info2;
+	unsigned int decomode;
+	unsigned int battery_percentage;
 } hw_ostc_layout_t;
 
 typedef struct hw_ostc_gasmix_t {
@@ -108,6 +126,7 @@ typedef struct hw_ostc_parser_t {
 	dc_parser_t base;
 	unsigned int hwos;
 	unsigned int model;
+	unsigned int serial;
 	// Cached fields.
 	unsigned int cached;
 	unsigned int version;
@@ -145,7 +164,13 @@ static const hw_ostc_layout_t hw_ostc_layout_ostc = {
 	43, /* salinity */
 	47, /* duration */
 	13, /* temperature */
+	34, /* battery volt after dive */
+	17, /* desat */
 	32, /* firmware */
+	49, /* deco_info1 */
+	50, /* deco_info1 */
+	51, /* decomode */
+	0,  /* battery percentage TBD */
 };
 
 static const hw_ostc_layout_t hw_ostc_layout_frog = {
@@ -157,7 +182,13 @@ static const hw_ostc_layout_t hw_ostc_layout_frog = {
 	43, /* salinity */
 	47, /* duration */
 	19, /* temperature */
+	34, /* battery volt after dive */
+	23, /* desat */
 	32, /* firmware */
+	49, /* deco_info1 */
+	50, /* deco_info2 */
+	51, /* decomode */
+	0,  /* battery percentage TBD */
 };
 
 static const hw_ostc_layout_t hw_ostc_layout_ostc3 = {
@@ -169,7 +200,13 @@ static const hw_ostc_layout_t hw_ostc_layout_ostc3 = {
 	70, /* salinity */
 	75, /* duration */
 	22, /* temperature */
+	50, /* battery volt after dive */
+	26, /* desat */
 	48, /* firmware */
+	77, /* deco_info1 */
+	78, /* deco_info2 */
+	79, /* decomode */
+        59, /* battery percentage */
 };
 
 static unsigned int
@@ -312,7 +349,7 @@ hw_ostc_parser_cache (hw_ostc_parser_t *parser)
 }
 
 static dc_status_t
-hw_ostc_parser_create_internal (dc_parser_t **out, dc_context_t *context, unsigned int hwos, unsigned int model)
+hw_ostc_parser_create_internal (dc_parser_t **out, dc_context_t *context, unsigned int serial, unsigned int hwos, unsigned int model)
 {
 	hw_ostc_parser_t *parser = NULL;
 
@@ -342,6 +379,7 @@ hw_ostc_parser_create_internal (dc_parser_t **out, dc_context_t *context, unsign
 		parser->gasmix[i].oxygen = 0;
 		parser->gasmix[i].helium = 0;
 	}
+	parser->serial = serial;
 
 	*out = (dc_parser_t *) parser;
 
@@ -350,15 +388,15 @@ hw_ostc_parser_create_internal (dc_parser_t **out, dc_context_t *context, unsign
 
 
 dc_status_t
-hw_ostc_parser_create (dc_parser_t **out, dc_context_t *context)
+hw_ostc_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int serial)
 {
-	return hw_ostc_parser_create_internal (out, context, 0, 0);
+	return hw_ostc_parser_create_internal (out, context, serial, 0, 0);
 }
 
 dc_status_t
-hw_ostc3_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model)
+hw_ostc3_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int serial, unsigned int model)
 {
-	return hw_ostc_parser_create_internal (out, context, 1, model);
+	return hw_ostc_parser_create_internal (out, context, serial, 1, model);
 }
 
 static dc_status_t
@@ -446,6 +484,8 @@ hw_ostc_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime)
 	return DC_STATUS_SUCCESS;
 }
 
+#define BUFLEN 32
+
 static dc_status_t
 hw_ostc_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value)
 {
@@ -470,9 +510,12 @@ hw_ostc_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned
 
 	dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
 	dc_salinity_t *water = (dc_salinity_t *) value;
+	dc_field_string_t *string = (dc_field_string_t *) value;
+
 	unsigned int salinity = data[layout->salinity];
 	if (version == 0x23 || version == 0x24)
 		salinity += 100;
+	char buf[BUFLEN];
 
 	if (value) {
 		switch (type) {
@@ -570,6 +613,79 @@ hw_ostc_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned
 				return DC_STATUS_UNSUPPORTED;
 			}
 			break;
+		case DC_FIELD_STRING:
+			switch(flags) {
+			case 0: /* serial */
+				string->desc = "Serial";
+				snprintf(buf, BUFLEN, "%u", parser->serial);
+				break;
+			case 1: /* battery */
+				string->desc = "Battery at end";
+				unsigned int percentage = (unsigned int) data[layout->battery_percentage];
+				if (percentage != 0xFF && (version == 0x23 || version == 0x24)) {
+					percentage = percentage>100? 100: percentage;
+					snprintf(buf, BUFLEN, "%.2fV, %u%% remaining",
+					         array_uint16_le (data + layout->battery) / 1000.0,
+					         percentage);
+				} else {
+					snprintf(buf, BUFLEN, "%.2fV", array_uint16_le (data + layout->battery) / 1000.0);
+				}
+				break;
+			case 2: /* desat */
+				string->desc = "Desat time";
+				snprintf(buf, BUFLEN, "%0u:%02u", array_uint16_le (data + layout->desat) / 60,
+						 array_uint16_le (data + layout->desat) % 60);
+				break;
+			case 3: /* firmware */
+				string->desc = "FW Version";
+				/* OSTC4 stores firmware as XXXX XYYY YYZZ ZZZB, -> X.Y.Z beta? */
+				if (parser->model == OSTC4) {
+					int firmwareOnDevice = array_uint16_le (data + layout->firmware);
+					unsigned char X = 0, Y = 0, Z = 0, beta = 0;
+					X = (firmwareOnDevice & 0xF800) >> 11;
+					Y = (firmwareOnDevice & 0x07C0) >> 6;
+					Z = (firmwareOnDevice & 0x003E) >> 1;
+					beta = firmwareOnDevice & 0x0001;
+
+					snprintf(buf, BUFLEN, "%u.%u.%u%s\n", X, Y, Z, beta? "beta": "");
+				} else {
+					snprintf(buf, BUFLEN, "%0u.%02u", data[layout->firmware], data[layout->firmware + 1]);
+				}
+				break;
+
+			case 4: /* Deco model */
+				string->desc = "Deco model";
+				if (((version == 0x23 || version == 0x24) && data[layout->decomode] == OSTC3_ZHL16) ||
+						(version == 0x22 && data[layout->decomode] == FROG_ZHL16) ||
+						(version == 0x21 && (data[layout->decomode] == OSTC_ZHL16_OC || data[layout->decomode] == OSTC_ZHL16_CC)))
+					strncpy(buf, "ZH-L16", BUFLEN);
+				else if (((version == 0x23 || version == 0x24) && data[layout->decomode] == OSTC3_ZHL16_GF) ||
+						(version == 0x22 && data[layout->decomode] == FROG_ZHL16_GF) ||
+						(version == 0x21 && (data[layout->decomode] == OSTC_ZHL16_OC_GF || data[layout->decomode] == OSTC_ZHL16_CC_GF)))
+					strncpy(buf, "ZH-L16-GF", BUFLEN);
+				else if (((version == 0x24) && data[layout->decomode] == OSTC4_VPM))
+					strncpy(buf, "VPM", BUFLEN);
+				else
+					return DC_STATUS_DATAFORMAT;
+				break;
+			case 5: /* Deco model info */
+				string->desc = "Deco model info";
+				if (((version == 0x23 || version == 0x24) && data[layout->decomode] == OSTC3_ZHL16) ||
+						(version == 0x22 && data[layout->decomode] == FROG_ZHL16) ||
+						(version == 0x21 && (data[layout->decomode] == OSTC_ZHL16_OC || data[layout->decomode] == OSTC_ZHL16_CC)))
+					snprintf(buf, BUFLEN, "Saturation %u, Desaturation %u", layout->deco_info1, layout->deco_info2);
+				else if (((version == 0x23 || version == 0x24) && data[layout->decomode] == OSTC3_ZHL16_GF) ||
+						(version == 0x22 && data[layout->decomode] == FROG_ZHL16_GF) ||
+						(version == 0x21 && (data[layout->decomode] == OSTC_ZHL16_OC_GF || data[layout->decomode] == OSTC_ZHL16_CC_GF)))
+					snprintf(buf, BUFLEN, "GF %u/%u", data[layout->deco_info1], data[layout->deco_info2]);
+				else
+					return DC_STATUS_DATAFORMAT;
+				break;
+			default:
+				return DC_STATUS_UNSUPPORTED;
+			}
+			string->value = strdup(buf);
+			break;
 		default:
 			return DC_STATUS_UNSUPPORTED;
 		}

src/iostream.c

@@ -188,43 +188,86 @@ dc_iostream_poll (dc_iostream_t *iostream, int timeout)
 dc_status_t
 dc_iostream_read (dc_iostream_t *iostream, void *data, size_t size, size_t *actual)
 {
-	dc_status_t status = DC_STATUS_SUCCESS;
+	if (actual)
-	size_t nbytes = 0;
+		*actual = 0;
 
-	if (iostream == NULL || iostream->vtable->read == NULL) {
+	if (iostream == NULL || iostream->vtable->read == NULL)
-		goto out;
+		return DC_STATUS_IO;
+
+	while (size) {
+		dc_status_t status;
+		size_t nbytes = 0;
+
+		status = iostream->vtable->read (iostream, data, size, &nbytes);
+		HEXDUMP (iostream->context, DC_LOGLEVEL_INFO, "Read", (unsigned char *) data, nbytes);
+
+		/*
+		 * If the reader is able to handle partial results,
+		 * return them as such. NOTE! No need to add up a
+		 * total, we will go through this loop only once
+		 * in this case.
+		 */
+		if (actual) {
+			*actual = nbytes;
+			return status;
+		}
+
+		if (status != DC_STATUS_SUCCESS)
+			return status;
+
+		/*
+		 * Defensive check: if the read() function returned
+		 * zero bytes, don't loop forever - give up with a
+		 * timeout. Jef pointed out that the subsurface
+		 * qt_serial_read() function can cause this badness..
+		 */
+		if (!nbytes)
+			return DC_STATUS_TIMEOUT;
+
+		/*
+		 * Continue reading to fill up the whole buffer,
+		 * since the reader is not able to handle a
+		 * partial result.
+		 */
+		data = (void *)(nbytes + (char *)data);
+		size -= nbytes;
 	}
 
-	status = iostream->vtable->read (iostream, data, size, &nbytes);
+	return DC_STATUS_SUCCESS;
-
-	HEXDUMP (iostream->context, DC_LOGLEVEL_INFO, "Read", (unsigned char *) data, nbytes);
-
-out:
-	if (actual)
-		*actual = nbytes;
-
-	return status;
 }
 
 dc_status_t
 dc_iostream_write (dc_iostream_t *iostream, const void *data, size_t size, size_t *actual)
 {
-	dc_status_t status = DC_STATUS_SUCCESS;
+	if (actual)
-	size_t nbytes = 0;
+		*actual = 0;
 
-	if (iostream == NULL || iostream->vtable->write == NULL) {
+	if (iostream == NULL || iostream->vtable->write == NULL)
-		goto out;
+		return DC_STATUS_IO;
+
+	while (size) {
+		dc_status_t status;
+		size_t nbytes = 0;
+
+		status = iostream->vtable->write (iostream, data, size, &nbytes);
+		HEXDUMP (iostream->context, DC_LOGLEVEL_INFO, "Write", (const unsigned char *) data, nbytes);
+
+		if (actual) {
+			*actual = nbytes;
+			return status;
+		}
+
+		if (status != DC_STATUS_SUCCESS)
+			return status;
+
+		if (!nbytes)
+			return DC_STATUS_IO;
+
+		data = (void *)(nbytes + (char *)data);
+		size -= nbytes;
 	}
 
-	status = iostream->vtable->write (iostream, data, size, &nbytes);
+	return DC_STATUS_SUCCESS;
-
-	HEXDUMP (iostream->context, DC_LOGLEVEL_INFO, "Write", (const unsigned char *) data, nbytes);
-
-out:
-	if (actual)
-		*actual = nbytes;
-
-	return status;
 }
 
 dc_status_t

src/libdivecomputer.symbols

@@ -76,6 +76,8 @@ dc_usbhid_device_free
 dc_usbhid_iterator_new
 dc_usbhid_open
 
+dc_usb_storage_open
+
 dc_custom_open
 
 dc_parser_new

src/mares_iconhd.c

@@ -97,6 +97,7 @@ typedef struct mares_iconhd_device_t {
 	unsigned char cache[20];
 	unsigned int available;
 	unsigned int offset;
+	unsigned int splitcommand;
 } mares_iconhd_device_t;
 
 static dc_status_t mares_iconhd_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size);
@@ -250,14 +251,17 @@ mares_iconhd_packet (mares_iconhd_device_t *device,
 {
 	dc_status_t status = DC_STATUS_SUCCESS;
 	dc_device_t *abstract = (dc_device_t *) device;
+	unsigned int split_csize;
 
 	assert (csize >= 2);
 
 	if (device_is_cancelled (abstract))
 		return DC_STATUS_CANCELLED;
 
+	split_csize = device->splitcommand ? 2 : csize;
+
 	// Send the command header to the dive computer.
-	status = mares_iconhd_write (device, command, 2);
+	status = mares_iconhd_write (device, command, split_csize);
 	if (status != DC_STATUS_SUCCESS) {
 		ERROR (abstract->context, "Failed to send the command.");
 		return status;
@@ -277,9 +281,9 @@ mares_iconhd_packet (mares_iconhd_device_t *device,
 		return DC_STATUS_PROTOCOL;
 	}
 
-	// Send the command payload to the dive computer.
+	// Send any remaining command payload to the dive computer.
-	if (csize > 2) {
+	if (csize > split_csize) {
-		status = mares_iconhd_write (device, command + 2, csize - 2);
+		status = mares_iconhd_write (device, command + split_csize, csize - split_csize);
 		if (status != DC_STATUS_SUCCESS) {
 			ERROR (abstract->context, "Failed to send the command.");
 			return status;
@@ -476,6 +480,15 @@ mares_iconhd_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_
 	device->available = 0;
 	device->offset = 0;
 
+	/*
+	 * At least the Mares Matrix needs the command to be split into
+	 * base and argument, with a wait for the ACK byte in between.
+	 *
+	 * See commit 59bfb0f3189b ("Add support for the Mares Matrix")
+	 * for details.
+	 */
+	device->splitcommand = 1;
+
 	// Set the serial communication protocol (115200 8E1).
 	status = dc_iostream_configure (device->iostream, 115200, 8, DC_PARITY_EVEN, DC_STOPBITS_ONE, DC_FLOWCONTROL_NONE);
 	if (status != DC_STATUS_SUCCESS) {
@@ -575,6 +588,26 @@ mares_iconhd_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_
 		break;
 	}
 
+	if (dc_iostream_get_transport(device->iostream) == DC_TRANSPORT_BLE) {
+		/*
+		 * Don't ask for larger amounts of data with the BLE
+		 * transport - it will fail.  I suspect there is a buffer
+		 * overflow in the BlueLink Pro dongle when bluetooth is
+		 * slower than the serial protocol that the dongle talks to
+		 * the dive computer.
+		 */
+		if (device->packetsize > 128)
+			device->packetsize = 128;
+		/*
+		 * With BLE, don't wait for ACK before sending the arguments
+		 * to a command.
+		 *
+		 * There is some timing issue that makes that take too long
+		 * and causes the command to be aborted.
+		 */
+		device->splitcommand = 0;
+	}
+
 	*out = (dc_device_t *) device;
 
 	return DC_STATUS_SUCCESS;

src/oceanic_atom2.c

@@ -1011,7 +1011,7 @@ oceanic_atom2_device_open (dc_device_t **out, dc_context_t *context, dc_iostream
 	} else if (OCEANIC_COMMON_MATCH (device->base.version, oceanic_default_version)) {
 		device->base.layout = &oceanic_default_layout;
 	} else {
-		WARNING (context, "Unsupported device detected!");
+		WARNING (context, "Unsupported device detected (%s)!", device->base.version);
 		device->base.layout = &oceanic_default_layout;
 		if (memcmp(device->base.version + 12, "256K", 4) == 0) {
 			device->base.layout = &oceanic_atom1_layout;

src/oceanic_atom2.h

@@ -37,7 +37,7 @@ dc_status_t
 oceanic_atom2_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream, unsigned int model);
 
 dc_status_t
-oceanic_atom2_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model);
+oceanic_atom2_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model, unsigned int serial);
 
 #ifdef __cplusplus
 }

src/oceanic_atom2_parser.c

@@ -20,6 +20,8 @@
  */
 
 #include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
 
 #include <libdivecomputer/units.h>
 
@@ -113,6 +115,7 @@ struct oceanic_atom2_parser_t {
 	unsigned int model;
 	unsigned int headersize;
 	unsigned int footersize;
+	unsigned int serial;
 	// Cached fields.
 	unsigned int cached;
 	unsigned int header;
@@ -142,7 +145,7 @@ static const dc_parser_vtable_t oceanic_atom2_parser_vtable = {
 
 
 dc_status_t
-oceanic_atom2_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model)
+oceanic_atom2_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model, unsigned int serial)
 {
 	oceanic_atom2_parser_t *parser = NULL;
 
@@ -195,6 +198,7 @@ oceanic_atom2_parser_create (dc_parser_t **out, dc_context_t *context, unsigned
 		parser->headersize = 5 * PAGESIZE / 2;
 	}
 
+	parser->serial = serial;
 	parser->cached = 0;
 	parser->header = 0;
 	parser->footer = 0;
@@ -396,6 +400,7 @@ oceanic_atom2_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetim
 	return DC_STATUS_SUCCESS;
 }
 
+#define BUF_LEN 16
 
 static dc_status_t
 oceanic_atom2_parser_cache (oceanic_atom2_parser_t *parser)
@@ -543,6 +548,9 @@ oceanic_atom2_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, uns
 
 	dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
 	dc_salinity_t *water = (dc_salinity_t *) value;
+	dc_field_string_t *string = (dc_field_string_t *) value;
+
+	char buf[BUF_LEN];
 
 	if (value) {
 		switch (type) {
@@ -572,7 +580,7 @@ oceanic_atom2_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, uns
 			break;
 		case DC_FIELD_SALINITY:
 			if (parser->model == A300CS || parser->model == VTX ||
-				parser->model == I750TC) {
+				parser->model == I750TC || parser->model == I770R) {
 				if (data[0x18] & 0x80) {
 					water->type = DC_WATER_FRESH;
 				} else {
@@ -598,6 +606,17 @@ oceanic_atom2_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, uns
 				return DC_STATUS_DATAFORMAT;
 			}
 			break;
+		case DC_FIELD_STRING:
+			switch(flags) {
+			case 0: /* Serial */
+				string->desc = "Serial";
+				snprintf(buf, BUF_LEN, "%06u", parser->serial);
+				break;
+			default:
+				return DC_STATUS_UNSUPPORTED;
+			}
+			string->value = strdup(buf);
+			break;
 		default:
 			return DC_STATUS_UNSUPPORTED;
 		}
@@ -752,7 +771,7 @@ oceanic_atom2_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_
 	if (have_pressure) {
 		unsigned int idx = 2;
 		if (parser->model == A300CS || parser->model == VTX ||
-			parser->model == I750TC)
+			parser->model == I750TC || parser->model == I770R)
 			idx = 16;
 		pressure = array_uint16_le(data + parser->header + idx);
 		if (pressure == 10000)
@@ -805,7 +824,7 @@ oceanic_atom2_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_
 				tank = 0;
 				pressure = (((data[offset + 7] << 8) + data[offset + 6]) & 0x0FFF);
 			} else if (parser->model == A300CS || parser->model == VTX ||
-				parser->model == I750TC) {
+				parser->model == I750TC || parser->model == I770R) {
 				// Tank pressure (1 psi) and number (one based index)
 				tank = (data[offset + 1] & 0x03) - 1;
 				pressure = ((data[offset + 7] << 8) + data[offset + 6]) & 0x0FFF;

src/parser.c

@@ -57,6 +57,8 @@
 #include "divesystem_idive.h"
 #include "cochran_commander.h"
 #include "tecdiving_divecomputereu.h"
+#include "garmin.h"
+#include "deepblu.h"
 
 #include "context-private.h"
 #include "parser-private.h"
@@ -65,7 +67,7 @@
 #define REACTPROWHITE 0x4354
 
 static dc_status_t
-dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t family, unsigned int model, unsigned int devtime, dc_ticks_t systime)
+dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t family, unsigned int model, unsigned int serial, unsigned int devtime, dc_ticks_t systime)
 {
 	dc_status_t rc = DC_STATUS_SUCCESS;
 	dc_parser_t *parser = NULL;
@@ -88,7 +90,7 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
 		break;
 	case DC_FAMILY_SUUNTO_VYPER2:
 	case DC_FAMILY_SUUNTO_D9:
-		rc = suunto_d9_parser_create (&parser, context, model);
+		rc = suunto_d9_parser_create (&parser, context, model, serial);
 		break;
 	case DC_FAMILY_SUUNTO_EONSTEEL:
 		rc = suunto_eonsteel_parser_create(&parser, context, model);
@@ -119,7 +121,7 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
 		if (model == REACTPROWHITE)
 			rc = oceanic_veo250_parser_create (&parser, context, model);
 		else
-			rc = oceanic_atom2_parser_create (&parser, context, model);
+			rc = oceanic_atom2_parser_create (&parser, context, model, serial);
 		break;
 	case DC_FAMILY_MARES_NEMO:
 	case DC_FAMILY_MARES_PUCK:
@@ -132,11 +134,11 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
 		rc = mares_iconhd_parser_create (&parser, context, model);
 		break;
 	case DC_FAMILY_HW_OSTC:
-		rc = hw_ostc_parser_create (&parser, context);
+		rc = hw_ostc_parser_create (&parser, context, serial);
 		break;
 	case DC_FAMILY_HW_FROG:
 	case DC_FAMILY_HW_OSTC3:
-		rc = hw_ostc3_parser_create (&parser, context, model);
+		rc = hw_ostc3_parser_create (&parser, context, serial, model);
 		break;
 	case DC_FAMILY_CRESSI_EDY:
 	case DC_FAMILY_ZEAGLE_N2ITION3:
@@ -152,10 +154,10 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
 		rc = atomics_cobalt_parser_create (&parser, context);
 		break;
 	case DC_FAMILY_SHEARWATER_PREDATOR:
-		rc = shearwater_predator_parser_create (&parser, context, model);
+		rc = shearwater_predator_parser_create (&parser, context, model, serial);
 		break;
 	case DC_FAMILY_SHEARWATER_PETREL:
-		rc = shearwater_petrel_parser_create (&parser, context, model);
+		rc = shearwater_petrel_parser_create (&parser, context, model, serial);
 		break;
 	case DC_FAMILY_DIVERITE_NITEKQ:
 		rc = diverite_nitekq_parser_create (&parser, context);
@@ -172,6 +174,12 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
 	case DC_FAMILY_TECDIVING_DIVECOMPUTEREU:
 		rc = tecdiving_divecomputereu_parser_create (&parser, context);
 		break;
+	case DC_FAMILY_GARMIN:
+		rc = garmin_parser_create (&parser, context);
+		break;
+	case DC_FAMILY_DEEPBLU:
+		rc = deepblu_parser_create (&parser, context);
+		break;
 	default:
 		return DC_STATUS_INVALIDARGS;
 	}
@@ -188,7 +196,9 @@ dc_parser_new (dc_parser_t **out, dc_device_t *device)
 		return DC_STATUS_INVALIDARGS;
 
 	return dc_parser_new_internal (out, device->context,
-		dc_device_get_type (device), device->devinfo.model,
+		dc_device_get_type (device),
+		device->devinfo.model,
+		device->devinfo.serial,
 		device->clock.devtime, device->clock.systime);
 }
 
@@ -196,7 +206,9 @@ dc_status_t
 dc_parser_new2 (dc_parser_t **out, dc_context_t *context, dc_descriptor_t *descriptor, unsigned int devtime, dc_ticks_t systime)
 {
 	return dc_parser_new_internal (out, context,
-		dc_descriptor_get_type (descriptor), dc_descriptor_get_model (descriptor),
+		dc_descriptor_get_type (descriptor),
+		dc_descriptor_get_model (descriptor),
+		0,
 		devtime, systime);
 }
 

src/shearwater_petrel.c

@@ -212,28 +212,41 @@ shearwater_petrel_device_foreach (dc_device_t *abstract, dc_dive_callback_t call
 	unsigned int hardware = array_uint_be (dc_buffer_get_data (buffer), dc_buffer_get_size (buffer));
 	unsigned int model = 0;
 	switch (hardware) {
-	case 0x0808: // Petrel 2
+	case 0x0101:
-	case 0x0909: // Petrel 1
+	case 0x0202:
-	case 0x0B0B: // Petrel 1 (newer hardware)
+		model = PREDATOR;
-		model = PETREL;
 		break;
+	case 0x0606:
 	case 0x0A0A: // Nerd 1
 		model = NERD;
 		break;
 	case 0x0E0D: // Nerd 2
 		model = NERD2;
 		break;
-	case 0x0707:
+	case 0x0404:
+	case 0x0909: // Petrel 1
+	case 0x0B0B: // Petrel 1 (newer hardware)
+		model = PETREL;
+		break;
+	case 0x0505:
+	case 0x0808: // Petrel 2
+		model = PETREL;
+		break;
+	case 0x0707: // documentation list 0C0D for both Perdix and Perdix AI :-(
 		model = PERDIX;
 		break;
+	case 0x0C0C:
 	case 0x0C0D:
+	case 0x0D0D:
 		model = PERDIXAI;
 		break;
 	case 0x0F0F:
+	case 0x1F0A:
 		model = TERIC;
 		break;
 	default:
-		WARNING (abstract->context, "Unknown hardware type %04x.", hardware);
+		// return a model of 0 which is unknown
+		WARNING (abstract->context, "Unknown hardware type %04x. Assuming Petrel.", hardware);
 	}
 
 	// Emit a device info event.

src/shearwater_petrel.h

@@ -35,7 +35,7 @@ dc_status_t
 shearwater_petrel_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
 
 dc_status_t
-shearwater_petrel_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model);
+shearwater_petrel_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model, unsigned int serial);
 
 #ifdef __cplusplus
 }

src/shearwater_predator.h

@@ -35,7 +35,7 @@ dc_status_t
 shearwater_predator_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
 
 dc_status_t
-shearwater_predator_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model);
+shearwater_predator_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model, unsigned int serial);
 
 #ifdef __cplusplus
 }

src/shearwater_predator_parser.c

@@ -28,6 +28,7 @@
 #include "context-private.h"
 #include "parser-private.h"
 #include "array.h"
+#include "field-cache.h"
 
 #define ISINSTANCE(parser)	( \
 	dc_parser_isinstance((parser), &shearwater_predator_parser_vtable) || \
@@ -51,6 +52,7 @@
 #define LOG_RECORD_CLOSING_5       0x25
 #define LOG_RECORD_CLOSING_6       0x26
 #define LOG_RECORD_CLOSING_7       0x27
+#define LOG_RECORD_INFO_EVENT      0x30
 #define LOG_RECORD_FINAL           0xFF
 
 #define SZ_BLOCK   0x80
@@ -68,12 +70,15 @@
 #define IMPERIAL 1
 
 #define NGASMIXES 10
+#define MAXSTRINGS 32
 #define NTANKS    2
 #define NRECORDS  8
 
 #define PREDATOR 2
 #define PETREL   3
 
+#define INFO_EVENT_TAG_LOG 38
+
 #define UNDEFINED 0xFFFFFFFF
 
 typedef struct shearwater_predator_parser_t shearwater_predator_parser_t;
@@ -87,6 +92,7 @@ typedef struct shearwater_predator_tank_t {
 	unsigned int enabled;
 	unsigned int beginpressure;
 	unsigned int endpressure;
+	unsigned int battery;
 } shearwater_predator_tank_t;
 
 struct shearwater_predator_parser_t {
@@ -110,10 +116,13 @@ struct shearwater_predator_parser_t {
 	unsigned int tankidx[NTANKS];
 	unsigned int calibrated;
 	double calibration[3];
-	dc_divemode_t mode;
+	unsigned int serial;
 	unsigned int units;
 	unsigned int atmospheric;
 	unsigned int density;
+
+	/* Generic field cache */
+	struct dc_field_cache cache;
 };
 
 static dc_status_t shearwater_predator_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size);
@@ -159,7 +168,7 @@ shearwater_predator_find_gasmix (shearwater_predator_parser_t *parser, unsigned
 
 
 static dc_status_t
-shearwater_common_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model, unsigned int petrel)
+shearwater_common_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model, unsigned int serial, unsigned int petrel)
 {
 	shearwater_predator_parser_t *parser = NULL;
 	const dc_parser_vtable_t *vtable = NULL;
@@ -187,6 +196,9 @@ shearwater_common_parser_create (dc_parser_t **out, dc_context_t *context, unsig
 	parser->model = model;
 	parser->petrel = petrel;
 	parser->samplesize = samplesize;
+	parser->serial = serial;
+
+	// Set the default values.
 	parser->cached = 0;
 	parser->pnf = 0;
 	parser->logversion = 0;
@@ -207,17 +219,19 @@ shearwater_common_parser_create (dc_parser_t **out, dc_context_t *context, unsig
 		parser->tank[i].enabled = 0;
 		parser->tank[i].beginpressure = 0;
 		parser->tank[i].endpressure = 0;
+		parser->tank[i].battery = 0;
 		parser->tankidx[i] = i;
 	}
 	parser->calibrated = 0;
 	for (unsigned int i = 0; i < 3; ++i) {
 		parser->calibration[i] = 0.0;
 	}
-	parser->mode = DC_DIVEMODE_OC;
 	parser->units = METRIC;
 	parser->density = 1025;
 	parser->atmospheric = ATM / (BAR / 1000);
 
+	DC_ASSIGN_FIELD(parser->cache, DIVEMODE, DC_DIVEMODE_OC);
+
 	*out = (dc_parser_t *) parser;
 
 	return DC_STATUS_SUCCESS;
@@ -225,16 +239,16 @@ shearwater_common_parser_create (dc_parser_t **out, dc_context_t *context, unsig
 
 
 dc_status_t
-shearwater_predator_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model)
+shearwater_predator_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model, unsigned int serial)
 {
-	return shearwater_common_parser_create (out, context, model, 0);
+	return shearwater_common_parser_create (out, context, model, serial, 0);
 }
 
 
 dc_status_t
-shearwater_petrel_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model)
+shearwater_petrel_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model, unsigned int serial)
 {
-	return shearwater_common_parser_create (out, context, model, 1);
+	return shearwater_common_parser_create (out, context, model, serial, 1);
 }
 
 
@@ -270,11 +284,12 @@ shearwater_predator_parser_set_data (dc_parser_t *abstract, const unsigned char
 	for (unsigned int i = 0; i < 3; ++i) {
 		parser->calibration[i] = 0.0;
 	}
-	parser->mode = DC_DIVEMODE_OC;
 	parser->units = METRIC;
 	parser->density = 1025;
 	parser->atmospheric = ATM / (BAR / 1000);
 
+	DC_ASSIGN_FIELD(parser->cache, DIVEMODE, DC_DIVEMODE_OC);
+
 	return DC_STATUS_SUCCESS;
 }
 
@@ -300,6 +315,84 @@ shearwater_predator_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *d
 	return DC_STATUS_SUCCESS;
 }
 
+// Show the battery state
+//
+// NOTE! Right now it only shows the most serious bit
+// but the code is set up so that we could perhaps
+// indicate that the battery is on the edge (ie it
+// reported both "normal" _and_ "warning" during the
+// dive - maybe that would be a "starting to warn")
+//
+// We could also report unpaired and comm errors.
+static void
+add_battery_info(shearwater_predator_parser_t *parser, const char *desc, unsigned int state)
+{
+	// We don't know what other state bits than 0-2 mean
+	state &= 7;
+	if (state >= 1 && state <= 7) {
+		static const char *states[8] = {
+			"",		// 000 - No state bits, not used
+			"normal",	// 001 - only normal
+			"critical",	// 010 - only critical
+			"critical",	// 011 - both normal and critical
+			"warning",	// 100 - only warning
+			"warning",	// 101 - normal and warning
+			"critical",	// 110 - warning and critical
+			"critical",	// 111 - normal, warning and critical
+		};
+		dc_field_add_string(&parser->cache, desc, states[state]);
+	}
+}
+
+static void
+add_deco_model(shearwater_predator_parser_t *parser, const unsigned char *data)
+{
+	unsigned int idx_deco_model = parser->pnf ? parser->opening[2] + 18 : 67;
+	unsigned int idx_gfs = parser->pnf ? parser->opening[3] + 5 : 85;
+
+	switch	(data[idx_deco_model]) {
+	case 0:
+		dc_field_add_string_fmt(&parser->cache, "Deco model", "GF %u/%u", data[4], data[5]);
+		break;
+	case 1:
+		dc_field_add_string_fmt(&parser->cache, "Deco model", "VPM-B +%u", data[idx_deco_model + 1]);
+		break;
+	case 2:
+		dc_field_add_string_fmt(&parser->cache, "Deco model", "VPM-B/GFS +%u %u%%", data[idx_deco_model + 1], data[idx_gfs]);
+		break;
+	default:
+		dc_field_add_string_fmt(&parser->cache, "Deco model", "Unknown model %d", data[idx_deco_model]);
+	}
+}
+
+static void
+add_battery_type(shearwater_predator_parser_t *parser, const unsigned char *data)
+{
+	if (parser->logversion < 7)
+		return;
+
+	unsigned int idx_battery_type = parser->pnf ? parser->opening[4] + 9 : 120;
+	switch (data[idx_battery_type]) {
+	case 1:
+		dc_field_add_string(&parser->cache, "Battery type", "1.5V Alkaline");
+		break;
+	case 2:
+		dc_field_add_string(&parser->cache, "Battery type", "1.5V Lithium");
+		break;
+	case 3:
+		dc_field_add_string(&parser->cache, "Battery type", "1.2V NiMH");
+		break;
+	case 4:
+		dc_field_add_string(&parser->cache, "Battery type", "3.6V Saft");
+		break;
+	case 5:
+		dc_field_add_string(&parser->cache, "Battery type", "3.7V Li-Ion");
+		break;
+	default:
+		dc_field_add_string_fmt(&parser->cache, "Battery type", "unknown type %d", data[idx_battery_type]);
+		break;
+	}
+}
 
 static dc_status_t
 shearwater_predator_parser_cache (shearwater_predator_parser_t *parser)
@@ -311,6 +404,7 @@ shearwater_predator_parser_cache (shearwater_predator_parser_t *parser)
 	if (parser->cached) {
 		return DC_STATUS_SUCCESS;
 	}
+	memset(&parser->cache, 0, sizeof(parser->cache));
 
 	// Log versions before 6 weren't reliably stored in the data, but
 	// 6 is also the oldest version that we assume in our code
@@ -432,13 +526,16 @@ shearwater_predator_parser_cache (shearwater_predator_parser_t *parser)
 					// bits the tank pressure in units of 2 psi.
 					unsigned int pressure = array_uint16_be (data + offset + pnf + idx[i]);
 					if (pressure < 0xFFF0) {
+						unsigned int battery = 1u << (pressure >> 12);
 						pressure &= 0x0FFF;
 						if (!tank[i].enabled) {
 							tank[i].enabled = 1;
 							tank[i].beginpressure = pressure;
 							tank[i].endpressure = pressure;
+							tank[i].battery = 0;
 						}
 						tank[i].endpressure = pressure;
+						tank[i].battery |= battery;
 					}
 				}
 			}
@@ -472,6 +569,8 @@ shearwater_predator_parser_cache (shearwater_predator_parser_t *parser)
 		}
 	}
 
+	dc_field_add_string_fmt(&parser->cache, "Logversion", "%d%s", logversion, pnf ? "(PNF)" : "");
+
 	// Cache sensor calibration for later use
 	unsigned int nsensors = 0, ndefaults = 0;
 	unsigned int base = parser->opening[3] + (pnf ? 6 : 86);
@@ -500,8 +599,12 @@ shearwater_predator_parser_cache (shearwater_predator_parser_t *parser)
 		// uncalibrated).
 		WARNING (abstract->context, "Disabled all O2 sensors due to a default calibration value.");
 		parser->calibrated = 0;
+		if (mode != DC_DIVEMODE_OC)
+			dc_field_add_string(&parser->cache, "PPO2 source", "voted/averaged");
 	} else {
 		parser->calibrated = data[base];
+		if (mode != DC_DIVEMODE_OC)
+			dc_field_add_string(&parser->cache, "PPO2 source", "cells");
 	}
 
 	// Cache the data for later use.
@@ -523,12 +626,22 @@ shearwater_predator_parser_cache (shearwater_predator_parser_t *parser)
 			parser->tankidx[i] = UNDEFINED;
 		}
 	}
-	parser->mode = mode;
 	parser->units = data[parser->opening[0] + 8];
 	parser->atmospheric = array_uint16_be (data + parser->opening[1] + (parser->pnf ? 16 : 47));
 	parser->density = array_uint16_be (data + parser->opening[3] + (parser->pnf ? 3 : 83));
 	parser->cached = 1;
 
+	DC_ASSIGN_FIELD(parser->cache, DIVEMODE, mode);
+
+	dc_field_add_string_fmt(&parser->cache, "Serial", "%08x", parser->serial);
+	// bytes 1-31 are identical in all formats
+	dc_field_add_string_fmt(&parser->cache, "FW Version", "%2x", data[19]);
+	add_deco_model(parser, data);
+	add_battery_type(parser, data);
+	dc_field_add_string_fmt(&parser->cache, "Battery at end", "%.1f V", data[9] / 10.0);
+	add_battery_info(parser, "T1 battery", tank[0].battery);
+	add_battery_info(parser, "T2 battery", tank[1].battery);
+
 	return DC_STATUS_SUCCESS;
 }
 
@@ -547,6 +660,7 @@ shearwater_predator_parser_get_field (dc_parser_t *abstract, dc_field_type_t typ
 	dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
 	dc_tank_t *tank = (dc_tank_t *) value;
 	dc_salinity_t *water = (dc_salinity_t *) value;
+	dc_field_string_t *string = (dc_field_string_t *) value;
 
 	if (value) {
 		switch (type) {
@@ -594,8 +708,9 @@ shearwater_predator_parser_get_field (dc_parser_t *abstract, dc_field_type_t typ
 			*((double *) value) = parser->atmospheric / 1000.0;
 			break;
 		case DC_FIELD_DIVEMODE:
-			*((dc_divemode_t *) value) = parser->mode;
+			return DC_FIELD_VALUE(parser->cache, value, DIVEMODE);
-			break;
+		case DC_FIELD_STRING:
+			return dc_field_get_string(&parser->cache, flags, string);
 		default:
 			return DC_STATUS_UNSUPPORTED;
 		}
@@ -639,6 +754,41 @@ shearwater_predator_parser_samples_foreach (dc_parser_t *abstract, dc_sample_cal
 	while (offset + parser->samplesize <= length) {
 		dc_sample_value_t sample = {0};
 
+		// stop parsing if we see the end block
+		if (pnf && data[offset] == LOG_RECORD_FINAL && data[offset + 1] == 0xFD)
+			break;
+
+		if (pnf && data[offset] == LOG_RECORD_INFO_EVENT) {
+			// additional events defined in PNF
+			INFO(abstract->context, "PNF INFO_EVENT ID %u time %u W1 %u W2 %u", data[offset + 1],
+											    array_uint32_be (data + offset + 4),
+											    array_uint32_be (data + offset + 8),
+											    array_uint32_be (data + offset + 12));
+			if (data[offset + 1] == INFO_EVENT_TAG_LOG) {
+				// this is a TAG
+				// its time is a unix timestamp, so we need to subtract the dive start time
+				unsigned int tag_time = array_uint32_be (data + offset + 4) - array_uint32_be (data + parser->opening[0] + 12);
+				unsigned int tag_heading = array_uint32_be (data + offset + 8);
+				unsigned int tag_type = array_uint32_be (data + offset + 12);
+				// heading is only valid if 0..360
+				// type is only valid if 0..5
+				if (tag_heading <= 360 && tag_type <= 5) {
+					// encode this as a bookmark event, using the flags to capture the type and value for heading
+					sample.event.type = SAMPLE_EVENT_BOOKMARK;
+					sample.event.time = tag_time;
+					sample.event.flags = (tag_type + 1) << SAMPLE_FLAGS_TYPE_SHIFT; // 0 means it isn't a tag
+					sample.event.value = tag_heading;
+					if (callback) callback (DC_SAMPLE_EVENT, sample, userdata);
+				}
+			}
+			offset += parser->samplesize;
+			continue;
+		}
+		// Ignore blocks that aren't dive samples
+		if (pnf && data[offset] != LOG_RECORD_DIVE_SAMPLE) {
+			offset += parser->samplesize;
+			continue;
+		}
 		// Ignore empty samples.
 		if (array_isequal (data + offset, parser->samplesize, 0x00)) {
 			offset += parser->samplesize;
@@ -683,19 +833,19 @@ shearwater_predator_parser_samples_foreach (dc_parser_t *abstract, dc_sample_cal
 			if ((status & OC) == 0) {
 				// PPO2
 				if ((status & PPO2_EXTERNAL) == 0) {
-#ifdef SENSOR_AVERAGE
+					if (!parser->calibrated) {
-					sample.ppo2 = data[offset + pnf + 6] / 100.0;
+						sample.ppo2 = data[offset + pnf + 6] / 100.0;
-					if (callback) callback (DC_SAMPLE_PPO2, sample, userdata);
+						if (callback) callback (DC_SAMPLE_PPO2, sample, userdata);
-#else
+					} else {
-					sample.ppo2 = data[offset + pnf + 12] * parser->calibration[0];
+						sample.ppo2 = data[offset + pnf + 12] * parser->calibration[0];
-					if (callback && (parser->calibrated & 0x01)) callback (DC_SAMPLE_PPO2, sample, userdata);
+						if (callback && (parser->calibrated & 0x01)) callback (DC_SAMPLE_PPO2, sample, userdata);
 
-					sample.ppo2 = data[offset + pnf + 14] * parser->calibration[1];
+						sample.ppo2 = data[offset + pnf + 14] * parser->calibration[1];
-					if (callback && (parser->calibrated & 0x02)) callback (DC_SAMPLE_PPO2, sample, userdata);
+						if (callback && (parser->calibrated & 0x02)) callback (DC_SAMPLE_PPO2, sample, userdata);
 
-					sample.ppo2 = data[offset + pnf + 15] * parser->calibration[2];
+						sample.ppo2 = data[offset + pnf + 15] * parser->calibration[2];
-					if (callback && (parser->calibrated & 0x04)) callback (DC_SAMPLE_PPO2, sample, userdata);
+						if (callback && (parser->calibrated & 0x04)) callback (DC_SAMPLE_PPO2, sample, userdata);
-#endif
+					}
 				}
 
 				// Setpoint
@@ -815,6 +965,5 @@ shearwater_predator_parser_samples_foreach (dc_parser_t *abstract, dc_sample_cal
 
 		offset += parser->samplesize;
 	}
-
 	return DC_STATUS_SUCCESS;
 }

src/suunto_d9.h

@@ -36,7 +36,7 @@ dc_status_t
 suunto_d9_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream, unsigned int model);
 
 dc_status_t
-suunto_d9_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model);
+suunto_d9_parser_create (dc_parser_t **parser, dc_context_t *context, unsigned int model, unsigned int serial);
 
 #ifdef __cplusplus
 }

src/suunto_d9_parser.c

@@ -20,7 +20,8 @@
  */
 
 #include <stdlib.h>
-#include <string.h>	// memcmp
+#include <string.h>	// memcmp, strdup
+#include <stdio.h>	// snprintf
 
 #include "suunto_d9.h"
 #include "context-private.h"
@@ -72,6 +73,7 @@ typedef struct suunto_d9_parser_t suunto_d9_parser_t;
 struct suunto_d9_parser_t {
 	dc_parser_t base;
 	unsigned int model;
+	unsigned int serial;
 	// Cached fields.
 	unsigned int cached;
 	unsigned int id;
@@ -244,7 +246,7 @@ suunto_d9_parser_cache (suunto_d9_parser_t *parser)
 }
 
 dc_status_t
-suunto_d9_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model)
+suunto_d9_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model, unsigned int serial)
 {
 	suunto_d9_parser_t *parser = NULL;
 
@@ -260,6 +262,7 @@ suunto_d9_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int
 
 	// Set the default values.
 	parser->model = model;
+	parser->serial = serial;
 	parser->cached = 0;
 	parser->id = 0;
 	parser->mode = AIR;
@@ -343,6 +346,7 @@ suunto_d9_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime)
 	return DC_STATUS_SUCCESS;
 }
 
+#define BUFLEN 16
 
 static dc_status_t
 suunto_d9_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value)
@@ -358,6 +362,9 @@ suunto_d9_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigne
 		return rc;
 
 	dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
+	dc_field_string_t *string = (dc_field_string_t *) value;
+
+	char buf[BUFLEN];
 
 	if (value) {
 		switch (type) {
@@ -405,6 +412,17 @@ suunto_d9_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigne
 				return DC_STATUS_DATAFORMAT;
 			}
 			break;
+		case DC_FIELD_STRING:
+			switch (flags) {
+			case 0: /* serial */
+				string->desc = "Serial";
+				snprintf(buf, BUFLEN, "%08u", parser->serial);
+				break;
+			default:
+				return DC_STATUS_UNSUPPORTED;
+			}
+			string->value = strdup(buf);
+			break;
 		default:
 			return DC_STATUS_UNSUPPORTED;
 		}

src/suunto_eonsteel.c

@@ -641,12 +641,35 @@ read_file(suunto_eonsteel_device_t *eon, const char *filename, dc_buffer_t *buf)
 	return DC_STATUS_SUCCESS;
 }
 
+/*
+ * Insert a directory entry in the sorted list, most recent entry
+ * first.
+ *
+ * The directory entry names are the timestamps as hex, so ordering
+ * in alphabetical order ends up also ordering in date order!
+ */
+static struct directory_entry *insert_dirent(struct directory_entry *entry, struct directory_entry *list)
+{
+	struct directory_entry **pos = &list, *next;
+
+	while ((next = *pos) != NULL) {
+		/* Is this bigger (more recent) than the next entry? We're good! */
+		if (strcmp(entry->name, next->name) > 0)
+			break;
+		pos = &next->next;
+	}
+	entry->next = next;
+	*pos = entry;
+
+	return list;
+}
+
 /*
  * NOTE! This will create the list of dirent's in reverse order,
  * with the last dirent first. That's intentional: for dives,
  * we will want to look up the last dive first.
  */
-static struct directory_entry *parse_dirent(suunto_eonsteel_device_t *eon, int nr, const unsigned char *p, unsigned int len, struct directory_entry *old)
+static struct directory_entry *parse_dirent(suunto_eonsteel_device_t *eon, int nr, const unsigned char *p, unsigned int len, struct directory_entry *list)
 {
 	while (len > 8) {
 		unsigned int type = array_uint32_le(p);
@@ -667,10 +690,9 @@ static struct directory_entry *parse_dirent(suunto_eonsteel_device_t *eon, int n
 			ERROR(eon->base.context, "out of memory");
 			break;
 		}
-		entry->next = old;
+		list = insert_dirent(entry, list);
-		old = entry;
 	}
-	return old;
+	return list;
 }
 
 static dc_status_t
@@ -731,6 +753,19 @@ get_file_list(suunto_eonsteel_device_t *eon, struct directory_entry **res)
 	return DC_STATUS_SUCCESS;
 }
 
+static int
+count_file_list(struct directory_entry *list)
+{
+	int count = 0;
+
+	while (list) {
+		count++;
+		list = list->next;
+	}
+
+	return count;
+}
+
 dc_status_t
 suunto_eonsteel_device_open(dc_device_t **out, dc_context_t *context, dc_iostream_t *iostream, unsigned int model)
 {
@@ -802,7 +837,6 @@ suunto_eonsteel_device_foreach(dc_device_t *abstract, dc_dive_callback_t callbac
 	dc_buffer_t *file;
 	char pathname[64];
 	unsigned int time;
-	unsigned int count = 0;
 	dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
 
 	// Emit a device info event.
@@ -820,46 +854,17 @@ suunto_eonsteel_device_foreach(dc_device_t *abstract, dc_dive_callback_t callbac
 		return DC_STATUS_SUCCESS;
 	}
 
-	// Locate the most recent dive.
-	// The filename represent the time of the dive, encoded as a hexadecimal
-	// number. Thus the most recent dive can be found by simply sorting the
-	// filenames alphabetically.
-	struct directory_entry *head = de, *tail = de, *latest = de;
-	while (de) {
-		if (strcmp (de->name, latest->name) > 0) {
-			latest = de;
-		}
-		tail = de;
-		count++;
-		de = de->next;
-	}
-
-	// Make the most recent dive the head of the list.
-	// The linked list is made circular, by attaching the head to the tail and
-	// then cut open again just before the most recent dive.
-	de = head;
-	while (de) {
-		if (de->next == latest) {
-			de->next = NULL;
-			tail->next = head;
-			break;
-		}
-
-		de = de->next;
-	}
-
 	file = dc_buffer_new (16384);
 	if (file == NULL) {
 		ERROR (abstract->context, "Insufficient buffer space available.");
-		file_list_free (latest);
+		file_list_free(de);
 		return DC_STATUS_NOMEMORY;
 	}
 
-	progress.maximum = count;
+	progress.maximum = count_file_list(de);
 	progress.current = 0;
 	device_event_emit(abstract, DC_EVENT_PROGRESS, &progress);
 
-	de = latest;
 	while (de) {
 		int len;
 		struct directory_entry *next = de->next;

src/suunto_eonsteel_parser.c

@@ -29,6 +29,7 @@
 #include "parser-private.h"
 #include "array.h"
 #include "platform.h"
+#include "field-cache.h"
 
 #define C_ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
 
@@ -70,38 +71,15 @@ struct type_desc {
 };
 
 #define MAXTYPE 512
-#define MAXGASES 16
 
 typedef struct suunto_eonsteel_parser_t {
 	dc_parser_t base;
 	struct type_desc type_desc[MAXTYPE];
-	// field cache
+	struct dc_field_cache cache;
-	struct {
-		unsigned int initialized;
-		unsigned int divetime;
-		double maxdepth;
-		double avgdepth;
-		unsigned int ngases;
-		dc_gasmix_t gasmix[MAXGASES];
-		dc_salinity_t salinity;
-		double surface_pressure;
-		dc_divemode_t divemode;
-		double lowsetpoint;
-		double highsetpoint;
-		double customsetpoint;
-		dc_tankvolume_t tankinfo[MAXGASES];
-		double tanksize[MAXGASES];
-		double tankworkingpressure[MAXGASES];
-	} cache;
 } suunto_eonsteel_parser_t;
 
 typedef int (*eon_data_cb_t)(unsigned short type, const struct type_desc *desc, const unsigned char *data, int len, void *user);
 
-typedef struct eon_event_t {
-	const char *name;
-	parser_sample_event_t type;
-} eon_event_t;
-
 static const struct {
 	const char *name;
 	enum eon_sample type;
@@ -167,16 +145,6 @@ static enum eon_sample lookup_descriptor_type(suunto_eonsteel_parser_t *eon, str
 	return ES_none;
 }
 
-static parser_sample_event_t lookup_event(const char *name, const eon_event_t events[], size_t n)
-{
-	for (size_t i = 0; i < n; ++i) {
-		if (!strcasecmp(name, events[i].name))
-			return events[i].type;
-	}
-
-	return SAMPLE_EVENT_NONE;
-}
-
 static const char *desc_type_name(enum eon_sample type)
 {
 	int i;
@@ -468,8 +436,6 @@ struct sample_data {
 
 	/* We gather up deco and cylinder pressure information */
 	int gasnr;
-	int tts, ndl;
-	double ceiling;
 };
 
 static void sample_time(struct sample_data *info, unsigned short time_delta)
@@ -507,7 +473,6 @@ static void sample_ndl(struct sample_data *info, short ndl)
 {
 	dc_sample_value_t sample = {0};
 
-	info->ndl = ndl;
 	if (ndl < 0)
 		return;
 
@@ -518,14 +483,27 @@ static void sample_ndl(struct sample_data *info, short ndl)
 
 static void sample_tts(struct sample_data *info, unsigned short tts)
 {
-	if (tts != 0xffff)
+	if (tts != 0xffff) {
-		info->tts = tts;
+		dc_sample_value_t sample = {0};
+		sample.time = tts;
+		if (info->callback) info->callback(DC_SAMPLE_TTS, sample, info->userdata);
+	}
 }
 
 static void sample_ceiling(struct sample_data *info, unsigned short ceiling)
 {
-	if (ceiling != 0xffff)
+	if (ceiling != 0xffff) {
-		info->ceiling = ceiling / 100.0;
+		dc_sample_value_t sample = {0};
+
+		// We don't actually have a time for the
+		// deco stop, we just have a ceiling.
+		//
+		// We'll just say it's one minute.
+		sample.deco.type = DC_DECO_DECOSTOP;
+		sample.deco.time = ceiling ? 60 : 0;
+		sample.deco.depth = ceiling / 100.0;
+		if (info->callback) info->callback(DC_SAMPLE_DECO, sample, info->userdata);
+	}
 }
 
 static void sample_heading(struct sample_data *info, unsigned short heading)
@@ -597,7 +575,7 @@ static void sample_gas_switch_event(struct sample_data *info, unsigned short idx
 	suunto_eonsteel_parser_t *eon = info->eon;
 	dc_sample_value_t sample = {0};
 
-	if (idx < 1 || idx > eon->cache.ngases)
+	if (idx < 1 || idx > eon->cache.GASMIX_COUNT)
 		return;
 
 	sample.gasmix = idx - 1;
@@ -681,26 +659,17 @@ static void sample_event_state_type(const struct type_desc *desc, struct sample_
 static void sample_event_state_value(const struct type_desc *desc, struct sample_data *info, unsigned char value)
 {
 	dc_sample_value_t sample = {0};
-	static const eon_event_t states[] = {
-		{"Wet Outside",                SAMPLE_EVENT_NONE},
-		{"Below Wet Activation Depth", SAMPLE_EVENT_NONE},
-		{"Below Surface",              SAMPLE_EVENT_NONE},
-		{"Dive Active",                SAMPLE_EVENT_NONE},
-		{"Surface Calculation",        SAMPLE_EVENT_NONE},
-		{"Tank pressure available",    SAMPLE_EVENT_NONE},
-		{"Closed Circuit Mode",        SAMPLE_EVENT_NONE},
-	};
 	const char *name;
 
 	name = info->state_type;
 	if (!name)
 		return;
 
-	sample.event.type = lookup_event(name, states, C_ARRAY_SIZE(states));
+	sample.event.type = SAMPLE_EVENT_STRING;
-	if (sample.event.type == SAMPLE_EVENT_NONE)
+	sample.event.name = name;
-		return;
-
 	sample.event.flags = value ? SAMPLE_FLAGS_BEGIN : SAMPLE_FLAGS_END;
+	sample.event.flags |= 1 << SAMPLE_FLAGS_SEVERITY_SHIFT;
+
 	if (info->callback) info->callback(DC_SAMPLE_EVENT, sample, info->userdata);
 }
 
@@ -712,25 +681,6 @@ static void sample_event_notify_type(const struct type_desc *desc, struct sample
 
 static void sample_event_notify_value(const struct type_desc *desc, struct sample_data *info, unsigned char value)
 {
-	static const eon_event_t notifications[] = {
-		{"NoFly Time",         SAMPLE_EVENT_NONE},
-		{"Depth",              SAMPLE_EVENT_NONE},
-		{"Surface Time",       SAMPLE_EVENT_NONE},
-		{"Tissue Level",       SAMPLE_EVENT_TISSUELEVEL},
-		{"Deco",               SAMPLE_EVENT_NONE},
-		{"Deco Window",        SAMPLE_EVENT_NONE},
-		{"Safety Stop Ahead",  SAMPLE_EVENT_NONE},
-		{"Safety Stop",        SAMPLE_EVENT_SAFETYSTOP},
-		{"Safety Stop Broken", SAMPLE_EVENT_CEILING_SAFETYSTOP},
-		{"Deep Stop Ahead",    SAMPLE_EVENT_NONE},
-		{"Deep Stop",          SAMPLE_EVENT_DEEPSTOP},
-		{"Dive Time",          SAMPLE_EVENT_DIVETIME},
-		{"Gas Available",      SAMPLE_EVENT_NONE},
-		{"SetPoint Switch",    SAMPLE_EVENT_NONE},
-		{"Diluent Hypoxia",    SAMPLE_EVENT_NONE},
-		{"Air Time",           SAMPLE_EVENT_NONE},
-		{"Tank Pressure",      SAMPLE_EVENT_NONE},
-	};
 	dc_sample_value_t sample = {0};
 	const char *name;
 
@@ -738,11 +688,11 @@ static void sample_event_notify_value(const struct type_desc *desc, struct sampl
 	if (!name)
 		return;
 
-	sample.event.type = lookup_event(name, notifications, C_ARRAY_SIZE(notifications));
+	sample.event.type = SAMPLE_EVENT_STRING;
-	if (sample.event.type == SAMPLE_EVENT_NONE)
+	sample.event.name = name;
-		return;
-
 	sample.event.flags = value ? SAMPLE_FLAGS_BEGIN : SAMPLE_FLAGS_END;
+	sample.event.flags |= 2 << SAMPLE_FLAGS_SEVERITY_SHIFT;
+
 	if (info->callback) info->callback(DC_SAMPLE_EVENT, sample, info->userdata);
 }
 
@@ -755,22 +705,6 @@ static void sample_event_warning_type(const struct type_desc *desc, struct sampl
 
 static void sample_event_warning_value(const struct type_desc *desc, struct sample_data *info, unsigned char value)
 {
-	static const eon_event_t warnings[] = {
-		{"ICD Penalty",           SAMPLE_EVENT_NONE},
-		{"Deep Stop Penalty",     SAMPLE_EVENT_VIOLATION},
-		{"Mandatory Safety Stop", SAMPLE_EVENT_SAFETYSTOP_MANDATORY},
-		{"OTU250",                SAMPLE_EVENT_NONE},
-		{"OTU300",                SAMPLE_EVENT_NONE},
-		{"CNS80%",                SAMPLE_EVENT_NONE},
-		{"CNS100%",               SAMPLE_EVENT_NONE},
-		{"Max.Depth",             SAMPLE_EVENT_MAXDEPTH},
-		{"Air Time",              SAMPLE_EVENT_AIRTIME},
-		{"Tank Pressure",         SAMPLE_EVENT_NONE},
-		{"Safety Stop Broken",    SAMPLE_EVENT_CEILING_SAFETYSTOP},
-		{"Deep Stop Broken",      SAMPLE_EVENT_CEILING_SAFETYSTOP},
-		{"Ceiling Broken",        SAMPLE_EVENT_CEILING},
-		{"PO2 High",              SAMPLE_EVENT_PO2},
-	};
 	dc_sample_value_t sample = {0};
 	const char *name;
 
@@ -778,11 +712,11 @@ static void sample_event_warning_value(const struct type_desc *desc, struct samp
 	if (!name)
 		return;
 
-	sample.event.type = lookup_event(name, warnings, C_ARRAY_SIZE(warnings));
+	sample.event.type = SAMPLE_EVENT_STRING;
-	if (sample.event.type == SAMPLE_EVENT_NONE)
+	sample.event.name = name;
-		return;
-
 	sample.event.flags = value ? SAMPLE_FLAGS_BEGIN : SAMPLE_FLAGS_END;
+	sample.event.flags |= 3 << SAMPLE_FLAGS_SEVERITY_SHIFT;
+
 	if (info->callback) info->callback(DC_SAMPLE_EVENT, sample, info->userdata);
 }
 
@@ -795,27 +729,18 @@ static void sample_event_alarm_type(const struct type_desc *desc, struct sample_
 
 static void sample_event_alarm_value(const struct type_desc *desc, struct sample_data *info, unsigned char value)
 {
-	static const eon_event_t alarms[] = {
-		{"Mandatory Safety Stop Broken", SAMPLE_EVENT_CEILING_SAFETYSTOP},
-		{"Ascent Speed",                 SAMPLE_EVENT_ASCENT},
-		{"Diluent Hyperoxia",            SAMPLE_EVENT_NONE},
-		{"Violated Deep Stop",           SAMPLE_EVENT_VIOLATION},
-		{"Ceiling Broken",               SAMPLE_EVENT_CEILING},
-		{"PO2 High",                     SAMPLE_EVENT_PO2},
-		{"PO2 Low",                      SAMPLE_EVENT_PO2},
-	};
-	dc_sample_value_t sample = {0};
 	const char *name;
+	dc_sample_value_t sample = {0};
 
 	name = info->alarm_type;
 	if (!name)
 		return;
 
-	sample.event.type = lookup_event(name, alarms, C_ARRAY_SIZE(alarms));
+	sample.event.type = SAMPLE_EVENT_STRING;
-	if (sample.event.type == SAMPLE_EVENT_NONE)
+	sample.event.name = name;
-		return;
-
 	sample.event.flags = value ? SAMPLE_FLAGS_BEGIN : SAMPLE_FLAGS_END;
+	sample.event.flags |= 4 << SAMPLE_FLAGS_SEVERITY_SHIFT;
+
 	if (info->callback) info->callback(DC_SAMPLE_EVENT, sample, info->userdata);
 }
 
@@ -976,10 +901,6 @@ static int traverse_samples(unsigned short type, const struct type_desc *desc, c
 	if (desc->size > len)
 		ERROR(eon->base.context, "Got %d bytes of data for '%s' that wants %d bytes", len, desc->desc, desc->size);
 
-	info->ndl = -1;
-	info->tts = 0;
-	info->ceiling = 0.0;
-
 	for (i = 0; i < EON_MAX_GROUP; i++) {
 		enum eon_sample type = desc->type[i];
 		int bytes = handle_sample_type(desc, info, type, data);
@@ -995,15 +916,6 @@ static int traverse_samples(unsigned short type, const struct type_desc *desc, c
 		used += bytes;
 	}
 
-	if (info->ndl < 0 && (info->tts || info->ceiling)) {
-		dc_sample_value_t sample = {0};
-
-		sample.deco.type = DC_DECO_DECOSTOP;
-		sample.deco.time = info->tts;
-		sample.deco.depth = info->ceiling;
-		if (info->callback) info->callback(DC_SAMPLE_DECO, sample, info->userdata);
-	}
-
 	// Warn if there are left-over bytes for something we did use part of
 	if (used && len)
 		ERROR(eon->base.context, "Entry for '%s' had %d bytes, only used %d", desc->desc, len+used, used);
@@ -1026,11 +938,6 @@ suunto_eonsteel_parser_samples_foreach(dc_parser_t *abstract, dc_sample_callback
 	return DC_STATUS_SUCCESS;
 }
 
-// Ugly define thing makes the code much easier to read
-// I'd love to use __typeof__, but that's a gcc'ism
-#define field_value(p, set) \
-	memcpy((p), &(set), sizeof(set))
-
 static dc_status_t
 suunto_eonsteel_parser_get_field(dc_parser_t *parser, dc_field_type_t type, unsigned int flags, void *value)
 {
@@ -1043,33 +950,27 @@ suunto_eonsteel_parser_get_field(dc_parser_t *parser, dc_field_type_t type, unsi
 
 	switch (type) {
 	case DC_FIELD_DIVETIME:
-		field_value(value, eon->cache.divetime);
+		return DC_FIELD_VALUE(eon->cache, value, DIVETIME);
-		break;
 	case DC_FIELD_MAXDEPTH:
-		field_value(value, eon->cache.maxdepth);
+		return DC_FIELD_VALUE(eon->cache, value, MAXDEPTH);
-		break;
 	case DC_FIELD_AVGDEPTH:
-		field_value(value, eon->cache.avgdepth);
+		return DC_FIELD_VALUE(eon->cache, value, AVGDEPTH);
-		break;
 	case DC_FIELD_GASMIX_COUNT:
 	case DC_FIELD_TANK_COUNT:
-		field_value(value, eon->cache.ngases);
+		return DC_FIELD_VALUE(eon->cache, value, GASMIX_COUNT);
-		break;
 	case DC_FIELD_GASMIX:
 		if (flags >= MAXGASES)
 			return DC_STATUS_UNSUPPORTED;
-		field_value(value, eon->cache.gasmix[flags]);
+		return DC_FIELD_INDEX(eon->cache, value, GASMIX, flags);
-		break;
 	case DC_FIELD_SALINITY:
-		field_value(value, eon->cache.salinity);
+		return DC_FIELD_VALUE(eon->cache, value, SALINITY);
-		break;
 	case DC_FIELD_ATMOSPHERIC:
-		field_value(value, eon->cache.surface_pressure);
+		return DC_FIELD_VALUE(eon->cache, value, ATMOSPHERIC);
-		break;
 	case DC_FIELD_DIVEMODE:
-		field_value(value, eon->cache.divemode);
+		return DC_FIELD_VALUE(eon->cache, value, DIVEMODE);
-		break;
 	case DC_FIELD_TANK:
+		if (flags >= MAXGASES)
+			return DC_STATUS_UNSUPPORTED;
 		/*
 		 * Sadly it seems that the EON Steel doesn't tell us whether
 		 * we get imperial or metric data - the only indication is
@@ -1094,11 +995,13 @@ suunto_eonsteel_parser_get_field(dc_parser_t *parser, dc_field_type_t type, unsi
 		 * We need to have workpressure and a valid tank. In that case,
 		 * a fractional tank size implies imperial.
 		 */
-		if (tank->workpressure && (tank->type == DC_TANKVOLUME_METRIC)) {
+		if (tank->workpressure && (tank->type & DC_TANKINFO_METRIC)) {
 			if (fabs(tank->volume - rint(tank->volume)) > 0.001)
-				tank->type = DC_TANKVOLUME_IMPERIAL;
+				tank->type += DC_TANKINFO_IMPERIAL - DC_TANKINFO_METRIC;
 		}
 		break;
+	case DC_FIELD_STRING:
+		return dc_field_get_string(&eon->cache, flags, (dc_field_string_t *)value);
 	default:
 		return DC_STATUS_UNSUPPORTED;
 	}
@@ -1127,7 +1030,7 @@ suunto_eonsteel_parser_get_datetime(dc_parser_t *parser, dc_datetime_t *datetime
 // time in ms
 static void add_time_field(suunto_eonsteel_parser_t *eon, unsigned short time_delta_ms)
 {
-	eon->cache.divetime += time_delta_ms;
+	eon->cache.DIVETIME += time_delta_ms;
 }
 
 // depth in cm
@@ -1135,8 +1038,8 @@ static void set_depth_field(suunto_eonsteel_parser_t *eon, unsigned short d)
 {
 	if (d != 0xffff) {
 		double depth = d / 100.0;
-		if (depth > eon->cache.maxdepth)
+		if (depth > eon->cache.MAXDEPTH)
-			eon->cache.maxdepth = depth;
+			eon->cache.MAXDEPTH = depth;
 		eon->cache.initialized |= 1 << DC_FIELD_MAXDEPTH;
 	}
 }
@@ -1149,28 +1052,28 @@ static void set_depth_field(suunto_eonsteel_parser_t *eon, unsigned short d)
 //   "enum:0=Off,1=Primary,2=?,3=Diluent"
 //   "enum:0=Off,1=Primary,3=Diluent,4=Oxygen"
 //
-// We turn that into the DC_TANKVOLUME data here, but
+// We turn that into the DC_TANKINFO data here, but
 // initially consider all non-off tanks to me METRIC.
 //
 // We may later turn the METRIC tank size into IMPERIAL if we
 // get a working pressure and non-integral size
-static int add_gas_type(suunto_eonsteel_parser_t *eon, const struct type_desc *desc, unsigned char type)
+static dc_status_t add_gas_type(suunto_eonsteel_parser_t *eon, const struct type_desc *desc, unsigned char type)
 {
-	int idx = eon->cache.ngases;
+	int idx = eon->cache.GASMIX_COUNT;
-	dc_tankvolume_t tankinfo = DC_TANKVOLUME_METRIC;
+	dc_tankinfo_t tankinfo = DC_TANKINFO_METRIC;
 	char *name;
 
 	if (idx >= MAXGASES)
-		return 0;
+		return DC_STATUS_SUCCESS;
 
-	eon->cache.ngases = idx+1;
+	eon->cache.GASMIX_COUNT = idx+1;
 	name = lookup_enum(desc, type);
 	if (!name)
 		DEBUG(eon->base.context, "Unable to look up gas type %u in %s", type, desc->format);
 	else if (!strcasecmp(name, "Diluent"))
-		;
+		tankinfo |= DC_TANKINFO_CC_DILUENT;
 	else if (!strcasecmp(name, "Oxygen"))
-		;
+		tankinfo |= DC_TANKINFO_CC_O2;
 	else if (!strcasecmp(name, "None"))
 		tankinfo = DC_TANKVOLUME_NONE;
 	else if (strcasecmp(name, "Primary"))
@@ -1181,46 +1084,46 @@ static int add_gas_type(suunto_eonsteel_parser_t *eon, const struct type_desc *d
 	eon->cache.initialized |= 1 << DC_FIELD_GASMIX_COUNT;
 	eon->cache.initialized |= 1 << DC_FIELD_TANK_COUNT;
 	free(name);
-	return 0;
+	return DC_STATUS_SUCCESS;
 }
 
 // "sml.DeviceLog.Header.Diving.Gases.Gas.Oxygen"
 // O2 percentage as a byte
-static int add_gas_o2(suunto_eonsteel_parser_t *eon, unsigned char o2)
+static dc_status_t add_gas_o2(suunto_eonsteel_parser_t *eon, unsigned char o2)
 {
-	int idx = eon->cache.ngases-1;
+	int idx = eon->cache.GASMIX_COUNT-1;
 	if (idx >= 0)
-		eon->cache.gasmix[idx].oxygen = o2 / 100.0;
+		eon->cache.GASMIX[idx].oxygen = o2 / 100.0;
 	eon->cache.initialized |= 1 << DC_FIELD_GASMIX;
-	return 0;
+	return DC_STATUS_SUCCESS;
 }
 
 // "sml.DeviceLog.Header.Diving.Gases.Gas.Helium"
 // He percentage as a byte
-static int add_gas_he(suunto_eonsteel_parser_t *eon, unsigned char he)
+static dc_status_t add_gas_he(suunto_eonsteel_parser_t *eon, unsigned char he)
 {
-	int idx = eon->cache.ngases-1;
+	int idx = eon->cache.GASMIX_COUNT-1;
 	if (idx >= 0)
-		eon->cache.gasmix[idx].helium = he / 100.0;
+		eon->cache.GASMIX[idx].helium = he / 100.0;
 	eon->cache.initialized |= 1 << DC_FIELD_GASMIX;
-	return 0;
+	return DC_STATUS_SUCCESS;
 }
 
-static int add_gas_size(suunto_eonsteel_parser_t *eon, float l)
+static dc_status_t add_gas_size(suunto_eonsteel_parser_t *eon, float l)
 {
-	int idx = eon->cache.ngases-1;
+	int idx = eon->cache.GASMIX_COUNT-1;
 	if (idx >= 0)
 		eon->cache.tanksize[idx] = l;
 	eon->cache.initialized |= 1 << DC_FIELD_TANK;
-	return 0;
+	return DC_STATUS_SUCCESS;
 }
 
-static int add_gas_workpressure(suunto_eonsteel_parser_t *eon, float wp)
+static dc_status_t add_gas_workpressure(suunto_eonsteel_parser_t *eon, float wp)
 {
-	int idx = eon->cache.ngases-1;
+	int idx = eon->cache.GASMIX_COUNT-1;
 	if (idx >= 0)
 		eon->cache.tankworkingpressure[idx] = wp;
-	return 0;
+	return DC_STATUS_SUCCESS;
 }
 
 static float get_le32_float(const unsigned char *src)
@@ -1242,12 +1145,22 @@ static float get_le32_float(const unsigned char *src)
 //   Info.SW
 //   Name
 //   SerialNumber
-static int traverse_device_fields(suunto_eonsteel_parser_t *eon, const struct type_desc *desc,
+static dc_status_t traverse_device_fields(suunto_eonsteel_parser_t *eon,
-                                  const unsigned char *data, int len)
+                                          const struct type_desc *desc,
+                                          const unsigned char *data, int len)
 {
 	const char *name = desc->desc + strlen("sml.DeviceLog.Device.");
-
+	if (!strcmp(name, "SerialNumber"))
-	return 0;
+		return dc_field_add_string(&eon->cache, "Serial", data);
+	if (!strcmp(name, "Info.HW"))
+		return dc_field_add_string(&eon->cache, "HW Version", data);
+	if (!strcmp(name, "Info.SW"))
+		return dc_field_add_string(&eon->cache, "FW Version", data);
+	if (!strcmp(name, "Info.BatteryAtStart"))
+		return dc_field_add_string(&eon->cache, "Battery at start", data);
+	if (!strcmp(name, "Info.BatteryAtEnd"))
+		return dc_field_add_string(&eon->cache, "Battery at end", data);
+	return DC_STATUS_SUCCESS;
 }
 
 // "sml.DeviceLog.Header.Diving.Gases"
@@ -1263,8 +1176,9 @@ static int traverse_device_fields(suunto_eonsteel_parser_t *eon, const struct ty
 //   .Gas.EndPressure (float32,precision=0)
 //   .Gas.TransmitterStartBatteryCharge (int8,precision=2)
 //   .Gas.TransmitterEndBatteryCharge (int8,precision=2)
-static int traverse_gas_fields(suunto_eonsteel_parser_t *eon, const struct type_desc *desc,
+static dc_status_t traverse_gas_fields(suunto_eonsteel_parser_t *eon,
-                               const unsigned char *data, int len)
+                                       const struct type_desc *desc,
+                                       const unsigned char *data, int len)
 {
 	const char *name = desc->desc + strlen("sml.DeviceLog.Header.Diving.Gases");
 
@@ -1277,13 +1191,31 @@ static int traverse_gas_fields(suunto_eonsteel_parser_t *eon, const struct type_
 	if (!strcmp(name, ".Gas.Helium"))
 		return add_gas_he(eon, data[0]);
 
+	if (!strcmp(name, ".Gas.TransmitterID"))
+		return dc_field_add_string(&eon->cache, "Transmitter ID", data);
+
 	if (!strcmp(name, ".Gas.TankSize"))
 		return add_gas_size(eon, get_le32_float(data));
 
 	if (!strcmp(name, ".Gas.TankFillPressure"))
 		return add_gas_workpressure(eon, get_le32_float(data));
 
-	return 0;
+	// There is a bug with older transmitters, where the transmitter
+	// battery charge returns zero. Rather than returning that bogus
+	// data, just don't return any battery charge information at all.
+	//
+	// Make sure to add all non-battery-charge field checks above this
+	// test, so that it doesn't trigger for anything else.
+	if (!data[0])
+		return 0;
+
+	if (!strcmp(name, ".Gas.TransmitterStartBatteryCharge"))
+		return dc_field_add_string_fmt(&eon->cache, "Transmitter Battery at start", "%d %%", data[0]);
+
+	if (!strcmp(name, ".Gas.TransmitterEndBatteryCharge"))
+		return dc_field_add_string_fmt(&eon->cache, "Transmitter Battery at end", "%d %%", data[0]);
+
+	return DC_STATUS_SUCCESS;
 }
 
 
@@ -1324,8 +1256,9 @@ static int traverse_gas_fields(suunto_eonsteel_parser_t *eon, const struct type_
 //   EndTissue.Helium+Pressure (uint32)
 //   EndTissue.RgbmNitrogen (float32,precision=3)
 //   EndTissue.RgbmHelium (float32,precision=3)
-static int traverse_diving_fields(suunto_eonsteel_parser_t *eon, const struct type_desc *desc,
+static dc_status_t traverse_diving_fields(suunto_eonsteel_parser_t *eon,
-                                  const unsigned char *data, int len)
+                                          const struct type_desc *desc,
+                                          const unsigned char *data, int len)
 {
 	const char *name = desc->desc + strlen("sml.DeviceLog.Header.Diving.");
 
@@ -1334,17 +1267,25 @@ static int traverse_diving_fields(suunto_eonsteel_parser_t *eon, const struct ty
 
 	if (!strcmp(name, "SurfacePressure")) {
 		unsigned int pressure = array_uint32_le(data); // in SI units - Pascal
-		eon->cache.surface_pressure = pressure / 100000.0; // bar
+		DC_ASSIGN_FIELD(eon->cache, ATMOSPHERIC, pressure / 100000.0); // bar
-		eon->cache.initialized |= 1 << DC_FIELD_ATMOSPHERIC;
+		return DC_STATUS_SUCCESS;
-		return 0;
 	}
 
+	if (!strcmp(name, "Algorithm"))
+		return dc_field_add_string(&eon->cache, "Deco algorithm", data);
+
 	if (!strcmp(name, "DiveMode")) {
 		if (!strncmp((const char *)data, "CCR", 3)) {
-			eon->cache.divemode = DC_DIVEMODE_CCR;
+			DC_ASSIGN_FIELD(eon->cache, DIVEMODE, DC_DIVEMODE_CCR);
-			eon->cache.initialized |= 1 << DC_FIELD_DIVEMODE;
 		}
-		return 0;
+		return dc_field_add_string(&eon->cache, "Dive Mode", data);
+	}
+
+	/* Signed byte of conservatism (-2 .. +2) */
+	if (!strcmp(name, "Conservatism")) {
+		int val = *(signed char *)data;
+
+		return dc_field_add_string_fmt(&eon->cache, "Personal Adjustment", "P%d", val);
 	}
 
 	if (!strcmp(name, "LowSetPoint")) {
@@ -1359,7 +1300,19 @@ static int traverse_diving_fields(suunto_eonsteel_parser_t *eon, const struct ty
 		return 0;
 	}
 
-	return 0;
+	// Time recoded in seconds.
+	// Let's just agree to ignore seconds
+	if (!strcmp(name, "DesaturationTime")) {
+		unsigned int time = array_uint32_le(data) / 60;
+		return dc_field_add_string_fmt(&eon->cache, "Desaturation Time", "%d:%02d", time / 60, time % 60);
+	}
+
+	if (!strcmp(name, "SurfaceTime")) {
+		unsigned int time = array_uint32_le(data) / 60;
+		return dc_field_add_string_fmt(&eon->cache, "Surface Time", "%d:%02d", time / 60, time % 60);
+	}
+
+	return DC_STATUS_SUCCESS;
 }
 
 // "Header" fields are:
@@ -1371,8 +1324,9 @@ static int traverse_diving_fields(suunto_eonsteel_parser_t *eon, const struct ty
 //   Duration (uint32)
 //   PauseDuration (uint32)
 //   SampleInterval (uint8)
-static int traverse_header_fields(suunto_eonsteel_parser_t *eon, const struct type_desc *desc,
+static dc_status_t traverse_header_fields(suunto_eonsteel_parser_t *eon,
-                                  const unsigned char *data, int len)
+                                          const struct type_desc *desc,
+                                          const unsigned char *data, int len)
 {
 	const char *name = desc->desc + strlen("sml.DeviceLog.Header.");
 
@@ -1381,15 +1335,17 @@ static int traverse_header_fields(suunto_eonsteel_parser_t *eon, const struct ty
 
 	if (!strcmp(name, "Depth.Max")) {
 		double d = get_le32_float(data);
-		if (d > eon->cache.maxdepth)
+		if (d > eon->cache.MAXDEPTH)
-			eon->cache.maxdepth = d;
+			DC_ASSIGN_FIELD(eon->cache, MAXDEPTH, d);
-		return 0;
+		return DC_STATUS_SUCCESS;
 	}
+	if (!strcmp(name, "DateTime"))
+		return dc_field_add_string(&eon->cache, "Dive ID", data);
 
-	return 0;
+	return DC_STATUS_SUCCESS;
 }
 
-static int traverse_dynamic_fields(suunto_eonsteel_parser_t *eon, const struct type_desc *desc, const unsigned char *data, int len)
+static dc_status_t traverse_dynamic_fields(suunto_eonsteel_parser_t *eon, const struct type_desc *desc, const unsigned char *data, int len)
 {
 	const char *name = desc->desc;
 
@@ -1404,7 +1360,7 @@ static int traverse_dynamic_fields(suunto_eonsteel_parser_t *eon, const struct t
 			}
 		}
 	}
-	return 0;
+	return DC_STATUS_SUCCESS;
 }
 
 /*
@@ -1428,6 +1384,8 @@ static int traverse_sample_fields(suunto_eonsteel_parser_t *eon, const struct ty
 			set_depth_field(eon, array_uint16_le(data));
 			data += 2;
 			continue;
+		default:
+			break;
 		}
 		break;
 	}
@@ -1457,7 +1415,7 @@ static void initialize_field_caches(suunto_eonsteel_parser_t *eon)
 
 	// The internal time fields are in ms and have to be added up
 	// like that. At the end, we translate it back to seconds.
-	eon->cache.divetime /= 1000;
+	eon->cache.DIVETIME /= 1000;
 }
 
 static void show_descriptor(suunto_eonsteel_parser_t *eon, int nr, struct type_desc *desc)

src/usb_storage.c

@@ -0,0 +1,109 @@
+/*
+ * Dummy "stream" operations for USB storage
+ *
+ * Copyright (C) 2018 Linus Torvalds
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <limits.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "common-private.h"
+#include "context-private.h"
+#include "iostream-private.h"
+#include "iterator-private.h"
+#include "descriptor-private.h"
+#include "timer.h"
+
+// Fake "device" that just contains the directory name that
+// you can read out of the iostream. All the actual IO is
+// up to you.
+typedef struct dc_usbstorage_t {
+	dc_iostream_t base;
+	char pathname[PATH_MAX];
+} dc_usbstorage_t;
+
+static dc_status_t
+dc_usb_storage_read (dc_iostream_t *iostream, void *data, size_t size, size_t *actual);
+
+static const dc_iostream_vtable_t dc_usbstorage_vtable = {
+	sizeof(dc_usbstorage_t),
+	NULL, /* set_timeout */
+	NULL, /* set_latency */
+	NULL, /* set_break */
+	NULL, /* set_dtr */
+	NULL, /* set_rts */
+	NULL, /* get_lines */
+	NULL, /* get_available */
+	NULL, /* configure */
+	dc_usb_storage_read, /* read */
+	NULL, /* write */
+	NULL, /* flush */
+	NULL, /* purge */
+	NULL, /* sleep */
+	NULL, /* close */
+};
+
+dc_status_t
+dc_usb_storage_open (dc_iostream_t **out, dc_context_t *context, const char *name)
+{
+	dc_usbstorage_t *device = NULL;
+	struct stat st;
+
+	if (out == NULL || name == NULL)
+		return DC_STATUS_INVALIDARGS;
+
+	INFO (context, "Open: name=%s", name);
+	if (stat(name, &st) < 0 || !S_ISDIR(st.st_mode))
+		return DC_STATUS_NODEVICE;
+
+	// Allocate memory.
+	device = (dc_usbstorage_t *) dc_iostream_allocate (context, &dc_usbstorage_vtable, DC_TRANSPORT_USBSTORAGE);
+	if (device == NULL) {
+		SYSERROR (context, ENOMEM);
+		return DC_STATUS_NOMEMORY;
+	}
+
+	strncpy(device->pathname, name, PATH_MAX);
+	device->pathname[PATH_MAX-1] = 0;
+
+	*out = (dc_iostream_t *) device;
+	return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t
+dc_usb_storage_read (dc_iostream_t *iostream, void *data, size_t size, size_t *actual)
+{
+	dc_usbstorage_t *device = (dc_usbstorage_t *) iostream;
+	size_t len = strlen(device->pathname);
+
+	if (size <= len)
+		return DC_STATUS_IO;
+	memcpy(data, device->pathname, len+1);
+	if (actual)
+		*actual = len;
+	return DC_STATUS_SUCCESS;
+}