On Mon, Oct 27, 2014 at 3:57 PM, Jef Driesen <j...@libdivecomputer.org> wrote:
> On 23-10-14 00:34, Linus Torvalds wrote:
>
> Both the windows and non-libusb builds are broken.
I have no sane way to test the windows build issues. But I fixed the
non-libusb build by moving the ifdef around a bit, and I renamed
"error()" to "report_error()" to hopefully get the Windows build
fixed.
Can you mention the actual broken casts? This is my #1 "C++ is a
broken piece opf shit" moment, though, since I really hate how *wrong*
C++ got the whole "void *" thing (not just NULL, absolutely
_everything_ is broken wrt type handling of "void *" in C++).
> But even the mingw (gcc) build fails. It
> fails on the ERROR macros with "error: called object '0' is not a function".
> Not sure why.
It sounds like the mingw header files use some odd kind of "error"
#define. Worked around by making it be "report_error()"
> The directory_entry structure with it's zero length array is most likely
> also not very portable. C99 has flexible arrays, but I'm not sure what msvc
> supports.
Changed to a one-byte array - it's going to waste a few bytes of
memory per entry, but it's not a big deal. (That's not due to the "1"
- that could be easily fixed - but due to then also aligning the thing
up for "sizeof()").
> Better integration with the existing libdivecomputer infrastructure. We
> already have logging functions, array_uint{16,24,32}_{be,le} helper
> functions for dealing with endianness, dynamic memory buffers (dc_buffer_t),
> etc. There is no need to re-implement any of those.
Quite frankly, your logging functions suck, because they don't return
any value. So you can't use "return ERROR()", which is the sane common
use.
Plus they need that "context" thing which makes no sense and isn't
even available except at "open" time.
It's not just open that wants to log things.
So no, I can't use that horrible thing. For example, even ignoring the
brokenness of the "context" thing, something like:
if (badness)
return report_error("badness %d happened", badness);
compared to:
if (badness) {
ERROR(context, "Badness %d happened", badness);
return DC_STATUS_WHATEVER;
}
is the difference between "I can bother to make reasonable error
reporting" and "f*ck this, I'll not bother logging the reason at all".
So then I'd just do
if (badness)
return DC_STATUS_FAIL;
so now there's no logging at all - just because your interface is bad.
But I can't even use that DC_STATUS_FAIL kind of thing. See later.
As to the "array_uint()" functions - you have no writing functions,
and you're lacking a "u8". And your types are wrong, not allowing
"void *". And they are insanely verbose. But whatever. I converted the
ones you had.
> Out of memory error handling. I know the arguments for calling exit very
> well, but for libdivecomputer I made the choice to handle out of memory
> differently. Please stick to this pattern.
I made it use the dc_buffer_t, and just ignore out-of-memory cases.
They don't happen, and if they did, they'd just result it empty
buffers now.
> Many functions return -1 in the case of an error. Can you rework this as
> dc_status_t values? BTW, if you want to use goto style error handling,
> that's fine.
No, I cannot use dc_status_t values, because they make it impossible
to return an error *and* a value.
There is a very good reason why UNIX calling conventions are "return
-1 on error".
That reason is the *non-error* case. Think of a simple function like
"read()". Ask yourself what it returns on error, and what it returns
on success.
Yes, I have used things like DC_STATUS_SUCCESS. I used VMS for some
time. It's horrible. Suddenly you have to first check for success, and
then have another interface to return the result size etc.
The whole "negative means error, zero or positive is success" is
really powerful. It means that you can return how many bytes you read,
and easily test whether there was something wrong, *without* having to
have some "pass return size value as a pointer" model.
So please realize that my "send_receive()" function works like
"read()" - it returns negative on error, and the number of bytes
received on success.
I can't do that with DC_STATUS_XYZ.
> For the name of the backend, I prefer a single word like "eonsteel" or just
> "steel" instead of eon_steel. This is just to follow the existing practice
> in libdivecomputer were backends are named DC_FAMILY_VENDOR_PRODUCT. So no
> underscores in the product part.
Did it for DC_FAMILY_SUUNTO_EONSTEEL.
> Main structures (struct eon_steel, eon_parser) and all entry point functions
> (public or through the vtable) get the same backend prefix.
I *really* don't want to do this, though. The public ones are
"suunto_eon_steel()" because they are visible to others. But I really
object to writing that long name out for internal helper functions
that are static. Why write that horribly long name for no gain?
> The parser logic is a bit hard to follow without having some example data to
> look at. Can you share some data files?
I don't have any data files, I just run it on the dive computer.
Remember: this is not a "memory dump" style device.
So the dc_device_dump() approach doesn't work, because on this dive
computer you'd have to do it per-dive.
It would be easy to dump the parse data, but I don't think there is
any such functionality: you expect the dump to be a memory dump of the
whole device.
New versions attached.
Linus
From 3dd5083869f83a5cc444554232306668dec3cfc0 Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torva...@linux-foundation.org>
Date: Wed, 22 Oct 2014 11:23:09 -0700
Subject: [PATCH 1/3] parser: add DC_FIELD_DEVINFO field type for parse-time
device information
This can be used to extend and override the device open-time DEVINFO
callback information at dive parse time. If you leave the pointers
NULL, nothing happens, but you can choose to individually fill in the
fields as needed (or not).
NOTE: The caller is supposed to clear the structure so that the
divecomputer backends don't need to care about fields they don't
support. So it's valid for a backend to just return DC_STATUS_SUCCESS
and not do anything else as a reply to DC_FIELD_DEVINFO, although
obviously that means that you won't be returning any new information
either.
Signed-off-by: Linus Torvalds <torva...@linux-foundation.org>
---
include/libdivecomputer/parser.h | 17 ++++++++++++++++-
1 file changed, 16 insertions(+), 1 deletion(-)
diff --git a/include/libdivecomputer/parser.h b/include/libdivecomputer/parser.h
index 65b18c9bb2fe..741803f4e256 100644
--- a/include/libdivecomputer/parser.h
+++ b/include/libdivecomputer/parser.h
@@ -53,9 +53,13 @@ typedef enum dc_field_type_t {
DC_FIELD_GASMIX_COUNT,
DC_FIELD_GASMIX,
DC_FIELD_SALINITY,
- DC_FIELD_ATMOSPHERIC
+ DC_FIELD_ATMOSPHERIC,
+ DC_FIELD_DEVINFO,
} dc_field_type_t;
+// Make it easy to test support compile-time with "#ifdef DC_FIELD_DEVINFO"
+#define DC_FIELD_DEVINFO DC_FIELD_DEVINFO
+
typedef enum parser_sample_event_t {
SAMPLE_EVENT_NONE,
SAMPLE_EVENT_DECOSTOP,
@@ -128,6 +132,17 @@ typedef struct dc_gasmix_t {
double nitrogen;
} dc_gasmix_t;
+// You don't have to fill all of these in, you can leave them NULL
+// but if you do fill them in, they override the device devinfo
+typedef struct dc_field_devinfo_t {
+ const char *vendor;
+ const char *model;
+ const char *serial;
+ const char *hw_version;
+ const char *fw_version;
+ const char *dive_id;
+} dc_field_devinfo_t;
+
typedef union dc_sample_value_t {
unsigned int time;
double depth;
--
2.1.2.452.gd5ca7ae
From f9777c5c7fc73e3b2f001510bf6b11341fb64d87 Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torva...@linux-foundation.org>
Date: Mon, 20 Oct 2014 10:34:37 -0700
Subject: [PATCH 2/3] Suunto EON Steel: support downloading of core dive
profile data
Very roughly copied from my test application. This parses all the basic
dive data, including sample data (time, depth, cylinder pressure etc).
We don't really report events yet, though. This includes data that the
EON steel considers samples, but that libdivecomputer considers events.
So while some of the sample information is parsed (like NDL, ceiling and
TTS information), this doesn't generate the libdivecomputer events to
make the information available to applications yet.
Signed-off-by: Linus Torvalds <torva...@linux-foundation.org>
---
examples/universal.c | 1 +
include/libdivecomputer/common.h | 1 +
include/libdivecomputer/suunto.h | 1 +
include/libdivecomputer/suunto_eon_steel.h | 39 ++
msvc/libdivecomputer.vcproj | 8 +
src/Makefile.am | 1 +
src/descriptor.c | 6 +
src/device.c | 3 +
src/parser.c | 3 +
src/suunto_eon_steel.c | 614 +++++++++++++++++++++++++++++
src/suunto_eon_steel_parser.c | 546 +++++++++++++++++++++++++
11 files changed, 1223 insertions(+)
create mode 100644 include/libdivecomputer/suunto_eon_steel.h
create mode 100644 src/suunto_eon_steel.c
create mode 100644 src/suunto_eon_steel_parser.c
diff --git a/examples/universal.c b/examples/universal.c
index 1e0307b25576..315259708a0e 100644
--- a/examples/universal.c
+++ b/examples/universal.c
@@ -78,6 +78,7 @@ static const backend_table_t g_backends[] = {
{"vyper", DC_FAMILY_SUUNTO_VYPER},
{"vyper2", DC_FAMILY_SUUNTO_VYPER2},
{"d9", DC_FAMILY_SUUNTO_D9},
+ {"eonsteel", DC_FAMILY_SUUNTO_EONSTEEL},
{"aladin", DC_FAMILY_UWATEC_ALADIN},
{"memomouse", DC_FAMILY_UWATEC_MEMOMOUSE},
{"smart", DC_FAMILY_UWATEC_SMART},
diff --git a/include/libdivecomputer/common.h b/include/libdivecomputer/common.h
index 983ec0716861..4bcc7009986b 100644
--- a/include/libdivecomputer/common.h
+++ b/include/libdivecomputer/common.h
@@ -49,6 +49,7 @@ typedef enum dc_family_t {
DC_FAMILY_SUUNTO_VYPER,
DC_FAMILY_SUUNTO_VYPER2,
DC_FAMILY_SUUNTO_D9,
+ DC_FAMILY_SUUNTO_EONSTEEL,
/* Reefnet */
DC_FAMILY_REEFNET_SENSUS = (2 << 16),
DC_FAMILY_REEFNET_SENSUSPRO,
diff --git a/include/libdivecomputer/suunto.h b/include/libdivecomputer/suunto.h
index 337dffd6f42f..87f1dc7583db 100644
--- a/include/libdivecomputer/suunto.h
+++ b/include/libdivecomputer/suunto.h
@@ -27,5 +27,6 @@
#include "suunto_vyper.h"
#include "suunto_vyper2.h"
#include "suunto_d9.h"
+#include "suunto_eon_steel.h"
#endif /* SUUNTO_H */
diff --git a/include/libdivecomputer/suunto_eon_steel.h b/include/libdivecomputer/suunto_eon_steel.h
new file mode 100644
index 000000000000..025dbce050f2
--- /dev/null
+++ b/include/libdivecomputer/suunto_eon_steel.h
@@ -0,0 +1,39 @@
+/*
+ * libdivecomputer
+ *
+ * Copyright (C) 2014 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 EON_STEEL_H
+#define EON_STEEL_H
+
+#include "context.h"
+#include "device.h"
+#include "parser.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+dc_status_t suunto_eon_steel_device_open(dc_device_t **device, dc_context_t *context, const char *name, unsigned int model);
+dc_status_t suunto_eon_steel_parser_create(dc_parser_t **parser, dc_context_t *context, unsigned int model);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* EON_STEEL_H */
diff --git a/msvc/libdivecomputer.vcproj b/msvc/libdivecomputer.vcproj
index 78a8190ccda2..d5943c6f34c9 100644
--- a/msvc/libdivecomputer.vcproj
+++ b/msvc/libdivecomputer.vcproj
@@ -395,6 +395,14 @@
>
</File>
<File
+ RelativePath="..\src\suunto_eon_steel.c"
+ >
+ </File>
+ <File
+ RelativePath="..\src\suunto_eon_steel_parser.c"
+ >
+ </File>
+ <File
RelativePath="..\src\suunto_eon.c"
>
</File>
diff --git a/src/Makefile.am b/src/Makefile.am
index 595f0c7dc1c0..91265ebe043a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -24,6 +24,7 @@ libdivecomputer_la_SOURCES = \
suunto_vyper.c suunto_vyper_parser.c \
suunto_vyper2.c \
suunto_d9.c suunto_d9_parser.c \
+ suunto_eon_steel.c suunto_eon_steel_parser.c \
reefnet_sensus.c reefnet_sensus_parser.c \
reefnet_sensuspro.c reefnet_sensuspro_parser.c \
reefnet_sensusultra.c reefnet_sensusultra_parser.c \
diff --git a/src/descriptor.c b/src/descriptor.c
index 2845af10e74b..4209318f4821 100644
--- a/src/descriptor.c
+++ b/src/descriptor.c
@@ -77,6 +77,10 @@ static const dc_descriptor_t g_descriptors[] = {
{"Suunto", "D6i", DC_FAMILY_SUUNTO_D9, 0x1A},
{"Suunto", "D9tx", DC_FAMILY_SUUNTO_D9, 0x1B},
{"Suunto", "DX", DC_FAMILY_SUUNTO_D9, 0x1C},
+ /* Suunto EON Steel */
+#ifdef HAVE_LIBUSB
+ {"Suunto", "EON Steel", DC_FAMILY_SUUNTO_EONSTEEL, 0},
+#endif
/* Uwatec Aladin */
{"Uwatec", "Aladin Air Twin", DC_FAMILY_UWATEC_ALADIN, 0x1C},
{"Uwatec", "Aladin Sport Plus", DC_FAMILY_UWATEC_ALADIN, 0x3E},
@@ -339,6 +343,8 @@ dc_descriptor_get_transport (dc_descriptor_t *descriptor)
if (descriptor->type == DC_FAMILY_ATOMICS_COBALT)
return DC_TRANSPORT_USB;
+ else if (descriptor->type == DC_FAMILY_SUUNTO_EONSTEEL)
+ return DC_TRANSPORT_USB;
else if (descriptor->type == DC_FAMILY_UWATEC_SMART)
return DC_TRANSPORT_IRDA;
else
diff --git a/src/device.c b/src/device.c
index 9fad7a238bc4..e12e745b4eea 100644
--- a/src/device.c
+++ b/src/device.c
@@ -82,6 +82,9 @@ dc_device_open (dc_device_t **out, dc_context_t *context, dc_descriptor_t *descr
case DC_FAMILY_SUUNTO_D9:
rc = suunto_d9_device_open (&device, context, name, dc_descriptor_get_model (descriptor));
break;
+ case DC_FAMILY_SUUNTO_EONSTEEL:
+ rc = suunto_eon_steel_device_open (&device, context, name, dc_descriptor_get_model (descriptor));
+ break;
case DC_FAMILY_UWATEC_ALADIN:
rc = uwatec_aladin_device_open (&device, context, name);
break;
diff --git a/src/parser.c b/src/parser.c
index 7cc7f4ed2cfd..c1bd6ead57bc 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -66,6 +66,9 @@ dc_parser_new (dc_parser_t **out, dc_device_t *device)
case DC_FAMILY_SUUNTO_D9:
rc = suunto_d9_parser_create (&parser, context, device->devinfo.model);
break;
+ case DC_FAMILY_SUUNTO_EONSTEEL:
+ rc = suunto_eon_steel_parser_create(&parser, context, device->devinfo.model);
+ break;
case DC_FAMILY_UWATEC_ALADIN:
case DC_FAMILY_UWATEC_MEMOMOUSE:
rc = uwatec_memomouse_parser_create (&parser, context, device->clock.devtime, device->clock.systime);
diff --git a/src/suunto_eon_steel.c b/src/suunto_eon_steel.c
new file mode 100644
index 000000000000..3ca38d7dba7b
--- /dev/null
+++ b/src/suunto_eon_steel.c
@@ -0,0 +1,614 @@
+/*
+ * libdivecomputer
+ *
+ * Copyright (C) 2014 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <libdivecomputer/suunto_eon_steel.h>
+
+#include "context-private.h"
+#include "device-private.h"
+#include "array.h"
+
+#ifdef HAVE_LIBUSB
+
+#include <libusb-1.0/libusb.h>
+
+struct eon_steel {
+ dc_device_t base;
+
+ libusb_context *ctx;
+ libusb_device_handle *handle;
+ unsigned int magic;
+ unsigned short seq;
+};
+
+// The EON Steel implements a small filesystem
+#define DIRTYPE_FILE 0x0001
+#define DIRTYPE_DIR 0x0002
+
+struct directory_entry {
+ struct directory_entry *next;
+ int type;
+ int namelen;
+ char name[1];
+};
+
+// EON Steel command numbers and other magic field values
+#define INIT_CMD 0x00
+#define INIT_MAGIC 0x0001
+#define INIT_SEQ 0
+#define INIT_LEN 4
+#define INIT_DATA "\x02\x00\x2a\x00"
+
+#define READ_STRING_CMD 0x0411
+
+#define FILE_LOOKUP_CMD 0x0010
+#define FILE_READ_CMD 0x0110
+#define FILE_STAT_CMD 0x0710
+#define FILE_CLOSE_CMD 0x0510
+
+#define DIR_LOOKUP_CMD 0x0810
+#define READDIR_CMD 0x0910
+#define DIR_CLOSE_CMD 0x0a10
+
+static const char *dive_directory = "0:/dives";
+
+static struct directory_entry *alloc_dirent(int type, int len, const char *name)
+{
+ struct directory_entry *res;
+
+ res = malloc(offsetof(struct directory_entry, name) + len + 1);
+ if (res) {
+ res->next = NULL;
+ res->type = type;
+ res->namelen = len;
+ memcpy(res->name, name, len);
+ res->name[len] = 0;
+ }
+ return res;
+}
+
+static int report_error(const char *fmt, ...)
+{
+ char buffer[128];
+ va_list args;
+
+ va_start(args, fmt);
+ vsnprintf(buffer, sizeof(buffer)-1, fmt, args);
+ va_end(args);
+ fprintf(stderr, "%.*s\n", (int)sizeof(buffer), buffer);
+ return -1;
+}
+
+static void put_le16(unsigned short val, void *dst)
+{
+ unsigned char *p = (unsigned char *)dst;
+ p[0] = val;
+ p[1] = val >> 8;
+}
+
+static void put_le32(unsigned int val, void *dst)
+{
+ unsigned char *p = (unsigned char *)dst;
+ p[0] = val;
+ p[1] = val >> 8;
+ p[2] = val >> 16;
+ p[3] = val >> 24;
+}
+
+static void debug(const char *name, const char *buf, int len)
+{
+ int i;
+
+ fprintf(stderr, "%4d %s:", len, name);
+ for (i = 0; i < len; i++)
+ fprintf(stderr, " %02x", (unsigned char) buf[i]);
+ fprintf(stderr, "\n");
+}
+
+static void debug_text(const char *name, const char *buf, int len)
+{
+ int i;
+
+ printf("text of %s:\n", name);
+ for (i = 0; i < len; i++) {
+ unsigned char c = buf[i];
+ if (c > 31 && c < 127)
+ putchar(c);
+ else if (c == '\n') {
+ putchar('\\');
+ putchar('n');
+ } else {
+ static const char hex[16]="0123456789abcdef";
+ putchar('\\');
+ putchar('x');
+ putchar(hex[c>>4]);
+ putchar(hex[c&15]);
+ }
+ }
+ printf("\nend of text\n");
+}
+
+static int receive_data(struct eon_steel *eon, unsigned char *buffer, int size)
+{
+ const int InEndpoint = 0x82;
+ unsigned char buf[64];
+ int ret = 0;
+
+ for (;;) {
+ int rc, transferred, len;
+
+ rc = libusb_interrupt_transfer(eon->handle, InEndpoint, buf, sizeof(buf), &transferred, 5000);
+ if (rc || transferred != sizeof(buf))
+ return report_error("incomplete read interrupt transfer");
+// dump every incoming packet?
+// debug("rcv", buf, transferred);
+ if (buf[0] != 0x3f)
+ return report_error("read interrupt transfer returns wrong report type");
+ len = buf[1];
+ if (len > sizeof(buf)-2)
+ return report_error("read interrupt transfer reports short length");
+ if (len > size)
+ return report_error("read interrupt transfer reports excessive length");
+ memcpy(buffer+ret, buf+2, len);
+ size -= len;
+ ret += len;
+ if (len < sizeof(buf)-2)
+ break;
+ }
+
+ return ret;
+}
+
+static int send_cmd(struct eon_steel *eon,
+ unsigned short cmd,
+ unsigned int len,
+ const unsigned char *buffer)
+{
+ const int OutEndpoint = 0x02;
+ unsigned char buf[64];
+ int transferred, rc;
+ unsigned short seq = eon->seq;
+ unsigned int magic = eon->magic;
+
+ // Two-byte packet header, followed by 12 bytes of extended header
+ if (len > sizeof(buf)-2-12)
+ return report_error("send command with too much long");
+
+ memset(buf, 0, sizeof(buf));
+
+ buf[0] = 0x3f;
+ buf[1] = len + 12;
+
+ // 2-byte LE command word
+ put_le16(cmd, buf+2);
+
+ // 4-byte LE magic value (starts at 1)
+ put_le32(magic, buf+4);
+
+ // 2-byte LE sequence number;
+ put_le16(seq, buf+8);
+
+ // 4-byte LE length
+ put_le32(len, buf+10);
+
+ // .. followed by actual data
+ memcpy(buf+14, buffer, len);
+
+ rc = libusb_interrupt_transfer(eon->handle, OutEndpoint, buf, sizeof(buf), &transferred, 5000);
+ if (rc < 0)
+ return report_error("write interrupt transfer failed");
+
+// dump every outgoing packet?
+// debug("cmd", buf, sizeof(buf));
+ return 0;
+}
+
+/*
+ * Send a command, receive a reply
+ *
+ * This carefully checks the data fields in the reply for a match
+ * against the command, and then only returns the actual reply
+ * data itself.
+ *
+ * Also note that "receive_data()" itself will have removed the
+ * per-packet handshake bytes, so unlike "send_cmd()", this does
+ * not see the two initial 0x3f 0x?? bytes, and this the offsets
+ * for the cmd/magic/seq/len are off by two compared to the
+ * send_cmd() side. The offsets are the same in the actual raw
+ * packet.
+ */
+static int send_receive(struct eon_steel *eon,
+ unsigned short cmd,
+ unsigned int len_out, const unsigned char *out,
+ unsigned int len_in, unsigned char *in)
+{
+ int len, actual;
+ unsigned char buf[2048];
+
+ if (send_cmd(eon, cmd, len_out, out) < 0)
+ return -1;
+ len = receive_data(eon, buf, sizeof(buf));
+ if (len < 10)
+ return report_error("short command reply (%d)", len);
+ if (array_uint16_le(buf) != cmd)
+ return report_error("command reply doesn't match command");
+ if (array_uint32_le(buf+2) != eon->magic + 5)
+ return report_error("command reply doesn't match magic (got %08x, expected %08x)", array_uint32_le(buf+2), eon->magic + 5);
+ if (array_uint16_le(buf+6) != eon->seq)
+ return report_error("command reply doesn't match sequence number");
+ actual = array_uint32_le(buf+8);
+ if (actual + 12 != len)
+ return report_error("command reply length mismatch (got %d, claimed %d)", len-12, actual);
+ if (len_in < actual)
+ return report_error("command reply returned too much data (got %d, had %d)", actual, len_in);
+
+ // Successful command - increment sequence number
+ eon->seq++;
+ memcpy(in, buf+12, actual);
+ return actual;
+}
+
+static int read_file(struct eon_steel *eon, const char *filename, dc_buffer_t *buf)
+{
+ unsigned char result[2560];
+ unsigned char cmdbuf[64];
+ unsigned int size, offset;
+ int rc, len;
+
+ memset(cmdbuf, 0, sizeof(cmdbuf));
+ len = strlen(filename) + 1;
+ if (len + 4 > sizeof(cmdbuf))
+ return report_error("too long filename: %s", filename);
+ memcpy(cmdbuf+4, filename, len);
+ rc = send_receive(eon, FILE_LOOKUP_CMD,
+ len+4, cmdbuf,
+ sizeof(result), result);
+ if (rc < 0)
+ return report_error("unable to look up %s", filename);
+// debug("lookup", result, rc);
+
+ rc = send_receive(eon, FILE_STAT_CMD,
+ 0, "",
+ sizeof(result), result);
+ if (rc < 0)
+ return report_error("unable to stat %s", filename);
+// debug("stat", result, rc);
+
+ size = array_uint32_le(result+4);
+ offset = 0;
+
+ while (size > 0) {
+ unsigned int ask, got, at;
+
+ ask = size;
+ if (ask > 1024)
+ ask = 1024;
+ put_le32(1234, cmdbuf+0); // Not file offset, after all
+ put_le32(ask, cmdbuf+4); // Size of read
+ rc = send_receive(eon, FILE_READ_CMD,
+ 8, cmdbuf,
+ sizeof(result), result);
+ if (rc < 0)
+ return report_error("unable to read %s", filename);
+ if (rc < 8)
+ return report_error("got short read reply for %s", filename);
+
+ // Not file offset, just stays unmodified.
+ at = array_uint32_le(result);
+ if (at != 1234)
+ return report_error("read of %s returned different offset than asked for (%d vs %d)", filename, at, offset);
+
+ // Number of bytes actually read
+ got = array_uint32_le(result+4);
+ if (!got)
+ break;
+ if (rc < 8 + got)
+ return report_error("odd read size reply for offset %d of file %s", offset, filename);
+
+ if (got > size)
+ got = size;
+ dc_buffer_append(buf, result+8, got);
+ offset += got;
+ size -= got;
+ }
+
+ rc = send_receive(eon, FILE_CLOSE_CMD,
+ 0, "",
+ sizeof(result), result);
+ if (rc < 0)
+ report_error("cmd 0510 failed");
+// debug("close", result, rc);
+
+ return offset;
+}
+
+/*
+ * 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(int nr, const unsigned char *p, int len, struct directory_entry *old)
+{
+ while (len > 8) {
+ unsigned int type = array_uint32_le(p);
+ unsigned int namelen = array_uint32_le(p+4);
+ const unsigned char *name = p+8;
+ struct directory_entry *entry;
+
+ if (namelen + 8 + 1 > len || name[namelen] != 0) {
+ report_error("corrupt dirent entry");
+ break;
+ }
+// debug("dir entry", p, 8);
+ p += 8 + namelen + 1;
+ len -= 8 + namelen + 1;
+ entry = alloc_dirent(type, namelen, name);
+ entry->next = old;
+ old = entry;
+ }
+ return old;
+}
+
+static int get_file_list(struct eon_steel *eon, struct directory_entry **res)
+{
+ struct directory_entry *de = NULL;
+ unsigned char cmd[64];
+ unsigned char result[2048];
+ int rc, cmdlen;
+
+
+ *res = NULL;
+ put_le32(0, cmd);
+ strcpy(cmd+4, dive_directory);
+ cmdlen = 4+strlen(dive_directory)+1;
+ rc = send_receive(eon, DIR_LOOKUP_CMD,
+ cmdlen, cmd,
+ sizeof(result), result);
+ if (rc < 0)
+ report_error("cmd DIR_LOOKUP failed");
+// debug("DIR_LOOKUP", result, rc);
+
+ for (;;) {
+ unsigned int nr, last;
+
+ rc = send_receive(eon, READDIR_CMD,
+ 0, "",
+ sizeof(result), result);
+ if (rc < 0)
+ return report_error("readdir failed");
+ if (rc < 8)
+ return report_error("short readdir result");
+ nr = array_uint32_le(result);
+ last = array_uint32_le(result+4);
+// debug("dir packet", result, 8);
+
+ de = parse_dirent(nr, result+8, rc-8, de);
+ if (last)
+ break;
+ }
+
+ rc = send_receive(eon, DIR_CLOSE_CMD,
+ 0, "",
+ sizeof(result), result);
+ if (rc < 0)
+ report_error("dir close failed");
+
+ *res = de;
+ return 0;
+}
+
+
+static dc_status_t eon_steel_device_foreach(dc_device_t *abstract, dc_dive_callback_t callback, void *userdata);
+static dc_status_t eon_steel_device_close(dc_device_t *abstract);
+
+static const dc_device_vtable_t eon_steel_device_vtable = {
+ DC_FAMILY_SUUNTO_EONSTEEL,
+ NULL, /* set_fingerprint */
+ NULL, /* read */
+ NULL, /* write */
+ NULL, /* dump */
+ eon_steel_device_foreach, /* foreach */
+ eon_steel_device_close /* close */
+};
+
+static int initialize_eon_steel(struct eon_steel *eon)
+{
+ const int InEndpoint = 0x82;
+ unsigned char buf[64];
+
+ /* Get rid of any pending stale input first */
+ for (;;) {
+ int transferred;
+
+ int rc = libusb_interrupt_transfer(eon->handle, InEndpoint, buf, sizeof(buf), &transferred, 10);
+ if (rc < 0)
+ break;
+ if (!transferred)
+ break;
+ }
+
+ if (send_cmd(eon, INIT_CMD, INIT_LEN, INIT_DATA))
+ return report_error("Failed to send initialization command");
+ if (receive_data(eon, buf, sizeof(buf)) < 0)
+ return report_error("Failed to receive initial reply");
+
+ // Don't ask
+ eon->magic = 0x00000005 | (buf[4] << 16) | (buf[5] << 24);
+ // Increment the sequence number for every command sent
+ eon->seq++;
+ return 0;
+}
+
+dc_status_t suunto_eon_steel_device_open(dc_device_t **out, dc_context_t *context, const char *name, unsigned int model)
+{
+ int rc;
+ struct eon_steel *eon;
+
+ if (out == NULL)
+ return DC_STATUS_INVALIDARGS;
+
+ eon = calloc(1, sizeof(struct eon_steel));
+ if (!eon)
+ return DC_STATUS_NOMEMORY;
+
+ // Set up the magic handshake fields
+ eon->magic = INIT_MAGIC;
+ eon->seq = INIT_SEQ;
+
+ // Set up the libdivecomputer interfaces
+ device_init(&eon->base, context, &eon_steel_device_vtable);
+ *out = (void *) eon;
+
+ if (libusb_init(&eon->ctx)) {
+ ERROR(context, "libusb_init() failed");
+ return DC_STATUS_IO;
+ }
+
+ eon->handle = libusb_open_device_with_vid_pid(eon->ctx, 0x1493, 0x0030);
+ if (!eon->handle) {
+ ERROR(context, "unable to open EON Steel device (%s)", strerror(errno));
+ libusb_exit(eon->ctx);
+ return DC_STATUS_IO;
+ }
+
+ libusb_set_auto_detach_kernel_driver(eon->handle, 1);
+ libusb_claim_interface(eon->handle, 0);
+
+ if (initialize_eon_steel(eon) < 0) {
+ ERROR(context, "unable to initialize EON Steel device (%s)", strerror(errno));
+ libusb_exit(eon->ctx);
+ return DC_STATUS_IO;
+ }
+
+ return DC_STATUS_SUCCESS;
+}
+
+static int count_dir_entries(struct directory_entry *de)
+{
+ int count = 0;
+ while (de) {
+ count++;
+ de = de->next;
+ }
+ return count;
+}
+
+static dc_status_t eon_steel_device_foreach(dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
+{
+ int skip = 0, rc;
+ struct directory_entry *de;
+ struct eon_steel *eon = (struct eon_steel *) abstract;
+ dc_buffer_t *file;
+ char pathname[64];
+ unsigned int time;
+ dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
+
+ if (get_file_list(eon, &de) < 0)
+ return DC_STATUS_IO;
+
+ file = dc_buffer_new(0);
+ progress.maximum = count_dir_entries(de);
+ progress.current = 0;
+ device_event_emit(abstract, DC_EVENT_PROGRESS, &progress);
+
+ while (de) {
+ int len;
+ struct directory_entry *next = de->next;
+ char buf[4];
+
+ if (device_is_cancelled(abstract))
+ skip = 1;
+
+ switch (de->type) {
+ case DIRTYPE_DIR:
+ /* Ignore subdirectories in the dive directory */
+ break;
+ case DIRTYPE_FILE:
+ if (skip)
+ break;
+ if (sscanf(de->name, "%x.LOG", &time) != 1)
+ break;
+ len = snprintf(pathname, sizeof(pathname), "%s/%s", dive_directory, de->name);
+ if (len >= sizeof(pathname))
+ break;
+
+ // Reset the membuffer, put the 4-byte length at the head.
+ dc_buffer_clear(file);
+ put_le32(time, buf);
+ dc_buffer_append(file, buf, 4);
+
+ // Then read the filename into the rest of the buffer
+ rc = read_file(eon, pathname, file);
+ if (rc < 0)
+ break;
+ if (!callback)
+ break;
+ if (!callback(dc_buffer_get_data(file), dc_buffer_get_size(file), NULL, 0, userdata))
+ skip = 1;
+
+ // We've used up the buffer, so create a new one
+ file = dc_buffer_new(0);
+ }
+ progress.current++;
+ device_event_emit(abstract, DC_EVENT_PROGRESS, &progress);
+
+ free(de);
+ de = next;
+ }
+ dc_buffer_free(file);
+
+ return device_is_cancelled(abstract) ? DC_STATUS_CANCELLED : DC_STATUS_SUCCESS;
+}
+
+static dc_status_t eon_steel_device_close(dc_device_t *abstract)
+{
+ struct eon_steel *eon = (struct eon_steel *) abstract;
+
+ libusb_close(eon->handle);
+ libusb_exit(eon->ctx);
+ free(eon);
+
+ return DC_STATUS_SUCCESS;
+}
+
+#else // no LIBUSB support
+
+dc_status_t suunto_eon_steel_device_open(dc_device_t **out, dc_context_t *context, const char *name, unsigned int model)
+{
+ ERROR(context, "The Suunto EON Steel backend needs libusb-1.0");
+ return DC_STATUS_UNSUPPORTED;
+}
+
+#endif
diff --git a/src/suunto_eon_steel_parser.c b/src/suunto_eon_steel_parser.c
new file mode 100644
index 000000000000..ef77fec3b947
--- /dev/null
+++ b/src/suunto_eon_steel_parser.c
@@ -0,0 +1,546 @@
+/*
+ * libdivecomputer
+ *
+ * Copyright (C) 2014 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <libdivecomputer/suunto_eon_steel.h>
+
+#include "context-private.h"
+#include "parser-private.h"
+#include "array.h"
+
+struct type_desc {
+ const char *desc, *format, *mod;
+};
+
+#define MAXTYPE 512
+#define MAXGASES 16
+
+struct eon_parser {
+ dc_parser_t base;
+ struct type_desc type_desc[MAXTYPE];
+ // field 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;
+ } cache;
+};
+
+
+static int report_error(const char *fmt, ...)
+{
+ char buffer[128];
+ va_list args;
+
+ va_start(args, fmt);
+ vsnprintf(buffer, sizeof(buffer)-1, fmt, args);
+ va_end(args);
+ fprintf(stderr, "%.*s\n", (int)sizeof(buffer), buffer);
+ return -1;
+}
+
+static unsigned char get_u8(const void *src)
+{
+ return *(const unsigned char *)src;
+}
+
+static void debug(const char *name, const char *buf, int len)
+{
+ int i;
+
+ fprintf(stderr, "%4d %s:", len, name);
+ for (i = 0; i < len; i++)
+ fprintf(stderr, " %02x", (unsigned char) buf[i]);
+ fprintf(stderr, "\n");
+}
+
+static void debug_text(const char *name, const char *buf, int len)
+{
+ int i;
+
+ printf("text of %s:\n", name);
+ for (i = 0; i < len; i++) {
+ unsigned char c = buf[i];
+ if (c > 31 && c < 127)
+ putchar(c);
+ else if (c == '\n') {
+ putchar('\\');
+ putchar('n');
+ } else {
+ static const char hex[16]="0123456789abcdef";
+ putchar('\\');
+ putchar('x');
+ putchar(hex[c>>4]);
+ putchar(hex[c&15]);
+ }
+ }
+ printf("\nend of text\n");
+}
+
+typedef int (*eon_data_cb_t)(unsigned short type, const struct type_desc *desc, const void *data, int len, void *user);
+
+static int record_type(struct eon_parser *eon, unsigned short type, const char *name, int namelen)
+{
+ struct type_desc desc;
+ const char *next;
+
+ desc.desc = desc.format = desc.mod = "";
+ do {
+ int len;
+ char *p;
+
+ next = strchr(name, '\n');
+ if (next) {
+ len = next - name;
+ next++;
+ } else {
+ len = strlen(name);
+ }
+
+ if (len < 5 || name[0] != '<' || name[4] != '>')
+ return report_error("Unexpected type description: %.*s", len, name);
+ p = malloc(len-4);
+ if (!p)
+ return report_error("out of memory");
+ memcpy(p, name+5, len-5);
+ p[len-5] = 0;
+
+ // PTH, GRP, FRM, MOD
+ switch (name[1]) {
+ case 'P': case 'G':
+ desc.desc = p;
+ break;
+ case 'F':
+ desc.format = p;
+ break;
+ case 'M':
+ desc.mod = p;
+ break;
+ default:
+ return report_error("Unknown type descriptor: %,*s", len, name);
+ }
+ } while ((name = next) != NULL);
+
+ if (type > MAXTYPE)
+ return report_error("Type out of range (%04x: '%s' '%s' '%s')",
+ type, desc.desc, desc.format, desc.mod);
+
+ eon->type_desc[type] = desc;
+ return 0;
+}
+
+static int traverse_entry(struct eon_parser *eon, const unsigned char *p, int len, eon_data_cb_t callback, void *user)
+{
+ const unsigned char *name, *data, *end, *last, *one_past_end = p + len;
+ int textlen, type;
+ int rc;
+
+ // First two bytes: zero and text length
+ if (p[0]) {
+ debug("next", p, 8);
+ return report_error("Bad dive entry (%02x)", p[0]);
+ }
+ textlen = p[1];
+
+ name = p + 2;
+ if (textlen == 0xff) {
+ textlen = array_uint32_le(name);
+ name += 4;
+ }
+
+ // Two bytes of 'type' followed by the name/descriptor, followed by the data
+ data = name + textlen;
+ type = array_uint16_le(name);
+ name += 2;
+
+ if (*name != '<') {
+ fflush(NULL);
+ debug("bad", p, 16);
+ exit(1);
+ }
+
+ record_type(eon, type, name, textlen-3);
+
+ end = data;
+ last = data;
+ while (end < one_past_end && *end) {
+ const char *begin = end;
+ unsigned int type = *end++;
+ unsigned int len;
+ if (type == 0xff) {
+ type = array_uint16_le(end);
+ end += 2;
+ }
+ len = *end++;
+
+ // I've never actually seen this case yet..
+ // Just assuming from the other cases.
+ if (len == 0xff) {
+ debug("len-ff", end, 8);
+ len = array_uint32_le(end);
+ end += 4;
+ }
+
+ if (type > MAXTYPE || !eon->type_desc[type].desc) {
+ debug("last", last, 16);
+ debug("this", begin, 16);
+ } else {
+ rc = callback(type, eon->type_desc+type, end, len, user);
+ if (rc < 0)
+ return rc;
+ }
+
+ last = begin;
+ end += len;
+ }
+
+ return end - p;
+}
+
+static int traverse_data(struct eon_parser *eon, eon_data_cb_t callback, void *user)
+{
+ const unsigned char *data = eon->base.data;
+ int len = eon->base.size;
+
+ // Dive files start with "SBEM" and four NUL characters
+ // Additionally, we've prepended the time as an extra
+ // 4-byte pre-header
+ if (len < 12 || memcmp(data+4, "SBEM", 4))
+ return 0;
+
+ data += 12;
+ len -= 12;
+
+ while (len > 4) {
+ int i = traverse_entry(eon, data, len, callback, user);
+ if (i < 0)
+ return 1;
+ len -= i;
+ data += i;
+ }
+ return 0;
+}
+
+struct sample_data {
+ struct eon_parser *eon;
+ dc_sample_callback_t callback;
+ void *userdata;
+ unsigned int time;
+};
+
+static void sample_time(struct sample_data *info, unsigned short time_delta)
+{
+ dc_sample_value_t sample = {0};
+
+ info->time += time_delta;
+ sample.time = info->time / 1000;
+ if (info->callback) info->callback(DC_SAMPLE_TIME, sample, info->userdata);
+}
+
+static void sample_depth(struct sample_data *info, unsigned short depth)
+{
+ dc_sample_value_t sample = {0};
+
+ if (depth == 0xffff)
+ return;
+
+ sample.depth = depth / 100.0;
+ if (info->callback) info->callback(DC_SAMPLE_DEPTH, sample, info->userdata);
+}
+
+static void sample_temp(struct sample_data *info, short temp)
+{
+ dc_sample_value_t sample = {0};
+
+ if (temp < -3000)
+ return;
+
+ sample.temperature = temp / 10.0;
+ if (info->callback) info->callback(DC_SAMPLE_TEMPERATURE, sample, info->userdata);
+}
+
+static void sample_ndl(struct sample_data *info, short temp)
+{
+ dc_sample_value_t sample = {0};
+
+ if (temp < 0)
+ return;
+
+ // There is no NDL sample
+}
+
+static void sample_tts(struct sample_data *info, unsigned short tts)
+{
+ dc_sample_value_t sample = {0};
+
+ if (tts == 0xffff)
+ return;
+
+ // There is no TTS sample
+}
+
+static void sample_ceiling(struct sample_data *info, unsigned short ceiling)
+{
+ dc_sample_value_t sample = {0};
+
+ if (ceiling == 0xffff)
+ return;
+
+ // There is no ceiling sample
+}
+
+static void sample_cylinder_pressure(struct sample_data *info, unsigned char idx, unsigned short pressure)
+{
+ dc_sample_value_t sample = {0};
+
+ if (pressure == 0xffff)
+ return;
+
+ sample.pressure.tank = idx-1;
+ sample.pressure.value = pressure / 100.0;
+ if (info->callback) info->callback(DC_SAMPLE_PRESSURE, sample, info->userdata);
+}
+
+static int traverse_samples(unsigned short type, const struct type_desc *desc, const void *data, int len, void *user)
+{
+ struct sample_data *info = user;
+
+ switch (type) {
+ case 0x0001: // group: time in first word, depth in second
+ sample_time(info, array_uint16_le(data));
+ sample_depth(info, array_uint16_le(data+2));
+ sample_temp(info, array_uint16_le(data+4));
+ sample_ndl(info, array_uint16_le(data+8));
+ sample_tts(info, array_uint16_le(data+10));
+ sample_ceiling(info, array_uint16_le(data+12));
+ break;
+ case 0x0002: // time in first word
+ sample_time(info, array_uint16_le(data));
+ break;
+ case 0x0003: // depth in first word
+ sample_depth(info, array_uint16_le(data));
+ break;
+ case 0x000a: // cylinder idx in first byte, pressure in next word
+ sample_cylinder_pressure(info, get_u8(data), array_uint16_le(data+1));
+ break;
+ }
+ return 0;
+}
+
+static dc_status_t eon_steel_parser_samples_foreach(dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata)
+{
+ struct eon_parser *eon = (void *)abstract;
+ struct sample_data data = { eon, callback, userdata, 0 };
+
+ traverse_data(eon, traverse_samples, &data);
+ 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 eon_steel_parser_get_field(dc_parser_t *parser, dc_field_type_t type, unsigned int flags, void *value)
+{
+ struct eon_parser *eon = (struct eon_parser *)parser;
+
+ if (!(eon->cache.initialized >> type))
+ return DC_STATUS_UNSUPPORTED;
+
+ switch (type) {
+ case DC_FIELD_DIVETIME:
+ field_value(value, eon->cache.divetime);
+ break;
+ case DC_FIELD_MAXDEPTH:
+ field_value(value, eon->cache.maxdepth);
+ break;
+ case DC_FIELD_AVGDEPTH:
+ field_value(value, eon->cache.avgdepth);
+ break;
+ case DC_FIELD_GASMIX_COUNT:
+ field_value(value, eon->cache.ngases);
+ break;
+ case DC_FIELD_GASMIX:
+ if (flags >= MAXGASES)
+ return DC_STATUS_UNSUPPORTED;
+ field_value(value, eon->cache.gasmix[flags]);
+ break;
+ case DC_FIELD_SALINITY:
+ field_value(value, eon->cache.salinity);
+ break;
+ case DC_FIELD_ATMOSPHERIC:
+ field_value(value, eon->cache.surface_pressure);
+ break;
+ }
+ return DC_STATUS_SUCCESS;
+}
+
+/*
+ * The time of the dive is encoded in the filename,
+ * and we've saved it off as the four first bytes
+ * of the dive data (in little-endian format).
+ */
+static dc_status_t eon_steel_parser_get_datetime(dc_parser_t *parser, dc_datetime_t *datetime)
+{
+ unsigned int t;
+
+ if (parser->size < 4)
+ return DC_STATUS_UNSUPPORTED;
+
+ dc_datetime_gmtime(datetime, array_uint32_le(parser->data));
+ return DC_STATUS_SUCCESS;
+}
+
+// time in ms
+static void add_time_field(struct eon_parser *eon, unsigned short time_delta_ms)
+{
+ eon->cache.divetime += time_delta_ms;
+}
+
+// depth in cm
+static void set_depth_field(struct eon_parser *eon, unsigned short d)
+{
+ if (d != 0xffff) {
+ double depth = d / 100.0;
+ if (depth > eon->cache.maxdepth)
+ eon->cache.maxdepth = depth;
+ eon->cache.initialized |= 1 << DC_FIELD_MAXDEPTH;
+ }
+}
+
+// gas type: 0=Off,1=Primary,2=?,3=Diluent
+static void add_gas_type(struct eon_parser *eon, unsigned char type)
+{
+ if (eon->cache.ngases < MAXGASES)
+ eon->cache.ngases++;
+ eon->cache.initialized |= 1 << DC_FIELD_GASMIX_COUNT;
+}
+
+// O2 percentage as a byte
+static void add_gas_o2(struct eon_parser *eon, unsigned char o2)
+{
+ int idx = eon->cache.ngases-1;
+ if (idx >= 0)
+ eon->cache.gasmix[idx].oxygen = o2 / 100.0;
+ eon->cache.initialized |= 1 << DC_FIELD_GASMIX;
+}
+
+// He percentage as a byte
+static void add_gas_he(struct eon_parser *eon, unsigned char he)
+{
+ int idx = eon->cache.ngases-1;
+ if (idx >= 0)
+ eon->cache.gasmix[idx].helium = he / 100.0;
+ eon->cache.initialized |= 1 << DC_FIELD_GASMIX;
+}
+
+static int traverse_fields(unsigned short type, const struct type_desc *desc, const void *data, int len, void *user)
+{
+ struct eon_parser *eon = user;
+
+ switch (type) {
+ case 0x0001: // group: time in first word, depth in second
+ add_time_field(eon, array_uint16_le(data));
+ set_depth_field(eon, array_uint16_le(data+2));
+ break;
+ case 0x0002: // time in first word
+ add_time_field(eon, array_uint16_le(data));
+ break;
+ case 0x0003: // depth in first word
+ set_depth_field(eon, array_uint16_le(data));
+ break;
+ case 0x000d: // gas state in first byte
+ add_gas_type(eon, get_u8(data));
+ break;
+ case 0x000e: // Oxygen percentage in first byte
+ add_gas_o2(eon, get_u8(data));
+ break;
+ case 0x000f: // Helium percentage in first byte
+ add_gas_he(eon, get_u8(data));
+ break;
+ }
+ return 0;
+}
+
+
+static void initialize_field_caches(struct eon_parser *eon)
+{
+ memset(&eon->cache, 0, sizeof(eon->cache));
+ eon->cache.initialized = 1 << DC_FIELD_DIVETIME;
+
+ traverse_data(eon, traverse_fields, 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;
+}
+
+static dc_status_t eon_steel_parser_set_data(dc_parser_t *parser, const unsigned char *data, unsigned int size)
+{
+ struct eon_parser *eon = (void *)parser;
+ memset(eon->type_desc, 0, sizeof(eon->type_desc));
+ initialize_field_caches(eon);
+ return DC_STATUS_SUCCESS;
+}
+
+static dc_status_t eon_steel_parser_destroy(dc_parser_t *parser)
+{
+ free(parser);
+ return DC_STATUS_SUCCESS;
+}
+
+static const dc_parser_vtable_t eon_steel_parser_vtable = {
+ DC_FAMILY_SUUNTO_EONSTEEL,
+ eon_steel_parser_set_data, /* set_data */
+ eon_steel_parser_get_datetime, /* datetime */
+ eon_steel_parser_get_field, /* fields */
+ eon_steel_parser_samples_foreach, /* samples_foreach */
+ eon_steel_parser_destroy /* destroy */
+};
+
+dc_status_t suunto_eon_steel_parser_create(dc_parser_t **out, dc_context_t *context, unsigned int model)
+{
+ struct eon_parser *eon;
+
+ if (out == NULL)
+ return DC_STATUS_INVALIDARGS;
+
+ eon = calloc(1, sizeof(*eon));
+ parser_init(&eon->base, context, &eon_steel_parser_vtable);
+ *out = &eon->base;
+
+ return DC_STATUS_SUCCESS;
+}
--
2.1.2.452.gd5ca7ae
From 640809b73bb67d76b1a3fb56f0de7fa3e62996ae Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torva...@linux-foundation.org>
Date: Mon, 27 Oct 2014 17:19:48 -0700
Subject: [PATCH 3/3] Suunto EON Steel: populate dive surface pressure, and
sw/hw version info
The EON Steel saves the dive computer firmware versions etc per dive,
which is really nice for upgrades: old dives done with older firmware
still show the firmware at the time of the dive. That, in turn, is nice
because we can use it for a reliable dive ID - dive time with serial
number etc.
This uses the new DC_FIELD_DEVINFO model to feed the hw/sw information
to the application, since we need the parser to access it.
Signed-off-by: Linus Torvalds <torva...@linux-foundation.org>
---
src/suunto_eon_steel_parser.c | 132 +++++++++++++++++++++++++++++++++++++++++-
1 file changed, 131 insertions(+), 1 deletion(-)
diff --git a/src/suunto_eon_steel_parser.c b/src/suunto_eon_steel_parser.c
index ef77fec3b947..3f32ef162adf 100644
--- a/src/suunto_eon_steel_parser.c
+++ b/src/suunto_eon_steel_parser.c
@@ -55,6 +55,7 @@ struct eon_parser {
dc_gasmix_t gasmix[MAXGASES];
dc_salinity_t salinity;
double surface_pressure;
+ struct dc_field_devinfo_t devinfo;
} cache;
};
@@ -76,6 +77,17 @@ static unsigned char get_u8(const void *src)
return *(const unsigned char *)src;
}
+static float get_le32_float(const void *src)
+{
+ union {
+ unsigned int val;
+ float result;
+ } u;
+
+ u.val = array_uint32_le(src);
+ return u.result;
+}
+
static void debug(const char *name, const char *buf, int len)
{
int i;
@@ -363,7 +375,6 @@ static dc_status_t eon_steel_parser_samples_foreach(dc_parser_t *abstract, dc_sa
{
struct eon_parser *eon = (void *)abstract;
struct sample_data data = { eon, callback, userdata, 0 };
-
traverse_data(eon, traverse_samples, &data);
return DC_STATUS_SUCCESS;
}
@@ -404,6 +415,9 @@ static dc_status_t eon_steel_parser_get_field(dc_parser_t *parser, dc_field_type
case DC_FIELD_ATMOSPHERIC:
field_value(value, eon->cache.surface_pressure);
break;
+ case DC_FIELD_DEVINFO:
+ field_value(value, eon->cache.devinfo);
+ break;
}
return DC_STATUS_SUCCESS;
}
@@ -467,6 +481,115 @@ static void add_gas_he(struct eon_parser *eon, unsigned char he)
eon->cache.initialized |= 1 << DC_FIELD_GASMIX;
}
+// "Device" fields are all utf8:
+// Info.BatteryAtEnd
+// Info.BatteryAtStart
+// Info.BSL
+// Info.HW
+// Info.SW
+// Name
+// SerialNumber
+static int traverse_device_fields(struct eon_parser *eon, const char *name, const void *data, int len)
+{
+ const char **entry;
+
+ if (!strcmp(name, "SerialNumber"))
+ entry = &eon->cache.devinfo.serial;
+ else if (!strcmp(name, "Info.HW"))
+ entry = &eon->cache.devinfo.hw_version;
+ else if (!strcmp(name, "Info.SW"))
+ entry = &eon->cache.devinfo.fw_version;
+ else if (!strcmp(name, "Name"))
+ entry = &eon->cache.devinfo.model;
+ else
+ return 0;
+
+ if (*entry)
+ free((void *)*entry);
+ *entry = strdup(data);
+ eon->cache.initialized |= 1 << DC_FIELD_DEVINFO;
+ return 0;
+}
+
+// "Header" fields are:
+// Activity (utf8)
+// DateTime (utf8)
+// Depth.Avg (float32,precision=2)
+// Depth.Max (float32,precision=2)
+// Diving.AlgorithmAscentTime (uint32)
+// Diving.AlgorithmBottomMixture.Helium (uint8,precision=2) (0.01*x,100*x)
+// Diving.AlgorithmBottomMixture.Oxygen (uint8,precision=2) (0.01*x,100*x)
+// Diving.AlgorithmBottomTime (uint32)
+// Diving.AlgorithmTransitionDepth (uint8)
+// Diving.Algorithm (utf8)
+// Diving.Altitude (uint16)
+// Diving.Conservatism (int8)
+// Diving.DaysInSeries (uint32)
+// Diving.DesaturationTime (uint32)
+// Diving.DiveMode (utf8)
+// Diving.EndTissue.CNS (float32,precision=3)
+// Diving.EndTissue.Helium+Pressure (uint32)
+// Diving.EndTissue.Nitrogen+Pressure (uint32)
+// Diving.EndTissue.OLF (float32,precision=3)
+// Diving.EndTissue.OTU (float32)
+// Diving.EndTissue.RgbmHelium (float32,precision=3)
+// Diving.EndTissue.RgbmNitrogen (float32,precision=3)
+// Diving.NumberInSeries (uint32)
+// Diving.PreviousDiveDepth (float32,precision=2)
+// Diving.StartTissue.CNS (float32,precision=3)
+// Diving.StartTissue.Helium+Pressure (uint32)
+// Diving.StartTissue.Nitrogen+Pressure (uint32)
+// Diving.StartTissue.OLF (float32,precision=3)
+// Diving.StartTissue.OTU (float32)
+// Diving.StartTissue.RgbmHelium (float32,precision=3)
+// Diving.StartTissue.RgbmNitrogen (float32,precision=3)
+// Diving.SurfacePressure (uint32)
+// Diving.SurfaceTime (uint32)
+// Duration (uint32)
+// PauseDuration (uint32)
+// SampleInterval (uint8)
+static int traverse_header_fields(struct eon_parser *eon, const char *name, const void *data, int len)
+{
+ if (!strcmp(name, "Depth.Max")) {
+ double d = get_le32_float(data);
+ if (d > eon->cache.maxdepth)
+ eon->cache.maxdepth = d;
+ return 0;
+ }
+ if (!strcmp(name, "Diving.SurfacePressure")) {
+ unsigned int pressure = array_uint32_le(data); // in SI units - Pascal
+ eon->cache.surface_pressure = pressure / 100000.0; // bar
+ eon->cache.initialized |= 1 << DC_FIELD_ATMOSPHERIC;
+ return 0;
+ }
+ if (!strcmp(name, "DateTime")) {
+ if (eon->cache.devinfo.dive_id)
+ free((void *)eon->cache.devinfo.dive_id);
+ eon->cache.devinfo.dive_id = strdup(data);
+ eon->cache.initialized |= 1 << DC_FIELD_DEVINFO;
+ return 0;
+ }
+ return 0;
+}
+
+static int traverse_dynamic_fields(struct eon_parser *eon, const struct type_desc *desc, const void *data, int len)
+{
+ const char *name = desc->desc;
+
+ if (!strncmp(name, "sml.", 4)) {
+ name += 4;
+ if (!strncmp(name, "DeviceLog.", 10)) {
+ name += 10;
+ if (!strncmp(name, "Device.", 7))
+ return traverse_device_fields(eon, name+7, data, len);
+ if (!strncmp(name, "Header.", 7)) {
+ return traverse_header_fields(eon, name+7, data, len);
+ }
+ }
+ }
+ return 0;
+}
+
static int traverse_fields(unsigned short type, const struct type_desc *desc, const void *data, int len, void *user)
{
struct eon_parser *eon = user;
@@ -491,6 +614,13 @@ static int traverse_fields(unsigned short type, const struct type_desc *desc, co
case 0x000f: // Helium percentage in first byte
add_gas_he(eon, get_u8(data));
break;
+ default:
+ // The types with the high byte set seem to be dynamic
+ // although not all of them seem to change. But let's
+ // just check the descriptor name for them.
+ if (type > 255)
+ traverse_dynamic_fields(eon, desc, data, len);
+ break;
}
return 0;
}
--
2.1.2.452.gd5ca7ae
_______________________________________________
subsurface mailing list
subsurface@subsurface-divelog.org
http://lists.subsurface-divelog.org/cgi-bin/mailman/listinfo/subsurface
