Add new port: science/sigrok-firmware-utils

PR:		188808
Submitted by:	uffer

      ===============================================================

The sigrok project aims at creating a portable, cross-platform,
Free/Libre/Open-Source signal analysis software suite that supports
various device types, such as logic analyzers, MSOs, oscilloscopes,
multimeters, LCR meters, sound level meters, thermometers, hygrometers,
anemometers, light meters, DAQs, dataloggers, function generators,
spectrum analyzers, power supplies, GPIB interfaces, and more.

11 files changed, 989 insertions, 0 deletions

diff --git a/science/sigrok-firmware-utils/Makefile b/science/sigrok-firmware-utils/Makefile
new file mode 100644
index 000000000000..e25be0791548
--- /dev/null
+++ b/science/sigrok-firmware-utils/Makefile
@@ -0,0 +1,43 @@
+# Created by: Uffe Jakobsen <uffe@uffe.org>
+# $FreeBSD$
+
+PORTNAME=	firmware
+PORTVERSION=	20140418
+CATEGORIES=	science
+MASTER_SITES=	#none
+PKGNAMEPREFIX=	sigrok-
+PKGNAMESUFFIX=	-utils
+DISTFILES=	#none
+
+MAINTAINER=	uffe@uffe.org
+COMMENT=	Sigrok firmware extraction utils
+
+LICENSE=	GPLv2
+
+USE_PYTHON=	3
+NO_BUILD=	yes
+
+PORTDOCS=	README.parsepe
+
+PY_FILES=	parsepe.py parseelf.py
+
+EX_FILES=	sigrok-fwextract-hantek-dso \
+		sigrok-fwextract-saleae-logic16 \
+		sigrok-fwextract-sysclk-lwla
+
+PLIST_FILES=	${PY_FILES:S,^,bin/,} \
+		${EX_FILES:S,^,bin/,} \
+		${EX_FILES:S,^,man/man1/,:S,$,.1.gz,}
+
+do-install:
+	@${MKDIR} ${STAGEDIR}${DOCSDIR}
+	${INSTALL_MAN} ${FILESDIR}/README.parsepe ${STAGEDIR}${DOCSDIR}
+.for fil in ${PY_FILES}
+	${INSTALL_SCRIPT} ${FILESDIR}/${fil} ${STAGEDIR}${PREFIX}/bin
+.endfor
+.for fil in ${EX_FILES}
+	${INSTALL_SCRIPT} ${FILESDIR}/${fil} ${STAGEDIR}${PREFIX}/bin
+	${INSTALL_MAN} ${FILESDIR}/${fil}.1 ${STAGEDIR}${MANDIRS}/man1
+.endfor
+
+.include <bsd.port.mk>
diff --git a/science/sigrok-firmware-utils/files/README.parsepe b/science/sigrok-firmware-utils/files/README.parsepe
new file mode 100644
index 000000000000..8a69b6f5545c
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/README.parsepe
@@ -0,0 +1,11 @@
+The parsepe.py tool can list all sections and symbols from a PE (portable
+executable) binary file, and extract the contents of a symbol.
+
+usage:
+parsepe.py -l <filename>                list all sections and symbols in file
+parsepe.py -s <symbol> -x <filename>    extract symbol from file
+
+TODO:
+- currently only handles COFF symbol tables
+- can only extract external (global) symbols
+
diff --git a/science/sigrok-firmware-utils/files/parseelf.py b/science/sigrok-firmware-utils/files/parseelf.py
new file mode 100644
index 000000000000..4f267eaa0012
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/parseelf.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+##
+## This file is part of the sigrok-util project.
+##
+## Copyright (C) 2013 Marcus Comstedt <marcus@mc.pp.se>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, see <http://www.gnu.org/licenses/>.
+##
+
+import struct
+
+class elf:
+
+    def read_struct(this, struct_fmt, struct_fields):
+        fmt = this.elf_endianprefix+str.translate(struct_fmt, this.elf_format);
+        fields = struct.unpack(fmt, this.file.read(struct.calcsize(fmt)))
+        return dict(zip(struct_fields, fields))
+
+    def read_ehdr(this):
+        return this.read_struct('16sHHWNNNWHHHHHH',
+                                ('e_ident', 'e_type', 'e_machine', 'e_version',
+                                 'e_entry', 'e_phoff', 'e_shoff', 'e_flags',
+                                 'e_ehsize', 'e_phentsize', 'e_phnum',
+                                 'e_shentsize', 'e_shnum', 'e_shstrndx'))
+
+    def read_shdr(this):
+        return this.read_struct('WWNNNNWWNN',
+                                ('sh_name', 'sh_type', 'sh_flags', 'sh_addr',
+                                 'sh_offset', 'sh_size', 'sh_link', 'sh_info',
+                                 'sh_addralign', 'sh_entsize'))
+
+    def read_section(this, shdr):
+        this.file.seek(shdr['sh_offset'])
+        return this.file.read(shdr['sh_size'])
+
+    def get_name(this, name, strtab=None):
+        strtab = strtab or this.strtab
+        nul = strtab.find(b'\0', name)
+        if nul < 0:
+            return bytes.decode(strtab[name:])
+        else:
+            return bytes.decode(strtab[name:nul])
+
+    def find_section(this, name):
+        for section in this.shdrs:
+            if this.get_name(section['sh_name']) == name:
+                return section
+        raise KeyError(name)
+
+    def parse_symbol(this):
+        if this.elf_wordsize == 64:
+            return this.read_struct('WBBHNX',
+                                    ('st_name', 'st_info', 'st_other',
+                                     'st_shndx', 'st_value', 'st_size'))
+        else:
+            return this.read_struct('WNWBBH',
+                                    ('st_name', 'st_value', 'st_size',
+                                     'st_info', 'st_other', 'st_shndx'))
+
+    def parse_rela(this):
+        return this.read_struct('NNn', ('r_offset', 'r_info', 'r_addend'))
+
+    def parse_rel(this):
+        return this.read_struct('NN', ('r_offset', 'r_info'))
+
+    def fixup_reloc(this, reloc):
+        if not 'r_addend' in reloc:
+            reloc['r_addend'] = 0
+        if this.elf_wordsize == 64:
+            reloc['r_sym'] = reloc['r_info'] >> 32
+            reloc['r_type'] = reloc['r_info'] & 0xffffffff
+        else:
+            reloc['r_sym'] = reloc['r_info'] >> 8
+            reloc['r_type'] = reloc['r_info'] & 0xff
+        return reloc
+
+    def parse_symbols(this, symsecname, strsecname):
+        try:
+            symsechdr = this.find_section(symsecname)
+            strsechdr = this.find_section(strsecname)
+        except KeyError:
+            return {}
+        strsec = this.read_section(strsechdr)
+        this.file.seek(symsechdr['sh_offset'])
+        syms = [dict(this.parse_symbol(),number=i) for i in
+                range(0, symsechdr['sh_size'] // symsechdr['sh_entsize'])]
+        return {this.get_name(sym['st_name'], strsec): sym for sym in syms}
+
+    def parse_relocs(this, section):
+        this.file.seek(section['sh_offset'])
+        if section['sh_type'] == 4:
+            relocs = [this.fixup_reloc(this.parse_rela()) for i in
+                      range(0, section['sh_size'] // section['sh_entsize'])]
+        else:
+            relocs = [this.fixup_reloc(this.parse_rel()) for i in
+                      range(0, section['sh_size'] // section['sh_entsize'])]
+        return relocs
+
+    def address_to_offset(this, addr):
+        for section in this.shdrs:
+            if (section['sh_addr'] <= addr and
+                section['sh_addr']+section['sh_size'] > addr):
+                return section['sh_offset']+(addr-section['sh_addr'])
+        raise IndexError('address out of range')
+
+    def load_symbol(this, sym):
+        this.file.seek(this.address_to_offset(sym['st_value']))
+        return this.file.read(sym['st_size'])
+
+    def __init__(this, filename):
+        this.file = open(filename, 'rb')
+        magic = this.file.read(16)
+
+        if magic[:4] != b'\x7fELF':
+            raise Exception("ELF signature not found")
+
+        if magic[4] == 1:
+            this.elf_wordsize = 32
+            nativeint = 'Ii'
+        elif magic[4] == 2:
+            this.elf_wordsize = 64
+            nativeint = 'Qq'
+        else:
+            raise Exception("Invalid ELF file class")
+
+        if magic[5] == 1:
+            this.elf_endianprefix = '<'
+        elif magic[5] == 2:
+            this.elf_endianprefix = '>'
+        else:
+            raise Exception("Invalid ELF data encoding")
+
+        this.elf_format = str.maketrans('HWwXxNn', 'HIiQq'+nativeint)
+
+        this.file.seek(0)
+        this.ehdr = this.read_ehdr()
+        this.file.seek(this.ehdr['e_shoff'])
+        this.shdrs = [this.read_shdr() for i in range(this.ehdr['e_shnum'])]
+
+        this.strtab = this.read_section(this.shdrs[this.ehdr['e_shstrndx']])
+
+        this.symtab = this.parse_symbols('.symtab', '.strtab')
+        this.dynsym = this.parse_symbols('.dynsym', '.dynstr')
+
+        this.relocs = {}
+        for section in this.shdrs:
+            if section['sh_type'] == 4 or section['sh_type'] == 9:
+                rels = {}
+                symsec = this.shdrs[section['sh_link']]
+                if this.get_name(symsec['sh_name']) == '.symtab':
+                    rels['symbols'] = this.symtab
+                elif this.get_name(symsec['sh_name']) == '.dynsym':
+                    rels['symbols'] = this.dynsym
+                rels['relocs'] = this.parse_relocs(section)
+                this.relocs[this.get_name(section['sh_name'])] = rels
+
+    def __del__(this):
+        try:
+            this.file.close()
+        except AttributeError:
+            pass
diff --git a/science/sigrok-firmware-utils/files/parsepe.py b/science/sigrok-firmware-utils/files/parsepe.py
new file mode 100644
index 000000000000..ac04fb2ee4b7
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/parsepe.py
@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+##
+## This file is part of the sigrok-util project.
+##
+## Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, see <http://www.gnu.org/licenses/>.
+##
+
+import sys
+import os
+from getopt import getopt
+import struct
+
+
+def parse(filename):
+	f = open(filename, 'rb')
+	if f.read(2) != b'MZ':
+		raise Exception("MZ signature not found.")
+
+	sections = []
+	# long e_lfanew
+	f.seek(0x3c)
+	pe_ptr = struct.unpack("<L", f.read(4))[0]
+	f.seek(pe_ptr)
+	if f.read(4) != b'\x50\x45\x00\x00':
+		raise Exception("PE signature not found.")
+	# skip Machine
+	f.seek(f.tell() + 2)
+	sections.append(['header', 324, 0])
+	num_sections = struct.unpack("<H", f.read(2))[0]
+	# skip TimeDateStamp
+	f.seek(f.tell() + 4)
+	symboltable_address = struct.unpack("<L", f.read(4))[0]
+	num_symbols = struct.unpack("<L", f.read(4))[0]
+	optheader_size = struct.unpack("<H", f.read(2))[0]
+	# skip past PE header and PE optional header
+	f.seek(f.tell() + 2 + optheader_size)
+
+	for i in range(num_sections):
+		name = f.read(8).decode('ascii', errors='ignore').strip('\x00')
+		# skip past Misc and VirtualAddress
+		f.seek(f.tell() + 8)
+		# SizeOfRawData
+		size = struct.unpack("<L", f.read(4))[0]
+		# PointerToRawData
+		ptr = struct.unpack("<L", f.read(4))[0]
+		# skip to next section header
+		f.seek(f.tell() + 16)
+		sections.append([name, size, ptr])
+
+	symbols = []
+	addr = symboltable_address
+	stringtable_address = symboltable_address + num_symbols * 18
+	for i in range(num_symbols):
+		f.seek(addr)
+		tmp = f.read(8)
+		symaddr = struct.unpack("<L", f.read(4))[0]
+		# skip SectionNumber and Type
+		symtype = struct.unpack("B", f.read(1))[0]
+		f.seek(f.tell() + 4)
+		if tmp[:4] == b'\x00\x00\x00\x00':
+			# symbol name is in the string table
+			straddr = stringtable_address + struct.unpack("<l", tmp[4:])[0]
+			f.seek(straddr)
+			tmpname = f.read(64)
+			name = tmpname[:tmpname.find(b'\x00')]
+		else:
+			name = tmp
+		name = name.decode('ascii', errors='ignore').strip('\x00')
+		# need IMAGE_SYM_CLASS_EXTERNAL
+		if symtype == 0x02:
+			size = 0
+		else:
+			size = None
+		if i != 0 and symbols[-1][2] is not None and symaddr > symbols[-1][1]:
+			symbols[-1][2] = symaddr - symbols[-1][1]
+		symbols.append([name, symaddr, size])
+		addr += 18
+
+	f.close()
+
+	return sections, symbols
+
+
+def list_all(filename):
+	sections, symbols = parse(filename)
+	if sections:
+		print("Sections:\n    Name         Size\t  Position")
+		cnt = 0
+		for name, size, address in sections:
+			print("%-3d %-8s    %5d\t  0x%.8x" % (cnt, name, size, address))
+			cnt += 1
+	if symbols:
+		print("\nSymbol table:\n   Address     Size    Symbol")
+		for symbol, address, size in symbols:
+			if size is not None:
+				sizestr = "%5d" % size
+			else:
+				sizestr = "     "
+			print("0x%.8x  %s    %-8s" % (address, sizestr, symbol))
+		print()
+
+
+def extract_symbol(filename, symbol):
+	sections, symbols = parse(filename)
+	if not symbols:
+		return None
+	data = None
+	for symbolname, address, size in symbols:
+		if symbolname == symbol:
+			if size is None:
+				raise Exception("symbol %s found, but has unknown size")
+			f = open(filename, 'rb')
+			f.seek(address)
+			data = f.read(size)
+			f.close()
+			if len(data) != size:
+				raise Exception("short file")
+			break
+
+	if data is None:
+		raise Exception("symbol %s not found" % symbol)
+
+	return data
+
+
+
+def usage():
+	print("usage: parsepe.py [-s <symbol>] <-l|-x> <filename>")
+	print("  -l   list all sections and symbols in file")
+	print("  -x   extract symbol from file (specify symbol name with -s)")
+	sys.exit()
+
+
+#
+# main
+#
+
+if __name__ == '__main__':
+	filename = symbol = mode = None
+	opts, args = getopt(sys.argv[1:], 's:lx')
+	for opt, arg in opts:
+		if opt == '-s':
+			symbol = arg
+		elif opt == '-l':
+			mode = 'list'
+		elif opt == '-x':
+			mode = 'extract'
+
+	if len(args) != 1:
+		usage()
+	if mode is None and symbol is None:
+		usage()
+
+	try:
+		filename = args[0]
+		if mode == 'list':
+			list_all(filename)
+		elif mode == 'extract':
+			if symbol is None:
+				raise Exception("specify a symbol to extract")
+			data = extract_symbol(filename, symbol)
+			outfile = os.path.splitext(filename)[0] + symbol
+			open(outfile, 'wb').write(data)
+			print("saved %d bytes to %s" % (len(data), outfile))
+		else:
+			raise Exception("specify -l or -x")
+	except Exception as e:
+		print("Error: %s" % str(e))
+
+
diff --git a/science/sigrok-firmware-utils/files/sigrok-fwextract-hantek-dso b/science/sigrok-firmware-utils/files/sigrok-fwextract-hantek-dso
new file mode 100644
index 000000000000..c134578f10ff
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/sigrok-fwextract-hantek-dso
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+##
+## This file is part of the sigrok-util project.
+##
+## Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, see <http://www.gnu.org/licenses/>.
+##
+
+import sys
+import os
+import re
+import struct
+from array import array
+
+import parsepe
+
+
+def find_model(filename):
+	filename = os.path.split(filename)[-1]
+	m = re.search('^dso([a-z0-9]+)1.sys$', filename, re.I)
+	if m:
+		model = m.group(1).upper()
+		model = model.replace('X86', '').replace('AMD64', '').replace('IA64', '')
+		if model == '520A':
+			model = '5200A'
+	else:
+		model = 'unknown'
+
+	return model
+
+
+def unsparse(data):
+	p = 0
+	maxaddr = 0
+	blob = array('B', [0] * 0x4000)
+	while p <= len(data) and data[p+4] == 0:
+		num_bytes = struct.unpack("<H", data[p:p+2])[0]
+		address = struct.unpack("<H", data[p+2:p+4])[0]
+		chunk = array('B')
+		chunk.frombytes(data[p+5:p+5+num_bytes])
+		p += 22
+
+		if address > 0x4000:
+			# the FX2 only has 16K RAM. other writes are to registers
+			# in the 0xe000 region, skip those
+			continue
+
+		blob[address:address+num_bytes] = chunk
+
+		if address + num_bytes > maxaddr:
+			maxaddr = address + num_bytes
+
+	return blob[:maxaddr].tostring()
+
+
+def usage():
+	print("sigrok-fwextract-hantek-dso <driverfile>")
+	sys.exit()
+
+
+#
+# main
+#
+
+if len(sys.argv) != 2:
+	usage()
+
+try:
+	filename = sys.argv[1]
+	binihx = parsepe.extract_symbol(filename, '_firmware')
+	if binihx is None:
+		raise Exception("no firmware found")
+	blob = unsparse(binihx)
+	outfile = 'hantek-dso-' + find_model(filename) + '.fw'
+	open(outfile, 'wb').write(blob)
+	print("saved %d bytes to %s" % (len(blob), outfile))
+except Exception as e:
+	print("Error: %s" % str(e))
diff --git a/science/sigrok-firmware-utils/files/sigrok-fwextract-hantek-dso.1 b/science/sigrok-firmware-utils/files/sigrok-fwextract-hantek-dso.1
new file mode 100644
index 000000000000..3f6bd1942001
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/sigrok-fwextract-hantek-dso.1
@@ -0,0 +1,39 @@
+.TH SIGROK\-FWEXTRACT\-HANTEK\-DSO 1 "Aug 08, 2013"
+.SH "NAME"
+sigrok\-fwextract\-hantek\-dso \- Extract Hantek DSO-2xxx/52xx firmware
+.SH "SYNOPSIS"
+.B sigrok\-fwextract\-hantek\-dso [FILE]
+.SH "DESCRIPTION"
+This tool extracts firmware from the driver that comes with the
+Hantek DSO-2xxx/52xx series USB oscilloscopes. Find the 32-bit
+driver installed on the Windows system -- typically called
+.B DSOxxxx1.sys
+or
+.BR DsoxxxxX861.sys ,
+where xxxx is your device's model.
+.PP
+Use it like this:
+.PP
+.B "  $ sigrok-fwextract-hantek-dso Dso2090X861.sys"
+.br
+.RB "  saved 4730 bytes to hantek-dso-2090.fw"
+.PP
+Copy the resulting file over to the location where libsigrok expects
+to find its firmware files. By default this is
+.BR /usr/local/share/sigrok-firmware .
+.SH OPTIONS
+None.
+.SH "EXIT STATUS"
+Exits with 0 on success, 1 on most failures.
+.SH "SEE ALSO"
+\fBsigrok\-fwextract\-saleae\-logic16\fP(1)
+.SH "BUGS"
+Please report any bugs via Bugzilla
+.RB "(" http://sigrok.org/bugzilla ")"
+or on the sigrok\-devel mailing list
+.RB "(" sigrok\-devel@lists.souceforge.net ")."
+.SH "LICENSE"
+This program is covered by the GNU General Public License (GPL),
+version 3 or later.
+.SH "AUTHORS"
+Please see the individual source code files.
diff --git a/science/sigrok-firmware-utils/files/sigrok-fwextract-saleae-logic16 b/science/sigrok-firmware-utils/files/sigrok-fwextract-saleae-logic16
new file mode 100644
index 000000000000..10fec9e33154
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/sigrok-fwextract-saleae-logic16
@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+##
+## This file is part of the sigrok-util project.
+##
+## Copyright (C) 2013 Marcus Comstedt <marcus@mc.pp.se>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, see <http://www.gnu.org/licenses/>.
+##
+
+import sys
+import struct
+import parseelf
+
+class searcher:
+
+    def reset(this, offs=0):
+        if offs < 0 or offs > this.length:
+            raise Exception('Reset past end of section')
+        this.address = this.baseaddr + offs
+        this.offset = offs
+
+    def skip(this, cnt):
+        if this.offset + cnt > this.length:
+            raise Exception('Skip past end of section')
+        this.address += cnt
+        this.offset += cnt
+
+    def peek(this, cnt, offs=0):
+        if this.offset + offs + cnt > this.length:
+            raise Exception('Peek past end of section')
+        return this.data[this.offset + offs : this.offset + offs + cnt]
+
+    def look_for(this, needle):
+        pos = this.data.find(needle, this.offset)
+        if pos < 0:
+            raise Exception('Needle not found in haystack')
+        this.skip(pos - this.offset)
+
+    def look_for_either(this, needle1, needle2):
+        pos1 = this.data.find(needle1, this.offset)
+        pos2 = this.data.find(needle2, this.offset)
+        if pos1 < 0 and pos2 < 0:
+            raise Exception('Needle not found in haystack')
+        if pos1 < 0 or pos2 < pos1:
+            pos1 = pos2
+        this.skip(pos1 - this.offset)
+
+    def __init__(this, data, addr):
+        this.data = data
+        this.baseaddr = addr
+        this.length = len(data)
+        this.reset()
+
+def search_plt_32(plt, addr):
+    plt.reset()
+    plt.look_for(struct.pack('<BBI', 0xff, 0x25, addr))	# jmp *addr32
+    return plt.address
+
+def search_plt_64(plt, addr):
+    plt.reset()
+    while True:
+        plt.look_for(b'\xff\x25')		# jmpq *offs32(%rip)
+        offs = struct.unpack('<i', plt.peek(4, 2))[0]
+        if plt.address + offs + 6 == addr:
+            return plt.address
+        plt.skip(2)
+
+def find_hex_file_lines_constructor_32(text, hex_file_lines_got, got_plt):
+    while True:
+        text.look_for_either(b'\x8b\xbb', b'\x8b\xb3')	# mov offs32(%ebx),{%edi,%esi}
+        offs = struct.unpack('<i', text.peek(4, 2))[0]
+        if got_plt + offs == hex_file_lines_got:
+            text.skip(6)
+            return
+        text.skip(2)
+
+def find_hex_file_lines_constructor_64(text, hex_file_lines_got):
+    while True:
+        text.look_for(b'\x48\x8b\x2d')		# mov offs32(%rip),%rbp
+        offs = struct.unpack('<i', text.peek(4, 3))[0]
+        if text.address + offs + 7 == hex_file_lines_got:
+            text.skip(7)
+            return
+        text.skip(3)
+
+def parse_hex_file_lines_constructor_32(text, basic_string_plt, got_plt, lines):
+    text.skip(-5)
+    esi = (text.peek(1) == b'\xb3')
+    text.skip(5)
+    cnt = len(lines)
+    while cnt > 0:
+        if text.peek(2) == b'\x8d\x45':		# lea offs8(%ebp),%eax
+            text.skip(3)
+        elif text.peek(2) == b'\x8d\x85':	# lea offs32(%ebp),%eax
+            text.skip(6)
+        if text.peek(1) == (b'\xbf' if esi else b'\xbe'):	# mov $imm32,%esi
+            text.skip(5)
+        elif text.peek(2) == (b'\x31\xff' if esi else b'\x31\xf6'):	# xor %esi,%esi
+            text.skip(2)
+        if text.peek(4) == b'\x89\x44\x24\x08':	# mov %eax,0x8(%esp)
+            text.skip(4)
+        if text.peek(2) == b'\x8d\x83':		# lea offs32(%ebx),%eax
+            straddr = struct.unpack('<i', text.peek(4, 2))[0]
+            text.skip(6)
+            straddr += got_plt
+        else:
+            raise Exception('Expected lea offs32(%ebx),%eax @ ' +
+                            ('0x%x' % text.address))
+        if text.peek(4) == b'\x89\x44\x24\x04':	# mov %eax,0x4(%esp)
+            text.skip(4)
+        if text.peek(3) == (b'\x89\x34\x24' if esi else b'\x89\x3c\x24'):	# mov %edi,(%esp)
+            offs = 0
+            text.skip(3)
+        elif text.peek(2) == (b'\x8d\x46' if esi else b'\x8d\x47'):	# lea offs8(%edi),%eax
+            offs = struct.unpack('<b', text.peek(1, 2))[0]
+            text.skip(3)
+        elif text.peek(2) == (b'\x8d\x86' if esi else b'\x8d\x87'):	# lea offs32(%edi),%eax
+            offs = struct.unpack('<i', text.peek(4, 2))[0]
+            text.skip(6)
+        else:
+            raise Exception('Expected lea offs(%e'+('s' if esi else 'd')+'i),%eax @ ' +
+                            ('0x%x' % text.address))
+        if offs < 0 or offs > (len(lines) << 2) or (offs & 3) != 0:
+            raise Exception('Invalid offset %d' % offs)
+        index = offs >> 2
+        if lines[index] != 0:
+            raise Exception('Line %d filled multiple times' % index)
+        if text.peek(3) == b'\x89\x04\x24':	# mov %eax,(%esp)
+            text.skip(3)
+        if text.peek(1) == b'\xe8':		# call offs32
+            offs = struct.unpack('<i', text.peek(4, 1))[0]
+            text.skip(5)
+            if text.address + offs != basic_string_plt:
+                raise Exception('Expected call ZNSsC1EPKcRKSaIcE@plt @ ' +
+                                ('0x%x' % text.address))
+        else:
+            raise Exception('Expected call ZNSsC1EPKcRKSaIcE@plt @ ' +
+                            ('0x%x' % text.address))
+        if straddr == 0:
+            raise Exception('NULL pointer stored to index %d' % index)
+        lines[index] = straddr
+        cnt -= 1
+
+def parse_hex_file_lines_constructor_64(text, basic_string_plt, lines):
+    cnt = len(lines)
+    while cnt > 0:
+        if text.peek(1) == b'\xbb':		# mov $imm32,%ebx
+            text.skip(5)
+        elif text.peek(2) == b'\x31\xdb':	# xor %ebx,%ebx
+            text.skip(2)
+        if text.peek(4) == b'\x48\x8d\x54\x24':	# lea offs8(%rsp),%rdx
+            text.skip(5)
+        elif text.peek(4) == b'\x48\x8d\x94\x24': # lea offs32(%rsp),%rdx
+            text.skip(8)
+        if text.peek(3) == b'\x48\x8d\x35':	# lea offs32(%rip),%rsi
+            straddr = struct.unpack('<i', text.peek(4, 3))[0]
+            text.skip(7)
+            straddr += text.address
+        else:
+            raise Exception('Expected lea offs(%rip),%rsi @ ' +
+                            ('0x%x' % text.address))
+        if text.peek(3) == b'\x48\x89\xef':	# mov %rbp,%rdi
+            offs = 0
+            text.skip(3)
+        elif text.peek(3) == b'\x48\x8d\x7d':	# lea offs8(%rbp),%rdi
+            offs = struct.unpack('<b', text.peek(1, 3))[0]
+            text.skip(4)
+        elif text.peek(3) == b'\x48\x8d\xbd':	# lea offs32(%rbp),%rdi
+            offs = struct.unpack('<i', text.peek(4, 3))[0]
+            text.skip(7)
+        else:
+            raise Exception('Expected lea offs(%rbp),%rdi @ ' +
+                            ('0x%x' % text.address))
+        if text.peek(1) == b'\xbb':		# mov $imm32,%ebx
+            text.skip(5)
+        elif text.peek(2) == b'\x31\xdb':	# xor %ebx,%ebx
+            text.skip(2)
+        if offs < 0 or offs > (len(lines) << 3) or (offs & 7) != 0:
+            raise Exception('Invalid offset %d' % offs)
+        index = offs >> 3
+        if lines[index] != 0:
+            raise Exception('Line %d filled multiple times' % index)
+        if text.peek(1) == b'\xe8':		# callq offs32
+            offs = struct.unpack('<i', text.peek(4, 1))[0]
+            text.skip(5)
+            if text.address + offs != basic_string_plt:
+                raise Exception('Expected callq ZNSsC1EPKcRKSaIcE@plt @ ' +
+                                ('0x%x' % text.address))
+        else:
+            raise Exception('Expected callq ZNSsC1EPKcRKSaIcE@plt @ ' +
+                            ('0x%x' % text.address))
+        if straddr == 0:
+            raise Exception('NULL pointer stored to index %d' % index)
+        lines[index] = straddr
+        cnt -= 1
+
+def find_reloc(elf, symname):
+    for section, relocs in elf.relocs.items():
+        if 'symbols' in relocs and symname in relocs['symbols']:
+            symnum = relocs['symbols'][symname]['number']
+            for reloc in relocs['relocs']:
+                if reloc['r_sym'] == symnum:
+                    return reloc
+    raise Exception('Unable to find a relocation against ' + symname)
+
+def ihex_to_binary(lines):
+    chunks = {}
+    for line in lines:
+        if line[0] != ':':
+            raise Exception('ihex line does not start with ":"')
+        line = bytes.fromhex(line[1:])
+        if (sum(bytearray(line)) & 0xff) != 0:
+            raise Exception('Invalid checksum in ihex')
+        (byte_count, address, rectype) = struct.unpack('>BHB', line[:4])
+        (data, checksum) = struct.unpack('>%dsB' % (byte_count), line[4:])
+        if rectype == 1 and byte_count == 0:
+            pass
+        elif rectype != 0 or byte_count == 0:
+            raise Exception('Unexpected rectype %d with bytecount %d' %
+                            (rectype, byte_count))
+        elif address in chunks:
+            raise Exception('Multiple ihex lines with address 0x%x' % address)
+        else:
+            chunks[address] = data
+    blob = b''
+    for address in sorted(iter(chunks)):
+        if address < len(blob):
+            raise Exception('Overlapping ihex chunks')
+        elif address > len(blob):
+            blob += b'\x00' * (address - len(blob))
+        blob += chunks[address]
+    return blob
+
+def extract_fx2_firmware(elf, symname, filename):
+    blob = elf.load_symbol(elf.dynsym[symname + 'Count'])
+    count = struct.unpack('<I', blob)[0]
+    got_plt = elf.find_section('.got.plt')['sh_addr']
+    hex_file_lines_got = find_reloc(elf, symname)['r_offset']
+    basic_string_got = find_reloc(elf, '_ZNSsC1EPKcRKSaIcE')['r_offset']
+    pltsec = elf.find_section('.plt')
+    plt = searcher(elf.read_section(pltsec), pltsec['sh_addr'])
+    try:
+        if elf.elf_wordsize == 64:
+            basic_string_plt = search_plt_64(plt, basic_string_got)
+        else:
+            basic_string_plt = search_plt_32(plt, basic_string_got)
+    except:
+        raise Exception('Unable to find a PLT entry for _ZNSsC1EPKcRKSaIcE')
+    textsec = elf.find_section('.text')
+    text = searcher(elf.read_section(textsec), textsec['sh_addr'])
+    while True:
+        try:
+            if elf.elf_wordsize == 64:
+                find_hex_file_lines_constructor_64(text, hex_file_lines_got)
+            else:
+                find_hex_file_lines_constructor_32(text, hex_file_lines_got,
+                                                   got_plt)
+        except:
+            raise Exception('Unable to find constructor for ' + symname)
+        oldoffs = text.offset
+        l = [0]*count
+        try:
+            if elf.elf_wordsize == 64:
+                parse_hex_file_lines_constructor_64(text, basic_string_plt, l)
+            else:
+                parse_hex_file_lines_constructor_32(text, basic_string_plt,
+                                                    got_plt, l)
+            break
+        except KeyError:
+            text.reset(oldoffs)
+    rodatasec = elf.find_section('.rodata')
+    rodata = elf.read_section(rodatasec)
+    lo = rodatasec['sh_addr']
+    hi = lo + rodatasec['sh_size']
+    for i in range(count):
+        addr = l[i]
+        if addr < lo or addr >= hi:
+            raise Exception('Address 0x%x outside of .rodata section' % addr)
+        l[i] = elf.get_name(addr - lo, rodata)
+    blob = ihex_to_binary(l)
+    f = open(filename, 'wb')
+    f.write(blob)
+    f.close()
+    print("saved %d bytes to %s" % (len(blob), filename))
+
+def extract_symbol(elf, symname, filename):
+    blob = elf.load_symbol(elf.dynsym[symname])
+    f = open(filename, 'wb')
+    f.write(blob)
+    f.close()
+    print("saved %d bytes to %s" % (len(blob), filename))
+
+def extract_bitstream(elf, lv):
+    extract_symbol(elf, 'gLogic16Lv' + lv + 'CompressedBitstream',
+                   'saleae-logic16-fpga-' + lv + '.bitstream')
+
+def usage():
+    print("sigrok-fwextract-saleae-logic16 <programfile>")
+    sys.exit()
+
+
+#
+# main
+#
+
+if len(sys.argv) != 2:
+    usage()
+
+try:
+    filename = sys.argv[1]
+    elf = parseelf.elf(filename)
+    if elf.ehdr['e_machine'] != 3 and elf.ehdr['e_machine'] != 62:
+        raise Exception('Unsupported e_machine')
+    extract_fx2_firmware(elf, 'gLogic16HexFileLines', 'saleae-logic16-fx2.fw')
+    extract_bitstream(elf, '18')
+    extract_bitstream(elf, '33')
+except Exception as e:
+    print("Error: %s" % str(e))
diff --git a/science/sigrok-firmware-utils/files/sigrok-fwextract-saleae-logic16.1 b/science/sigrok-firmware-utils/files/sigrok-fwextract-saleae-logic16.1
new file mode 100644
index 000000000000..3766602096ed
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/sigrok-fwextract-saleae-logic16.1
@@ -0,0 +1,40 @@
+.TH SIGROK\-FWEXTRACT\-SALEAE\-LOGIC16 1 "Aug 08, 2013"
+.SH "NAME"
+sigrok\-fwextract\-saleae\-logic16 \- Extract Saleae Logic16 firmware
+.SH "SYNOPSIS"
+.B sigrok\-fwextract\-saleae\-logic16 [FILE]
+.SH "DESCRIPTION"
+This tool extracts FX2 firmware and FPGA bitstreams from the vendor
+software for the Saleae Logic16 USB logic analyzer. Download the Linux
+version (either 32-bit or 64-bit will do), and unpack it to find the
+main binary called "Logic".
+.PP
+In order to extract the firmware/bitstreams, run the following command:
+.PP
+.B "  $ sigrok-fwextract-saleae-logic16 Logic"
+.br
+.RB "  saved 5214 bytes to saleae-logic16-fx2.fw"
+.br
+.RB "  saved 149516 bytes to saleae-logic16-fpga-18.bitstream"
+.br
+.RB "  saved 149516 bytes to saleae-logic16-fpga-33.bitstream"
+.PP
+Copy the resulting files over to the location where libsigrok expects
+to find its firmware files. By default this is
+.BR /usr/local/share/sigrok-firmware .
+.SH OPTIONS
+None.
+.SH "EXIT STATUS"
+Exits with 0 on success, 1 on most failures.
+.SH "SEE ALSO"
+\fBsigrok\-fwextract\-hantek\-dso\fP(1)
+.SH "BUGS"
+Please report any bugs via Bugzilla
+.RB "(" http://sigrok.org/bugzilla ")"
+or on the sigrok\-devel mailing list
+.RB "(" sigrok\-devel@lists.souceforge.net ")."
+.SH "LICENSE"
+This program is covered by the GNU General Public License (GPL),
+version 3 or later.
+.SH "AUTHORS"
+Please see the individual source code files.
diff --git a/science/sigrok-firmware-utils/files/sigrok-fwextract-sysclk-lwla b/science/sigrok-firmware-utils/files/sigrok-fwextract-sysclk-lwla
new file mode 100644
index 000000000000..c9e261e25ba8
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/sigrok-fwextract-sysclk-lwla
@@ -0,0 +1,41 @@
+#! /bin/sh -e
+##
+## This file is part of the sigrok-util project.
+##
+## Copyright (C) 2014 Daniel Elstner <daniel.kitta@gmail.com>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, see <http://www.gnu.org/licenses/>.
+##
+
+infile=$1
+if [ -z "$infile" ]; then
+    echo "Usage: $0 SETUP-EXE" >&2
+    exit 1
+fi
+
+# Verify the checksum to make sure this is the right binary file
+expectsum=f2a9333329200ad1d939d051257f914200cf0c765ff4962b2907dcf30716f455
+set '' $(sha256sum -b "$infile")
+
+if [ "$2" != "$expectsum" ]; then
+    echo "$0: checksum mismatch for '$infile'" >&2
+    echo "$0: make sure you picked the right file (lwla1034_EN_setup.exe on the CD-ROM)" >&2
+    exit 1
+fi
+
+# Extract the firmware binaries from the executable
+dd bs=1 skip=34110338 count=78398 if="$infile" of=sysclk-lwla1034-int.bitstream
+dd bs=1 skip=34266237 count=78247 if="$infile" of=sysclk-lwla1034-extpos.bitstream
+dd bs=1 skip=34344484 count=79145 if="$infile" of=sysclk-lwla1034-extneg.bitstream
+dd bs=1 skip=34578631 count=48525 if="$infile" of=sysclk-lwla1034-off.bitstream
diff --git a/science/sigrok-firmware-utils/files/sigrok-fwextract-sysclk-lwla.1 b/science/sigrok-firmware-utils/files/sigrok-fwextract-sysclk-lwla.1
new file mode 100644
index 000000000000..500f97f07e38
--- /dev/null
+++ b/science/sigrok-firmware-utils/files/sigrok-fwextract-sysclk-lwla.1
@@ -0,0 +1,33 @@
+.TH SIGROK\-FWEXTRACT\-SYSCLK\-LWLA 1 "Jan 04, 2014"
+.SH "NAME"
+sigrok\-fwextract\-sysclk\-lwla \- Extract SysClk LWLA* firmware
+.SH "SYNOPSIS"
+.B sigrok\-fwextract\-sysclk\-lwla SETUP-EXE
+.SH "DESCRIPTION"
+This tool extracts FPGA bitstreams from the vendor software for the SysClk
+LWLA1034 USB logic analyzer. Insert the CD-ROM that ships with the device,
+and locate the Windows installer executable "lwla1034_EN_setup.exe".
+.PP
+In order to extract the bitstreams, run the following command:
+.PP
+.B "  $ sigrok-fwextract-sysclk-lwla lwla1034_EN_setup.exe"
+.PP
+Copy the resulting four bitstream files over to the location where libsigrok
+expects to find its firmware files. By default this is
+.BR /usr/local/share/sigrok-firmware .
+.SH OPTIONS
+None.
+.SH "EXIT STATUS"
+Exits with 0 on success, 1 on most failures.
+.SH "SEE ALSO"
+\fBsigrok\-fwextract\-hantek\-dso\fP(1)
+.SH "BUGS"
+Please report any bugs via Bugzilla
+.RB "(" http://sigrok.org/bugzilla ")"
+or on the sigrok\-devel mailing list
+.RB "(" sigrok\-devel@lists.souceforge.net ")."
+.SH "LICENSE"
+This program is covered by the GNU General Public License (GPL),
+version 3 or later.
+.SH "AUTHORS"
+Please see the individual source code files.
diff --git a/science/sigrok-firmware-utils/pkg-descr b/science/sigrok-firmware-utils/pkg-descr
new file mode 100644
index 000000000000..dcee66b9525d
--- /dev/null
+++ b/science/sigrok-firmware-utils/pkg-descr
@@ -0,0 +1,8 @@
+The sigrok project aims at creating a portable, cross-platform,
+Free/Libre/Open-Source signal analysis software suite that supports
+various device types, such as logic analyzers, MSOs, oscilloscopes,
+multimeters, LCR meters, sound level meters, thermometers, hygrometers,
+anemometers, light meters, DAQs, dataloggers, function generators,
+spectrum analyzers, power supplies, GPIB interfaces, and more.
+
+WWW: http://www.sigrok.org/wiki/Firmware