Add initial Scubapro G2 frontend

The back-end parser seems to be the same as for the Uwatec Smart (aka
Galileo Sol).  At least that's the assumption right now.

The downloader just uses USB HID (very similar to EON Steel) rather than
the horrible IrDA thing.

There's also eventually a BLE thing, but that's for the future.

This is an unholy mixture of the Uwatec Smart downloader logic and the
EON Steel usbhid transfer code.  The back-end is pure Uwatec Smart
(model 0x11, same as Galileo Sol).

I'm not at all sure this gets everything right, but it downloads
*something*.

[Jef Driesen: Renamed the backend to uwatec, and made some smaller
              cosmetic changes to match the existing coding style.]

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

examples/common.c

@@ -55,6 +55,7 @@ static const backend_table_t g_backends[] = {
 	{"memomouse",   DC_FAMILY_UWATEC_MEMOMOUSE,    0},
 	{"smart",       DC_FAMILY_UWATEC_SMART,        0x10},
 	{"meridian",    DC_FAMILY_UWATEC_MERIDIAN,     0x20},
+	{"g2",          DC_FAMILY_UWATEC_G2,           0x11},
 	{"sensus",      DC_FAMILY_REEFNET_SENSUS,      1},
 	{"sensuspro",   DC_FAMILY_REEFNET_SENSUSPRO,   2},
 	{"sensusultra", DC_FAMILY_REEFNET_SENSUSULTRA, 3},

include/libdivecomputer/common.h

@@ -59,6 +59,7 @@ typedef enum dc_family_t {
 	DC_FAMILY_UWATEC_MEMOMOUSE,
 	DC_FAMILY_UWATEC_SMART,
 	DC_FAMILY_UWATEC_MERIDIAN,
+	DC_FAMILY_UWATEC_G2,
 	/* Oceanic */
 	DC_FAMILY_OCEANIC_VTPRO = (4 << 16),
 	DC_FAMILY_OCEANIC_VEO250,

src/Makefile.am

@@ -38,6 +38,7 @@ libdivecomputer_la_SOURCES = \
 	uwatec_memomouse.h uwatec_memomouse.c uwatec_memomouse_parser.c \
 	uwatec_smart.h uwatec_smart.c uwatec_smart_parser.c \
 	uwatec_meridian.h uwatec_meridian.c \
+	uwatec_g2.h uwatec_g2.c \
 	oceanic_common.h oceanic_common.c \
 	oceanic_atom2.h oceanic_atom2.c oceanic_atom2_parser.c \
 	oceanic_veo250.h oceanic_veo250.c oceanic_veo250_parser.c \

src/descriptor.c

@@ -135,6 +135,10 @@ static const dc_descriptor_t g_descriptors[] = {
 	{"Scubapro", "Mantis",      DC_FAMILY_UWATEC_MERIDIAN, 0x20},
 	{"Scubapro", "Chromis",     DC_FAMILY_UWATEC_MERIDIAN, 0x24},
 	{"Scubapro", "Mantis 2",    DC_FAMILY_UWATEC_MERIDIAN, 0x26},
+	/* Scubapro G2 */
+#ifdef USBHID
+	{"Scubapro", "G2",          DC_FAMILY_UWATEC_G2, 0x11},
+#endif
 	/* Reefnet */
 	{"Reefnet", "Sensus",       DC_FAMILY_REEFNET_SENSUS, 1},
 	{"Reefnet", "Sensus Pro",   DC_FAMILY_REEFNET_SENSUSPRO, 2},
@@ -429,6 +433,8 @@ dc_descriptor_get_transport (dc_descriptor_t *descriptor)
 		return DC_TRANSPORT_USB;
 	else if (descriptor->type == DC_FAMILY_SUUNTO_EONSTEEL)
 		return DC_TRANSPORT_USBHID;
+	else if (descriptor->type == DC_FAMILY_UWATEC_G2)
+		return DC_TRANSPORT_USBHID;
 	else if (descriptor->type == DC_FAMILY_UWATEC_SMART)
 		return DC_TRANSPORT_IRDA;
 	else

src/device.c

@@ -33,6 +33,7 @@
 #include "reefnet_sensuspro.h"
 #include "reefnet_sensusultra.h"
 #include "uwatec_aladin.h"
+#include "uwatec_g2.h"
 #include "uwatec_memomouse.h"
 #include "uwatec_meridian.h"
 #include "uwatec_smart.h"
@@ -138,6 +139,9 @@ dc_device_open (dc_device_t **out, dc_context_t *context, dc_descriptor_t *descr
 	case DC_FAMILY_UWATEC_MERIDIAN:
 		rc = uwatec_meridian_device_open (&device, context, name);
 		break;
+	case DC_FAMILY_UWATEC_G2:
+		rc = uwatec_g2_device_open (&device, context);
+		break;
 	case DC_FAMILY_REEFNET_SENSUS:
 		rc = reefnet_sensus_device_open (&device, context, name);
 		break;

src/parser.c

@@ -100,6 +100,9 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
 	case DC_FAMILY_UWATEC_MERIDIAN:
 		rc = uwatec_smart_parser_create (&parser, context, model, devtime, systime);
 		break;
+	case DC_FAMILY_UWATEC_G2:
+		rc = uwatec_smart_parser_create (&parser, context, 0x11, devtime, systime);
+		break;
 	case DC_FAMILY_REEFNET_SENSUS:
 		rc = reefnet_sensus_parser_create (&parser, context, devtime, systime);
 		break;

src/uwatec_g2.c

@@ -0,0 +1,380 @@
+/*
+ * libdivecomputer
+ *
+ * Copyright (C) 2008 Jef Driesen
+ *           (C) 2017 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> // malloc, free
+#include <string.h>	// strncmp, strstr
+
+#include "uwatec_g2.h"
+#include "context-private.h"
+#include "device-private.h"
+#include "usbhid.h"
+#include "array.h"
+
+#define ISINSTANCE(device) dc_device_isinstance((device), &uwatec_g2_device_vtable)
+
+#define PACKET_SIZE 64
+
+typedef struct uwatec_g2_device_t {
+	dc_device_t base;
+	dc_usbhid_t *usbhid;
+	unsigned int address;
+	unsigned int timestamp;
+	unsigned int devtime;
+	dc_ticks_t systime;
+} uwatec_g2_device_t;
+
+static dc_status_t uwatec_g2_device_set_fingerprint (dc_device_t *device, const unsigned char data[], unsigned int size);
+static dc_status_t uwatec_g2_device_dump (dc_device_t *abstract, dc_buffer_t *buffer);
+static dc_status_t uwatec_g2_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata);
+static dc_status_t uwatec_g2_device_close (dc_device_t *abstract);
+
+static const dc_device_vtable_t uwatec_g2_device_vtable = {
+	sizeof(uwatec_g2_device_t),
+	DC_FAMILY_UWATEC_G2,
+	uwatec_g2_device_set_fingerprint, /* set_fingerprint */
+	NULL, /* read */
+	NULL, /* write */
+	uwatec_g2_device_dump, /* dump */
+	uwatec_g2_device_foreach, /* foreach */
+	uwatec_g2_device_close /* close */
+};
+
+static dc_status_t
+uwatec_g2_extract_dives (dc_device_t *device, const unsigned char data[], unsigned int size, dc_dive_callback_t callback, void *userdata);
+
+static int
+receive_data (uwatec_g2_device_t *device, unsigned char *data, unsigned int size)
+{
+	while (size) {
+		unsigned char buf[PACKET_SIZE];
+		size_t transferred = 0;
+		dc_status_t rc = DC_STATUS_SUCCESS;
+		unsigned int len = 0;
+
+		rc = dc_usbhid_read (device->usbhid, buf, PACKET_SIZE, &transferred);
+		if (rc != DC_STATUS_SUCCESS) {
+			ERROR (device->base.context, "read interrupt transfer failed");
+			return -1;
+		}
+		if (transferred != PACKET_SIZE) {
+			ERROR (device->base.context, "incomplete read interrupt transfer (got %zu, expected %d)", transferred, PACKET_SIZE);
+			return -1;
+		}
+		len = buf[0];
+		if (len >= PACKET_SIZE) {
+			ERROR (device->base.context, "read interrupt transfer returns impossible packet size (%d)", len);
+			return -1;
+		}
+		HEXDUMP (device->base.context, DC_LOGLEVEL_DEBUG, "rcv", buf + 1, len);
+		if (len > size) {
+			ERROR (device->base.context, "receive result buffer too small - truncating");
+			len = size;
+		}
+		memcpy(data, buf + 1, len);
+		size -= len;
+		data += len;
+	}
+	return 0;
+}
+
+
+static dc_status_t
+uwatec_g2_transfer (uwatec_g2_device_t *device, const unsigned char command[], unsigned int csize, unsigned char answer[], unsigned int asize)
+{
+	unsigned char buf[PACKET_SIZE];
+	dc_status_t status = DC_STATUS_SUCCESS;
+	size_t transferred = 0;
+
+	if (csize >= PACKET_SIZE) {
+		ERROR (device->base.context, "command too big (%d)", csize);
+		return DC_STATUS_INVALIDARGS;
+	}
+
+	buf[0] = csize;
+	memcpy(buf + 1, command, csize);
+	status = dc_usbhid_write (device->usbhid, buf, csize + 1, &transferred);
+	if (status != DC_STATUS_SUCCESS) {
+		ERROR (device->base.context, "Failed to send the command.");
+		return status;
+	}
+
+	if (receive_data (device, answer, asize) < 0) {
+		ERROR (device->base.context, "Failed to receive the answer.");
+		return DC_STATUS_IO;
+	}
+
+	return DC_STATUS_SUCCESS;
+}
+
+
+dc_status_t
+uwatec_g2_device_open (dc_device_t **out, dc_context_t *context)
+{
+	dc_status_t status = DC_STATUS_SUCCESS;
+	uwatec_g2_device_t *device = NULL;
+
+	if (out == NULL)
+		return DC_STATUS_INVALIDARGS;
+
+	// Allocate memory.
+	device = (uwatec_g2_device_t *) dc_device_allocate (context, &uwatec_g2_device_vtable);
+	if (device == NULL) {
+		ERROR (context, "Failed to allocate memory.");
+		return DC_STATUS_NOMEMORY;
+	}
+
+	// Set the default values.
+	device->usbhid = NULL;
+	device->address = 0;
+	device->timestamp = 0;
+	device->systime = (dc_ticks_t) -1;
+	device->devtime = 0;
+
+	// Open the irda socket.
+	status = dc_usbhid_open (&device->usbhid, context, 0x2e6c, 0x3201);
+	if (status != DC_STATUS_SUCCESS) {
+		ERROR (context, "Failed to open USB device");
+		goto error_free;
+	}
+
+	*out = (dc_device_t*) device;
+
+	return DC_STATUS_SUCCESS;
+
+error_free:
+	dc_device_deallocate ((dc_device_t *) device);
+	return status;
+}
+
+
+static dc_status_t
+uwatec_g2_device_close (dc_device_t *abstract)
+{
+	dc_status_t status = DC_STATUS_SUCCESS;
+	uwatec_g2_device_t *device = (uwatec_g2_device_t*) abstract;
+	dc_status_t rc = DC_STATUS_SUCCESS;
+
+	// Close the device.
+	rc = dc_usbhid_close (device->usbhid);
+	if (status != DC_STATUS_SUCCESS) {
+		dc_status_set_error(&status, rc);
+	}
+
+	return status;
+}
+
+
+static dc_status_t
+uwatec_g2_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size)
+{
+	uwatec_g2_device_t *device = (uwatec_g2_device_t*) abstract;
+
+	if (size && size != 4)
+		return DC_STATUS_INVALIDARGS;
+
+	if (size)
+		device->timestamp = array_uint32_le (data);
+	else
+		device->timestamp = 0;
+
+	return DC_STATUS_SUCCESS;
+}
+
+
+static dc_status_t
+uwatec_g2_device_dump (dc_device_t *abstract, dc_buffer_t *buffer)
+{
+	uwatec_g2_device_t *device = (uwatec_g2_device_t*) abstract;
+	dc_status_t rc = DC_STATUS_SUCCESS;
+
+	// Erase the current contents of the buffer.
+	if (!dc_buffer_clear (buffer)) {
+		ERROR (abstract->context, "Insufficient buffer space available.");
+		return DC_STATUS_NOMEMORY;
+	}
+
+	// Enable progress notifications.
+	dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
+	device_event_emit (&device->base, DC_EVENT_PROGRESS, &progress);
+
+	// Read the model number.
+	unsigned char cmd_model[1] = {0x10};
+	unsigned char model[1] = {0};
+	rc = uwatec_g2_transfer (device, cmd_model, sizeof (cmd_model), model, sizeof (model));
+	if (rc != DC_STATUS_SUCCESS)
+		return rc;
+
+	// Read the serial number.
+	unsigned char cmd_serial[1] = {0x14};
+	unsigned char serial[4] = {0};
+	rc = uwatec_g2_transfer (device, cmd_serial, sizeof (cmd_serial), serial, sizeof (serial));
+	if (rc != DC_STATUS_SUCCESS)
+		return rc;
+
+	// Read the device clock.
+	unsigned char cmd_devtime[1] = {0x1A};
+	unsigned char devtime[4] = {0};
+	rc = uwatec_g2_transfer (device, cmd_devtime, sizeof (cmd_devtime), devtime, sizeof (devtime));
+	if (rc != DC_STATUS_SUCCESS)
+		return rc;
+
+	// Store the clock calibration values.
+	device->systime = dc_datetime_now ();
+	device->devtime = array_uint32_le (devtime);
+
+	// Update and emit a progress event.
+	progress.current += 9;
+	device_event_emit (&device->base, DC_EVENT_PROGRESS, &progress);
+
+	// Emit a clock event.
+	dc_event_clock_t clock;
+	clock.systime = device->systime;
+	clock.devtime = device->devtime;
+	device_event_emit (&device->base, DC_EVENT_CLOCK, &clock);
+
+	// Emit a device info event.
+	dc_event_devinfo_t devinfo;
+	devinfo.model = model[0];
+	devinfo.firmware = 0;
+	devinfo.serial = array_uint32_le (serial);
+	device_event_emit (&device->base, DC_EVENT_DEVINFO, &devinfo);
+
+	// Command template.
+	unsigned char command[9] = {0x00,
+			(device->timestamp      ) & 0xFF,
+			(device->timestamp >> 8 ) & 0xFF,
+			(device->timestamp >> 16) & 0xFF,
+			(device->timestamp >> 24) & 0xFF,
+			0x10,
+			0x27,
+			0,
+			0};
+
+	// Data Length.
+	command[0] = 0xC6;
+	unsigned char answer[4] = {0};
+	rc = uwatec_g2_transfer (device, command, sizeof (command), answer, sizeof (answer));
+	if (rc != DC_STATUS_SUCCESS)
+		return rc;
+
+	unsigned int length = array_uint32_le (answer);
+
+	// Update and emit a progress event.
+	progress.maximum = 4 + 9 + (length ? length + 4 : 0);
+	progress.current += 4;
+	device_event_emit (&device->base, DC_EVENT_PROGRESS, &progress);
+
+	if (length == 0)
+		return DC_STATUS_SUCCESS;
+
+	// Allocate the required amount of memory.
+	if (!dc_buffer_resize (buffer, length)) {
+		ERROR (abstract->context, "Insufficient buffer space available.");
+		return DC_STATUS_NOMEMORY;
+	}
+
+	unsigned char *data = dc_buffer_get_data (buffer);
+
+	// Data.
+	command[0] = 0xC4;
+	rc = uwatec_g2_transfer (device, command, sizeof (command), answer, sizeof (answer));
+	if (rc != DC_STATUS_SUCCESS)
+		return rc;
+
+	unsigned int total = array_uint32_le (answer);
+
+	// Update and emit a progress event.
+	progress.current += 4;
+	device_event_emit (&device->base, DC_EVENT_PROGRESS, &progress);
+
+	if (total != length + 4) {
+		ERROR (abstract->context, "Received an unexpected size.");
+		return DC_STATUS_PROTOCOL;
+	}
+
+	if (receive_data (device, data, length)) {
+		ERROR (abstract->context, "Failed to receive the answer.");
+		return DC_STATUS_IO;
+	}
+
+	// Update and emit a progress event.
+	progress.current += length;
+	device_event_emit (&device->base, DC_EVENT_PROGRESS, &progress);
+
+	return DC_STATUS_SUCCESS;
+}
+
+
+static dc_status_t
+uwatec_g2_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
+{
+	dc_buffer_t *buffer = dc_buffer_new (0);
+	if (buffer == NULL)
+		return DC_STATUS_NOMEMORY;
+
+	dc_status_t rc = uwatec_g2_device_dump (abstract, buffer);
+	if (rc != DC_STATUS_SUCCESS) {
+		dc_buffer_free (buffer);
+		return rc;
+	}
+
+	rc = uwatec_g2_extract_dives (abstract,
+		dc_buffer_get_data (buffer), dc_buffer_get_size (buffer), callback, userdata);
+
+	dc_buffer_free (buffer);
+
+	return rc;
+}
+
+
+static dc_status_t
+uwatec_g2_extract_dives (dc_device_t *abstract, const unsigned char data[], unsigned int size, dc_dive_callback_t callback, void *userdata)
+{
+	if (abstract && !ISINSTANCE (abstract))
+		return DC_STATUS_INVALIDARGS;
+
+	const unsigned char header[4] = {0xa5, 0xa5, 0x5a, 0x5a};
+
+	// Search the data stream for start markers.
+	unsigned int previous = size;
+	unsigned int current = (size >= 4 ? size - 4 : 0);
+	while (current > 0) {
+		current--;
+		if (memcmp (data + current, header, sizeof (header)) == 0) {
+			// Get the length of the profile data.
+			unsigned int len = array_uint32_le (data + current + 4);
+
+			// Check for a buffer overflow.
+			if (current + len > previous)
+				return DC_STATUS_DATAFORMAT;
+
+			if (callback && !callback (data + current, len, data + current + 8, 4, userdata))
+				return DC_STATUS_SUCCESS;
+
+			// Prepare for the next dive.
+			previous = current;
+			current = (current >= 4 ? current - 4 : 0);
+		}
+	}
+
+	return DC_STATUS_SUCCESS;
+}

src/uwatec_g2.h

@@ -0,0 +1,39 @@
+/*
+ * libdivecomputer
+ *
+ * Copyright (C) 2008 Jef Driesen
+ *
+ * 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 UWATEC_G2_H
+#define UWATEC_G2_H
+
+#include <libdivecomputer/context.h>
+#include <libdivecomputer/device.h>
+#include <libdivecomputer/parser.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+dc_status_t
+uwatec_g2_device_open (dc_device_t **device, dc_context_t *context);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* UWATEC_G2_H */