fmctdc1ns5cha calibration branch

1a37fc28 · Evangelia Gousiou · 96dab0a1 · 1a37fc28 · 1a37fc28 · 1a37fc28
Commit 1a37fc28 authored Jul 30, 2013 by Evangelia Gousiou
20 changed files
--- a/common/PendulumCNT91.py
+++ b/common/PendulumCNT91.py
+# Copyright INCAA Computers, 2012
+# Author: Bert Gooijer <bert.gooijer@incaacomputers.com>
+# Licence: GPL v2 or later.
+# Website: http://www.ohwr.org
+
+import os
+
+class usbtmc:
+    
+    def __init__(self, device):
+	print("Opening: %s" % device)
+        self.device = device
+        self.FILE = os.open(device, os.O_RDWR)
+        
+    def write(self, command):
+        os.write(self.FILE, command)
+        
+    def read(self):
+        return os.read(self.FILE, 4000)
+    
+    def getName(self):
+        self.write("*IDN?")
+        return self.read()
+    
+    def sendReset(self):
+        self.write("*RST")
+        
+    def close(self):
+        os.close(self.FILE)
+        
+class PendulumCNT91:
+    
+    def __init__(self, device):
+        self.meas = usbtmc(device)
+        self.name = self.meas.getName()
+        print self.name
+        
+    def write(self, command):
+        self.meas.write(command)
+        
+    def read(self):
+        return self.meas.read()
+    
+    def reset(self):
+        self.meas.sendReset()
+        
+    def close(self):
+        self.meas.close()
\ No newline at end of file
--- a/common/cp210x/__init__.py
+++ b/common/cp210x/__init__.py
+# -*- coding: utf-8 -*-
+
+__author__ = "Johannes Hölzl <johannes.hoelzl@gmx.de>"
+__license__ = "GNU LGPL"
--- a/common/cp210x/cp210x.py
+++ b/common/cp210x/cp210x.py
--- a/common/cp210x/eeprom.py
+++ b/common/cp210x/eeprom.py
+# -*- coding: utf-8 -*-
+# Copyright (c) 2007 Johannes Hölzl <johannes.hoelzl@gmx.de>
+#
+# This library is covered by the GNU LGPL, read LICENSE for details.
+
+import cp210x
+from cp210x import from_binary, to_binary, iif, VALUES
+
+__all__ = ['EEPROM', 'HexFileError']
+
+POS_BAUDRATE_TABLE  = 0x0000
+POS_PART_NUMBER     = 0x01FF
+POS_PRODUCT_STRING  = 0x0208
+POS_SERIAL_NUMBER   = 0x0307
+POS_PRODUCT_ID      = 0x0390
+POS_VENDOR_ID       = 0x0392
+POS_VERSION         = 0x0394
+POS_CFG_ATTRIBUTES  = 0x03A1
+POS_MAX_POWER       = 0x03A2
+POS_VENDOR_STRING   = 0x03C3
+POS_LOCK_VALUE      = 0x03FF
+
+class HexFileError(StandardError):
+    pass
+
+def checksum(line):
+    return sum(ord(c) for c in line) & 0xFF
+
+def _int_value(position, size, read=lambda x:x, write=lambda x:x):
+    def get(self):
+        return read(from_binary(self.get(position, size)))
+    def set(self, value):
+        self.set(position, to_binary(write(value), size))
+    return property(get, set)
+    
+def _str_value(position, max_size):
+    def get(self):
+        size = from_binary(self.get(position, 1))
+        assert size <= (max_size + 2) and size >= 2
+        assert self.get(position + 1, 1) == '\x03', "Missing 0x03 at %04X" % (position + 1)
+        return self.get(position + 2, size - 2).decode('utf-16-le')
+        
+    def set(self, value):
+        encoded = value.encode('utf-16-le')
+        assert len(encoded) <= max_size
+        self.set(position, chr(len(encoded) + 2) + '\x03' + encoded)
+        
+    return property(get, set)
+
+class EEPROM(object):
+    START_ADDRESS = 0x3600
+    def __init__(self, content=None):
+        if isinstance(content, str) or content is None:
+            assert content is None or len(content) == cp210x.SIZE_EEPROM
+            self.content = content
+        elif isinstance(content, cp210x.Cp210xProgrammer):
+            self.content = content.get_eeprom_content()
+        else:
+            self.parse_hex_file(content.read())
+
+    def write_to_cp210x(self, cp210xDevice):
+        cp210xDevice.set_eeprom_content(self.content)
+            
+    def parse_hex_file(self, hex_content):
+        self.content = ''
+        address = self.START_ADDRESS
+        for tag in hex_content.split('\n'):
+            if not tag.startswith(':'):
+                raise HexFileError("Line doesn't start with ':'")
+            
+            try:
+                content = tag[1:].decode('hex')
+            except TypeError:
+                raise HexFileError("Hex data expected")
+            
+            if len(content) < 5:
+                raise HexFileError("Line to short")
+
+            if checksum(content) != 0:
+                raise HexFileError("Checksum error")
+        
+            size = from_binary(content[0])
+            tag_address = from_binary(content[1:3], le=False)
+            tag_type = from_binary(content[3:4])
+            line = content[4:-1]
+            
+            if tag_type == 0x00:
+                if tag_address != address:
+                    raise HexFileError("Expected address %04X but found %04X"
+                                       % (address, tag_address))
+                self.content += line
+                address += len(line)
+            elif tag_type == 0x01:
+                if size != 0 or len(line) != 0:
+                    raise HexFileError("Defekt end tag")
+                break
+                
+            else:
+                raise HexFileError("Unknown tag type %02X" % tag_type)
+
+    def build_hex_file(self):
+        for tag_start in range(0, len(self.content), 0x10):
+            line = self.content[tag_start:tag_start+0x10]
+            address = self.START_ADDRESS + tag_start
+            tag = (to_binary(len(line), 1) + 
+                   to_binary(address, le=False) + 
+                   '\x00' + 
+                   line)
+            cs = checksum(tag)
+            if cs == 0:
+                tag += '\x00'
+            else:
+                tag += chr(0x100 - cs)
+            yield ":%s\n" % tag.encode('hex')
+        yield ":00000001FF\n"
+
+    def write_hex_file(self, f):
+        if isinstance(f, str):
+            f = file(f, 'wb')
+            do_close = True
+        else:
+            do_close = False
+        for line in self.build_hex_file():
+            f.write(line)
+        if do_close:
+            f.close()
+
+    def read_hex_file(self, f):
+        if isinstance(f, str):
+            f = file(f, 'rb')
+            do_close = True
+        else:
+            do_close = False
+        self.parse_hex_file(f.read())
+        if do_close:
+            f.close()
+
+    def get(self, pos, length):
+        return self.content[pos:pos+length]
+    
+    def set(self, pos, data):
+        self.content = (self.content[:pos] + 
+                        data + 
+                        self.content[pos + len(data):])
+   
+    def _get_baudrate_table(self):
+        dat = self.get(POS_BAUDRATE_TABLE, cp210x.SIZE_BAUDRATE_TABLE)
+        return [cp210x.parse_baudrate_cfg(dat[pos:pos+cp210x.SIZE_BAUDRATE_CFG])
+                for pos in range(0, cp210x.SIZE_BAUDRATE_TABLE, 
+                                 cp210x.SIZE_BAUDRATE_CFG)]
+    def _set_baudrate_table(self, baudrates):
+        assert len(baudrates) == cp210x.SIZE_BAUDRATES
+        self.set(POS_BAUDRATE_TABLE, 
+                 ''.join(cp210x.build_baudrate_cfg(*cfg) for cfg in baudrates))
+    baudrate_table = property(_get_baudrate_table, _set_baudrate_table)
+    product_string = _str_value(POS_PRODUCT_STRING, cp210x.SIZE_PRODUCT_STRING)
+    serial_number = _str_value(POS_SERIAL_NUMBER, cp210x.SIZE_SERIAL_NUMBER)
+    part_number = _int_value(POS_PART_NUMBER, 1)
+    product_id = _int_value(POS_PRODUCT_ID, 2)
+    vendor_id = _int_value(POS_VENDOR_ID, 2)
+    version = _int_value(POS_VERSION, 2, 
+                         cp210x.from_bcd2, cp210x.to_bcd2)
+    bus_powered = _int_value(POS_CFG_ATTRIBUTES, 1, 
+                             lambda a: bool(a & 0x40), 
+                             lambda a: iif(a, 0xC0, 0x80))
+    max_power = _int_value(POS_MAX_POWER, 1, lambda p: p*2, cp210x.to_div2)
+    vendor_string = _str_value(POS_VENDOR_STRING, cp210x.SIZE_VENDOR_STRING)
+    locked = _int_value(POS_LOCK_VALUE, 1, 
+                        lambda l: l == cp210x.LCK_LOCKED, 
+                        lambda b: iif(b, cp210x.LCK_LOCKED, 
+                                      cp210x.LCK_UNLOCKED))
+        
+    def get_values(self):
+        return dict((name, getattr(self, name)) for name, type in VALUES)
+
+    def set_values(self, values):
+        for name, value in values.items():
+            setattr(self, name, value)
+
+            
--- a/common/cp210x/usb.py
+++ b/common/cp210x/usb.py
+# Python interface for "usb.h" version 0.1.4.4.4
+#
+# Copyright (c) 2005 Robert Hoelzl <robert.hoelzl@gmx.de>
+# Copyright (c) 2007 Johannes Hoelzl <johannes.hoelzl@gmx.de>
+#
+# This library is covered by the GNU LGPL, read LICENSE for details.
+
+from ctypes import *
+import sys
+
+class LibUsbNotInstalled(OSError):
+    pass
+
+try:
+    if sys.platform == 'darwin':
+        PATH_MAX = 1024
+        dll=cdll.LoadLibrary("libusb.dylib")
+    elif sys.platform == 'linux2':
+        PATH_MAX = 4096
+        dll=cdll.LoadLibrary("libusb.so")
+    else:
+        raise NotImplementedError("Platform %s not supported by usb.py" % sys.platform)
+except OSError:
+    raise LibUsbNotInstalled() 
+    
+
+# helper functions
+def func(f, *args, **retval):
+    f.restype = retval.get('retval', None)
+    f.argtypes = args
+    if retval.has_key('rename'): globals()[retval['rename']] = f
+    else: globals()[f.__name__[4:]] = f
+    
+# constants
+CLASS_PER_INTERFACE = 0
+USB_CLASS_AUDIO = 1
+CLASS_COMM = 2
+CLASS_HID = 3
+CLASS_PRINTER = 7
+CLASS_PTP = 6
+CLASS_MASS_STORAGE = 8
+CLASS_HUB = 9
+CLASS_DATA = 10
+CLASS_VENDOR_SPEC = 0xff
+
+DT_DEVICE = 0x01
+DT_CONFIG = 0x02
+DT_STRING = 0x03
+DT_INTERFACE = 0x04
+DT_ENDPOINT = 0x05
+
+DT_HID = 0x21
+DT_REPORT = 0x22
+DT_PHYSICAL = 0x23
+DT_HUB = 0x29
+
+DT_DEVICE_SIZE = 18
+DT_CONFIG_SIZE = 9
+DT_INTERFACE_SIZE = 9
+DT_ENDPOINT_SIZE = 7
+DT_ENDPOINT_AUDIO_SIZE = 9    # Audio extension
+DT_HUB_NONVAR_SIZE = 7
+
+
+class descriptor_header(Structure): _fields_ = [
+    ("bLength", c_uint8),
+    ("bDescriptorType", c_uint8) ]
+
+
+class string_descriptor(Structure): _fields_ = [
+    ("bLength", c_uint8),
+    ("bDescriptorType", c_uint8),
+    ("wData", c_uint*1) ]
+
+class hid_descriptor(Structure): _fields_ = [
+    ("bLength", c_uint8),
+    ("bDescriptorType", c_uint8),
+    ("bcdHID", c_uint16),
+    ("bCountryCode", c_uint8),
+    ("bNumDescriptors", c_uint8) ]
+
+MAXENDPOINTS = 32
+class endpoint_descriptor(Structure): _fields_ = [
+    ("bLength", c_uint8),
+    ("bDescriptorType", c_uint8),
+    ("bEndpointAddress", c_uint8),
+    ("bmAttributes", c_uint8),
+    ("wMaxPacketSize", c_uint16),
+    ("bInterval", c_uint8),
+    ("bRefresh", c_uint8),
+    ("bSynchAddress", c_uint8),
+
+    ("extra", POINTER(c_uint8)),
+    ("extralen", c_int) ]
+
+
+ENDPOINT_ADDRESS_MASK = 0x0f    # in bEndpointAddress
+ENDPOINT_DIR_MASK = 0x80
+
+ENDPOINT_TYPE_MASK = 0x03    # in bmAttributes
+ENDPOINT_TYPE_CONTROL = 0
+ENDPOINT_TYPE_ISOCHRONOUS = 1
+ENDPOINT_TYPE_BULK = 2
+ENDPOINT_TYPE_INTERRUPT = 3
+
+MAXINTERFACES = 32
+class interface_descriptor(Structure): _fields_ = [
+    ("bLength", c_uint8),
+    ("bDescriptorType", c_uint8),
+    ("bInterfaceNumber", c_uint8),
+    ("bAlternateSetting", c_uint8),
+    ("bNumEndpoints", c_uint8),
+    ("bInterfaceClass", c_uint8),
+    ("bInterfaceSubClass", c_uint8),
+    ("bInterfaceProtocol", c_uint8),
+    ("iInterface", c_uint8),
+
+    ("endpoint", POINTER(endpoint_descriptor)),
+
+    ("extra", POINTER(c_uint8)),
+    ("extralen", c_int) ]
+
+MAXALTSETTING = 128      # Hard limit
+class interface(Structure): _fields_ = [
+    ("altsetting", POINTER(interface_descriptor)),
+
+    ("num_altsetting", c_int) ]
+
+MAXCONFIG = 8
+class config_descriptor(Structure): _fields_ = [
+    ("bLength", c_uint8),
+    ("bDescriptorType", c_uint8),
+    ("wTotalLength", c_uint16),
+    ("bNumInterfaces", c_uint8),
+    ("bConfigurationValue", c_uint8),
+    ("iConfiguration", c_uint16),
+    ("bmAttributes", c_uint8),
+    ("MaxPower", c_uint8),
+
+    ("interface", POINTER(interface)),
+
+    ("extra", POINTER(c_uint8)),  # Extra descriptors
+    ("extralen", c_int) ]
+
+class device_descriptor(Structure): _fields_ = [
+    ("bLength", c_uint8),
+    ("bDescriptorType", c_uint8),
+    ("bcdUSB", c_uint16),
+    ("bDeviceClass", c_uint8),
+    ("bDeviceSubClass", c_uint8),
+    ("bDeviceProtocol", c_uint8),
+    ("bMaxPacketSize0", c_uint8),
+    ("idVendor", c_uint16),
+    ("idProduct", c_uint16),
+    ("bcdDevice", c_uint16),
+    ("iManufacturer", c_uint8),
+    ("iProduct", c_uint8),
+    ("iSerialNumber", c_uint8),
+    ("bNumConfigurations", c_uint8) ]
+
+class ctrl_setup(Structure): _fields_ = [
+    ("bRequestType", c_uint8),
+    ("bRequest", c_uint8),
+    ("wValue", c_uint16),
+    ("wIndex", c_uint16),
+    ("wLength", c_uint16) ]
+
+
+REQ_GET_STATUS = 0x00
+REQ_CLEAR_FEATURE = 0x01
+# 0x02 is reserved
+REQ_SET_FEATURE = 0x03
+# 0x04 is reserved
+REQ_SET_ADDRESS = 0x05
+REQ_GET_DESCRIPTOR = 0x06
+REQ_SET_DESCRIPTOR = 0x07
+REQ_GET_CONFIGURATION = 0x08
+REQ_SET_CONFIGURATION = 0x09
+REQ_GET_INTERFACE = 0x0A
+REQ_SET_INTERFACE = 0x0B
+REQ_SYNCH_FRAME = 0x0C
+
+TYPE_STANDARD = (0x00 << 5)
+TYPE_CLASS = (0x01 << 5)
+TYPE_VENDOR = (0x02 << 5)
+TYPE_RESERVED = (0x03 << 5)
+
+RECIP_DEVICE = 0x00
+RECIP_INTERFACE = 0x01
+RECIP_ENDPOINT = 0x02
+RECIP_OTHER = 0x03
+
+ENDPOINT_IN = 0x80
+ENDPOINT_OUT = 0x00
+
+# Error codes
+ERROR_BEGIN = 500000
+
+#if 1
+#define USB_LE16_TO_CPU(x) do { x = ((x & 0xff) << 8) | ((x & 0xff00) >> 8); } while(0)
+#else
+#define USB_LE16_TO_CPU(x)
+#endif
+
+device_p = POINTER("device")
+bus_p = POINTER("bus")
+
+class device(Structure): _fields_ = [
+    ("next", device_p),
+    ("prev", device_p),
+    ("filename", c_char*(PATH_MAX + 1)),
+
+    ("bus", bus_p),
+    ("descriptor", device_descriptor),
+    ("config", POINTER(config_descriptor)),
+
+    ("dev", c_void_p),    # Darwin support
+
+    ("devnum", c_char),
+
+    ("num_children", c_uint8),
+    ("children", POINTER(device_p)) ]
+SetPointerType(device_p, device)
+
+class bus(Structure): _fields_ = [
+    ("next", bus_p),
+    ("prev", bus_p),
+
+    ("dirname", c_char*(PATH_MAX + 1)),
+
+    ("devices", device_p),
+    ("location", c_uint),
+
+    ("root_dev", device_p) ]
+SetPointerType(bus_p, bus)
+
+
+dev_handle_p = c_void_p
+
+
+func(dll.usb_open, device_p, retval=dev_handle_p, rename="_open")
+func(dll.usb_close, dev_handle_p, retval=c_int)
+func(dll.usb_get_string, dev_handle_p, c_int, c_int, c_char_p, c_int, retval=c_int)
+func(dll.usb_get_string_simple, dev_handle_p, c_int, c_char_p, c_int, retval=c_int)
+func(dll.usb_get_descriptor_by_endpoint, dev_handle_p, c_int, c_uint8, c_uint8, c_void_p, c_int, retval=c_int)
+func(dll.usb_get_descriptor, dev_handle_p, c_uint8, c_uint8, c_void_p, c_int, retval=c_int)
+
+func(dll.usb_bulk_write, dev_handle_p, c_int, c_char_p, c_int, c_int, retval=c_int)
+func(dll.usb_bulk_read, dev_handle_p, c_int, c_char_p, c_int, c_int, retval=c_int)
+func(dll.usb_interrupt_write, dev_handle_p, c_int, c_char_p, c_int, c_int, retval=c_int)
+func(dll.usb_interrupt_read, dev_handle_p, c_int, c_char_p, c_int, c_int, retval=c_int)
+func(dll.usb_control_msg, dev_handle_p, c_int, c_int, c_int, c_int, c_char_p, c_int, c_int, retval=c_int)
+func(dll.usb_set_configuration, dev_handle_p, c_int, retval=c_int)
+func(dll.usb_claim_interface, dev_handle_p, c_int, retval=c_int)
+func(dll.usb_release_interface, dev_handle_p, c_int, retval=c_int)
+func(dll.usb_set_altinterface, dev_handle_p, c_int, retval=c_int)
+func(dll.usb_resetep, dev_handle_p, c_uint16, retval=c_int)
+func(dll.usb_clear_halt, dev_handle_p, c_uint16, retval=c_int)
+func(dll.usb_reset, dev_handle_p, retval=c_int)
+     
+func(dll.usb_strerror, retval=c_char_p)
+     
+func(dll.usb_init)
+func(dll.usb_set_debug, c_int)
+func(dll.usb_find_busses, retval=c_int)
+func(dll.usb_find_devices, retval=c_int)
+func(dll.usb_device, dev_handle_p, retval=device_p, rename="get_device")
+func(dll.usb_get_busses, retval=bus_p)
+
+func(dll.usb_detach_kernel_driver_np, dev_handle_p, c_int, retval=c_int)
+
+# workaround for bug in ctypes 0.9.6 (cannot create functions with c_void_p as retval)
+def open(dev):
+    return cast(_open(dev), dev_handle_p)
--- a/common/cp210x/valuefile.py
+++ b/common/cp210x/valuefile.py
+# -*- coding: utf-8 -*-
+# Copyright (c) 2007 Johannes Hölzl <johannes.hoelzl@gmx.de>
+#
+# This library is covered by the GNU LGPL, read LICENSE for details.
+
+# For documentation of the baudrate table see:
+#
+# [AN205] Silicon Labs Application Note 205 Rev. 0.3
+# http://www.silabs.com/public/documents/tpub_doc/anote/Microcontrollers/Interface/en/an205.pdf
+
+import re
+from ConfigParser import ConfigParser
+
+import cp210x
+from cp210x import VALUES, SIZE_BAUDRATES
+
+__all__ = ['read_file', 'write_file', 'update_values', 'PrescalerIsZero',
+           'ValuesFileError']
+
+class ValuesError(StandardError):
+    pass
+
+class PrescalerIsZero(ValuesError):
+    pass
+
+class ValuesFileError(ValuesError):
+    pass
+
+version_pattern = re.compile(r'^\s*(\d\d?)\.(\d\d?)\s*$')
+def read_version(s):
+    match = version_pattern.match(s)
+    if match is None:
+        raise ValueError("Version does not match 'xx.yy'")
+    return (int(match.group(1)), int(match.group(2)))
+def write_version(v):
+    return "%d.%02d" % v
+
+def read_hex(s):
+    return int(s.strip(), 16)
+
+def write_hex(num):
+    return "%04X" % num
+
+def write_bool(b):
+    if b:
+        return 'yes'
+    else:
+        return 'no'
+
+def read_bool(s):
+    s = s.strip().lower()
+    if s not in ['true', 'yes', 'false', 'no']:
+        raise ValueError("Boolean must be either 'true', 'yes', 'false' or 'no'.")
+    return s in ['true', 'yes']
+
+def read_baudrate_info(s):
+    values = s.split(',')
+    if len(values) != 3:
+         raise ValueError("Baudrate info must be three comma-separated items")
+    try:
+        baudgen = read_hex(values[0])
+    except ValueError:
+        raise ValueError("The first baudrate info must be a hex-value")
+    try:
+        timer0 = read_hex(values[1])
+    except ValueError:
+        raise ValueError("The second baudrate info must be a hex-value")
+    try:
+        prescale = int(values[2])
+    except ValueError:
+        raise ValueError("The thirdbaudrate info must be a number")
+    return (baudgen, timer0, prescale)
+
+TYPES = {
+    'boolean':  (read_bool, write_bool),
+    'int':      (int, str),
+    'id':       (read_hex, write_hex),
+    'string':   (str, str),
+    'version':  (read_version, write_version),
+}
+
+def read_file(fp):
+    cp = ConfigParser()
+    if isinstance(fp, str):
+        cp.read([fp])
+    else:
+        cp.readfp(fp)
+    
+    values = {}
+    
+    for name, type in VALUES:
+        if name is 'baudrate_table':
+            continue
+        reader, _ = TYPES[type]
+        if cp.has_option('usb device', name):
+            try:
+                values[name] = reader(cp.get('usb device', name))
+            except ValueError, err:
+                raise ValuesFileError("Key '%s': %s" % (name, str(err)))
+    
+    if cp.has_section('baudrate table'):
+        baudrate_table = []
+        for name, value in cp.items('baudrate table'):
+            try:
+                baudrate = int(name)
+            except ValueError:
+                raise ValuesFileError("Key names in 'baudrate table' must be"
+                                      " baudrate numbers.")
+            try:
+                baudrate_table.append(read_baudrate_info(value) + (baudrate, ))
+            except ValueError, err:
+                raise ValuesFileError("Wrong baudrate info %i: %s"
+                                      % (baudrate, str(err)))
+        baudrate_table.sort(key=(lambda i: i[3]), reverse=True)
+        
+        values['baudrate_table'] = baudrate_table
+    return values
+
+def write_file(fp, values):
+    fp.write("[usb device]\n")
+    
+    for name, type in VALUES:
+        if name == 'baudrate_table':
+            continue
+        _, writer = TYPES[type]
+        if name in values:
+            fp.write("%s = %s\n" % (name, writer(values[name])))
+
+    if 'baudrate_table' in values:
+        fp.write("\n")
+        fp.write("[baudrate table]\n")
+        for (baudgen, timegen, prescaler, 
+             baudrate) in sorted(values['baudrate_table'], key=(lambda i: i[3]),
+                                 reverse=True):
+            fp.write("%7d = %04X, %04X, %d # %s\n"
+                     % (baudrate, baudgen, timegen, prescaler,
+                        show_baudrate(baudgen, timegen, prescaler)))
+
+def calc_baudrate(baudgen, timegen, prescaler):
+    # This formulas are from AN205 page 5.
+    if prescaler == 0:
+        raise PrescalerIsZero("Prescaler is 0")
+    baudrate = (24000000. / prescaler) / (0x10000 - baudgen)
+    return (baudrate, (0x10000 - timegen) * 2)
+
+def show_baudrate(baudgen, timegen, prescaler):
+    try:
+        baudrate, timeout = calc_baudrate(baudgen, timegen, prescaler)
+    except PrescalerIsZero:
+        return "Wrong data, Prescaler is 0."
+    if timeout >= 1000:
+        timeout = "%1.3f ms" % (float(timeout) / 1000)
+    else:
+        timeout = "%d us" % timeout
+    if baudrate is None:
+        return ", %s" % (baudrate, timeout)
+    else:
+        return "%7.0f Baud, %s" % (baudrate, timeout)
+
+def update_values(v, new, dev):
+    old_baudrate_table = v.get('baudrate_table')
+    new_baudrate_table = new.get('baudrate_table')
+    
+    v.update(new)
+
+    # update baudrate table
+    # it is needed, that the baudrate table has 32 entries when it is written
+    # to the eeprom or device.
+    if ((old_baudrate_table is not None or new_baudrate_table is not None) and
+        (new_baudrate_table is None or 
+         len(new_baudrate_table) < SIZE_BAUDRATES)):
+         
+        if old_baudrate_table is not None:
+            if len(old_baudrate_table) < SIZE_BAUDRATES:
+                baudrate_table = old_baudrate_table
+            else:
+                baudrate_table = list(merge_baudrate_table(dev.baudrate_table, 
+                                                           old_baudrate_table))
+        else:
+            baudrate_table = dev.baudrate_table
+                                                               
+        if new_baudrate_table:
+            baudrate_table = list(merge_baudrate_table(baudrate_table, 
+                                                       new_baudrate_table))        
+        v['baudrate_table'] = baudrate_table
+    
+            
+            
+def merge_baudrate_table(old, new):
+    for (old_info, (start, stop)) in zip(old, REQUEST_BAUDRATE_RANGES):
+        for baudgen, timer, prescaler, baudrate in new:
+            if ((start is None or baudrate <= start) and 
+                baudrate >= stop):
+                yield (baudgen, timer, prescaler, baudrate)
+                break
+        else:
+            yield old_info
+            
+REQUEST_BAUDRATE_RANGES = [
+# The table data is from AN205 Table 1 on page 1.
+#     Start     End       Default Baudrate
+    (None,    2457601), #  Undefined
+    (2457600, 1474561), #  Undefined
+    (1474560, 1053258), #  Undefined
+    (1053257,  670255), #  921600
+    ( 670254,  567139), #  576000
+    ( 567138,  491521), #  500000
+    ( 491520,  273067), #  460800
+    ( 273066,  254235), #  256000
+    ( 254234,  237833), #  250000
+    ( 237832,  156869), #  230400
+    ( 156868,  129348), #  153600
+    ( 129347,  117029), #  128000
+    ( 117028,   77609), #  115200
+    (  77608,   64112), #   76800
+    (  64111,   58054), #   64000
+    (  58053,   56281), #   57600
+    (  56280,   51559), #   56000
+    (  51558,   38602), #   51200
+    (  38601,   28913), #   38400
+    (  28912,   19251), #   28800
+    (  19250,   16063), #   19200
+    (  16062,   14429), #   16000
+    (  14428,    9613), #   14400
+    (   9612,    7208), #    9600
+    (   7207,    4804), #    7200
+    (   4803,    4001), #    4800
+    (   4000,    2401), #    4000
+    (   2400,    1801), #    2400
+    (   1800,    1201), #    1800
+    (   1200,     601), #    1200
+    (    600,     301), #     600
+    (    300,      57), #     300
+]
--- a/common/cp210x_eeprom.py
+++ b/common/cp210x_eeprom.py
+#!   /usr/bin/env   python
+#    coding: utf8
+
+# Copyright CERN, 2011
+# Author: Matthieu Cattin <matthieu.cattin@cern.ch>
+# Licence: GPL v2 or later.
+# Website: http://www.ohwr.org
+
+import sys
+import rr
+import time
+import os
+import re
+from ctypes import *
+
+from ptsexcept import *
+
+from cp210x import usb, valuefile, cp210x
+from cp210x.eeprom import EEPROM
+
+
+"""
+cp210x_eeprom: Access to USB-UART bridge CP2103 EEPROM
+
+Note: The EEPROM is used to store calibration data.
+The data is stored as a string in the "Product String".
+Format example: "234.45, 163.08, 174.98, 205.81"
+
+"""
+
+
+CALIBR_CHANNELS =  ['ch1-ch2', 'ch1-ch3', 'ch1-ch4', 'ch1-ch5']
+
+class CP210xEepromOperationError(Exception):
+    def __init__(self, msg):
+        self.msg = msg
+    def __str__(self):
+        return ("CP210x EEPROM: %s" %(self.msg))
+
+class CCP210x_Eeprom:
+
+    def __init__(self, vid, pid):
+        usb.init()
+        usb_patterns = []
+        vid = int(vid, 16)
+        pid = int(pid, 16)
+        usb_patterns.append(dict(idVendor=vid, idProduct=pid))
+        self.dev = [item for item in cp210x.Cp210xProgrammer.list_devices(usb_patterns)]
+        self.dev = self.dev[0]
+
+
+    def get_calibr_data(self):
+        self.dev.open()
+        try:
+            eeprom = EEPROM(self.dev)
+        except:
+            raise CP210xEepromOperationError('Cannot open device.')
+        finally:
+            self.dev.close()
+        eeprom_value = eeprom.get_values()
+
+        product_string = eeprom_value['product_string']
+
+        #print "Product string: \"%s\"" % product_string
+        calibr_string_list = product_string.split(' ')
+
+        if len(calibr_string_list) != 4:
+            raise CP210xEepromOperationError('Product string has the wrong format.')
+        calibr_data = {}
+        for i in range(len(calibr_string_list)):
+            pattern = r'\b[0-9]{3}\.[0-9]{2}\b'
+            if re.search(pattern, calibr_string_list[i]):
+                calibr_data[CALIBR_CHANNELS[i]] = calibr_string_list[i]
+            else:
+                raise CP210xEepromOperationError('Product string has the wrong format.')
+
+        return calibr_data
+
+
+    def set_calibr_data(self, data):
+        self.dev.open()
+        product_string = data[CALIBR_CHANNELS[0]] + ' ' + data[CALIBR_CHANNELS[1]] + ' ' + data[CALIBR_CHANNELS[2]] + ' ' + data[CALIBR_CHANNELS[3]]
+        #print "New product string value: \"%s\"" % product_string
+        try:
+            self.dev.set_product_string(product_string)
+            print "Calibration data written to cp210x EEPROM."
+        finally:
+            self.dev.close()
+
--- a/common/gn4124GIT.py
+++ b/common/gn4124GIT.py
+#!/usr/bin/python
+
+import sys
+import rr
+import time
+import csr
+
+class CGN4124:
+
+    # Host registers (BAR12), for DMA items storage
+    HOST_BAR = 0xC
+    HOST_DMA_CARRIER_START_ADDR = 0x00
+    HOST_DMA_HOST_START_ADDR_L = 0x04
+    HOST_DMA_HOST_START_ADDR_H = 0x08
+    HOST_DMA_LENGTH = 0x0C
+    HOST_DMA_NEXT_ITEM_ADDR_L = 0x10
+    HOST_DMA_NEXT_ITEM_ADDR_H = 0x14
+    HOST_DMA_ATTRIB = 0x18
+
+    # GN4124 chip registers (BAR4)
+    GN4124_BAR = 0x4
+    R_PCI_SYS_CFG = 0x800
+    R_CLK_CSR = 0x808
+    R_INT_CFG0 = 0x820
+    R_GPIO_DIR_MODE = 0xA04
+    R_GPIO_INT_MASK_CLR = 0xA18
+    R_GPIO_INT_MASK_SET = 0xA1C
+    R_GPIO_INT_STATUS = 0xA20
+    R_GPIO_INT_VALUE = 0xA28
+
+    CLK_CSR_DIVOT_MASK = 0x3F0
+    INT_CFG0_GPIO = 15
+    GPIO_INT_SRC = 8
+
+    # GN4124 core registers (BAR0)
+    R_DMA_CTL = 0x00
+    R_DMA_STA = 0x04
+    R_DMA_CARRIER_START_ADDR = 0x08
+    R_DMA_HOST_START_ADDR_L = 0x0C
+    R_DMA_HOST_START_ADDR_H = 0x10
+    R_DMA_LENGTH = 0x14
+    R_DMA_NEXT_ITEM_ADDR_L = 0x18
+    R_DMA_NEXT_ITEM_ADDR_H = 0x1C
+    R_DMA_ATTRIB = 0x20
+
+    DMA_CTL_START = 0
+    DMA_CTL_ABORT = 1
+    DMA_CTL_SWAP = 2
+    DMA_STA = ['Idle','Done','Busy','Error','Aborted']
+    DMA_ATTRIB_LAST = 0
+    DMA_ATTRIB_DIR = 1
+
+    def rd_reg(self, bar, addr):
+        return self.bus.iread(bar, addr, 4)
+
+    def wr_reg(self, bar, addr, value):
+        self.bus.iwrite(bar, addr, 4, value)
+
+    def __init__(self, bus, csr_addr):
+        self.bus = bus
+        self.dma_csr = csr.CCSR(bus, csr_addr)
+        self.dma_item_cnt = 0
+        # Get page list
+        self.pages = self.bus.getplist()
+        # Shift by 12 to get the 32-bit physical addresses
+        self.pages = [addr << 12 for addr in self.pages]
+        self.set_interrupt_config()
+        # Enable interrupt from gn4124
+        self.bus.irqena()
+
+    # Set local bus frequency
+    def set_local_bus_freq(self, freq):
+        # freq in MHz
+        # LCLK = (25MHz*(DIVFB+1))/(DIVOT+1)
+        # DIVFB = 31
+        # DIVOT = (800/LCLK)-1
+        divot = int(round((800/freq)-1,0))
+        #print '%d' % divot
+        data = 0xe001f00c + (divot << 4)
+        #print '%.8X' % data
+        #print 'Set local bus freq to %dMHz' % int(round(800/(divot+1),0))
+        self.wr_reg(self.GN4124_BAR, self.R_CLK_CSR, data)
+
+    # Get local bus frequency
+    #   return: frequency in MHz
+    def get_local_bus_freq(self):
+        reg = self.rd_reg(self.GN4124_BAR, self.R_CLK_CSR)
+        divot = ((reg & self.CLK_CSR_DIVOT_MASK)>>4)
+        return (800/(divot + 1))
+
+    # Get physical addresses of the pages allocated to GN4124
+    def get_physical_addr(self):
+        return self.pages
+
+    # Enable interrupt handling in the driver
+    def irq_en(self):
+        self.bus.irqena()
+
+    # Wait for interrupt
+    def wait_irq(self):
+        # Add here reading of the interrupt source (once the irq core will be present)
+        return self.bus.irqwait()
+
+    # GN4124 RSTOUT33 assert/de-assert cycle
+    def rstout33_cycle(self):
+        # assert RSTOUT33 pin
+        self.wr_reg(self.GN4124_BAR, self.R_PCI_SYS_CFG, 0x00021040)
+        # de-assert RSTOUT33 pin
+        self.wr_reg(self.GN4124_BAR, self.R_PCI_SYS_CFG, 0x00025000)
+
+    # GN4124 interrupt configuration
+    def set_interrupt_config(self):
+        # Set interrupt line from FPGA (GPIO8) as input
+        self.wr_reg(self.GN4124_BAR, self.R_GPIO_DIR_MODE, (1<<self.GPIO_INT_SRC))
+        # Set interrupt mask for all GPIO except for GPIO8
+        self.wr_reg(self.GN4124_BAR, self.R_GPIO_INT_MASK_SET, ~(1<<self.GPIO_INT_SRC))
+        # Make sure the interrupt mask is cleared for GPIO8
+        self.wr_reg(self.GN4124_BAR, self.R_GPIO_INT_MASK_CLR, (1<<self.GPIO_INT_SRC))
+        # Interrupt on rising edge of GPIO8
+        self.wr_reg(self.GN4124_BAR, self.R_GPIO_INT_VALUE, (1<<self.GPIO_INT_SRC))
+        # GPIO as interrupt 0 source
+        self.wr_reg(self.GN4124_BAR, self.R_INT_CFG0, (1<<self.INT_CFG0_GPIO))
+
+    # Get DMA controller status
+    def get_dma_status(self):
+        reg = self.dma_csr.rd_reg(self.R_DMA_STA)
+        if(reg > len(self.DMA_STA)):
+            print("DMA status register : %.8X") % reg
+            raise Exception('Invalid DMA status')
+        else:
+            return self.DMA_STA[reg]
+
+    # Configure DMA byte swapping
+    #   0 = A1 B2 C3 D4 (straight)
+    #   1 = B2 A1 D4 C3 (swap bytes in words)
+    #   2 = C3 D4 A1 B2 (swap words)
+    #   3 = D4 C3 B2 A1 (invert bytes)
+    def set_dma_swap(self, swap):
+        if(swap > 3):
+            raise Exception('Invalid swapping configuration : %d') % swap
+        else:
+            self.dma_csr.wr_reg(self.R_CTL, (swap << self.DMA_CTL_SWAP))
+
+    # Add DMA item (first item is on the board, the following in the host memory)
+    #   carrier_addr, host_addr, length and next_item_addr are in bytes
+    #   dma_dir  = 1 -> PCIe to carrier
+    #   dma_dir  = 0 -> carrier to PCIe
+    #   dma_last = 0 -> last item in the transfer
+    #   dma_last = 1 -> more item in the transfer
+    #   Only supports 32-bit host address
+    def add_dma_item(self, carrier_addr, host_addr, length, dma_dir, last_item):
+        if(0 == self.dma_item_cnt):
+            # write the first DMA item in the carrier
+            self.dma_csr.wr_reg(self.R_DMA_CARRIER_START_ADDR, carrier_addr)
+            self.dma_csr.wr_reg(self.R_DMA_HOST_START_ADDR_L, (host_addr & 0xFFFFFFFF))
+            self.dma_csr.wr_reg(self.R_DMA_HOST_START_ADDR_H, (host_addr >> 32))
+            self.dma_csr.wr_reg(self.R_DMA_LENGTH, length)
+            self.dma_csr.wr_reg(self.R_DMA_NEXT_ITEM_ADDR_L, (self.pages[0] & 0xFFFFFFFF))
+            self.dma_csr.wr_reg(self.R_DMA_NEXT_ITEM_ADDR_H, 0x0)
+            attrib = (dma_dir << self.DMA_ATTRIB_DIR) + (last_item << self.DMA_ATTRIB_LAST)
+            self.dma_csr.wr_reg(self.R_DMA_ATTRIB, attrib)
+        else:
+            # write nexy DMA item(s) in host memory
+            # uses page 0 to store DMA items
+            # current and next item addresses are automatically set
+            current_item_addr = (self.dma_item_cnt-1)*0x20
+            next_item_addr = (self.dma_item_cnt)*0x20
+            self.wr_reg(self.HOST_BAR, self.HOST_DMA_CARRIER_START_ADDR + current_item_addr, carrier_addr)
+            self.wr_reg(self.HOST_BAR, self.HOST_DMA_HOST_START_ADDR_L + current_item_addr, host_addr)
+            self.wr_reg(self.HOST_BAR, self.HOST_DMA_HOST_START_ADDR_H + current_item_addr, 0x0)
+            self.wr_reg(self.HOST_BAR, self.HOST_DMA_LENGTH + current_item_addr, length)
+            self.wr_reg(self.HOST_BAR, self.HOST_DMA_NEXT_ITEM_ADDR_L + current_item_addr,
+                                self.pages[0] + next_item_addr)
+            self.wr_reg(self.HOST_BAR, self.HOST_DMA_NEXT_ITEM_ADDR_H + current_item_addr, 0x0)
+            attrib = (dma_dir << self.DMA_ATTRIB_DIR) + (last_item << self.DMA_ATTRIB_LAST)
+            self.wr_reg(self.HOST_BAR, self.HOST_DMA_ATTRIB + current_item_addr, attrib)
+        self.dma_item_cnt += 1
+
+    # Start DMA transfer
+    def start_dma(self):
+        self.dma_item_cnt = 0
+        self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_START, 1)
+        # The following two lines should be removed
+        # when the GN4124 vhdl core will implement auto clear of start bit
+        #while(('Idle' == self.get_dma_status()) or
+        #      ('Busy' == self.get_dma_status())):
+        #    pass
+        self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_START, 0)
+
+    # Abort DMA transfer
+    def abort_dma(self):
+        self.dma_item_cnt = 0
+        self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_ABORT, 1)
+        # The following two lines should be removed
+        # when the GN4124 vhdl core will implement auto clear of start bit
+        while('Aborted' != self.get_dma_status()):
+            pass
+        self.dma_csr.wr_bit(self.R_DMA_CTL, self.DMA_CTL_ABORT, 0)
+
+    # Get memory page
+    def get_memory_page(self, page_nb):
+        data = []
+        for i in range(2**10):
+            data.append(self.rd_reg(self.HOST_BAR, (page_nb<<12)+(i<<2)))
+        return data
+
+    # Set memory page
+    def set_memory_page(self, page_nb, pattern):
+        for i in range(2**10):
+            self.wr_reg(self.HOST_BAR, (page_nb<<12)+(i<<2), pattern)
--- a/common/usb_box/calibr_box.py
+++ b/common/usb_box/calibr_box.py
+#!   /usr/bin/env   python
+#    coding: utf8
+
+# Copyright CERN, 2011
+# Author: Matthieu Cattin <matthieu.cattin@cern.ch>
+# Licence: GPL v2 or later.
+# Website: http://www.ohwr.org
+
+import sys
+import time
+import os
+
+import cp210x_gpio
+
+
+"""
+calibr_box: Access to calibration box via USB-UART bridge CP2103
+
+"""
+
+class CalibrBoxOperationError(Exception):
+    def __init__(self, msg):
+        self.msg = msg
+    def __str__(self):
+        return ("Calibration box: %s" %(self.msg))
+
+
+class CCalibr_box:
+	def __init__(self, device):
+                self.cp210x = cp210x_gpio.CCP210x(device)
+                # Select AWG as default output
+#                self.cp210x.gpio_get();
+                self.cp210x.gpio_set(0x0);
+
+		self.state = 0;
+
+        def select_output(self, out):
+	
+#		print("Cur %x" % self.state)
+		self.state = self.state & 0x3;
+
+		if(out == 1):
+		    self.state = self.state | ( 0xc );
+		elif(out == 2):
+		    self.state = self.state | ( 0x8 );
+		elif(out == 3):
+		    self.state = self.state | ( 0x4 );
+		elif(out == 4):
+		    self.state = self.state | ( 0x0 );
+                else:
+                    raise CalibrBoxOperationError("Invalid output selection!")
+		self.cp210x.gpio_set(self.state)
+
+
+	def select_trigger_loopback(self, tloop):
+	    if(tloop):
+		self.state = self.state | 2;
+	    else:
+		self.state = self.state & ~2;
+
+	    self.cp210x.gpio_set(self.state)
+
--- a/common/usb_box/cp210x_gpio.py
+++ b/common/usb_box/cp210x_gpio.py
+#!   /usr/bin/env	python
+#    coding: utf8
+
+import fcntl, struct, termios, os
+import time
+import array
+import struct
+from ctypes import *
+
+
+class CCP210x:
+	def __init__(self, device):
+		self.fd = open(device, 'wb')
+
+	def gpio_set(self, mask):
+		print("gpio_set %x" % mask),
+		f = array.array('L', [0])
+		f[0] = (mask << 8) | 0xff;
+		fcntl.ioctl(self.fd, 0x8001, f, 0)
+
+	def gpio_get(self):
+		f = array.array('L', [0])
+		ret = fcntl.ioctl(self.fd.fileno(), 0x8000, f, 1)
+		print("gpio_get %x" % f[0]),
+		return f[0]
+
+# Create an object (the 0 is used to generate the name, eg. /dev/ttyUSB0
+#gpio = cp210x_gpio(0)
+
+# Infinite test loop
+#while 1:
+#	# Pass the mask of the 4 bits as a hex number
+#	gpio.gpio_set(0xf)
+#	# Returns the states of the 4 bits as hex number
+#	print gpio.gpio_get()
+#	time.sleep(1)
+#	gpio.gpio_set(0x0)
+#	print gpio.gpio_get()
+#	time.sleep(1)
--- a/common/usb_box/find_usb_tty.py
+++ b/common/usb_box/find_usb_tty.py
+#!   /usr/bin/env   python
+#    coding: utf8
+
+import  glob
+import  os
+import  re
+
+
+class CttyUSB:
+
+    def __init__(self):
+        pass
+
+    def find_usb_tty(self, vendor_id = None, product_id = None) :
+        tty_devs    = []
+
+        for dn in glob.glob('/sys/bus/usb/devices/*') :
+            try     :
+                vid = int(open(os.path.join(dn, "idVendor" )).read().strip(), 16)
+                pid = int(open(os.path.join(dn, "idProduct")).read().strip(), 16)
+                #print "dn:%s vid:%s pid:%s" % (dn,vid,pid)
+                if  ((vendor_id is None) or (vid == vendor_id)) and ((product_id is None) or (pid == product_id)) :
+                    dns = glob.glob(os.path.join(dn, os.path.basename(dn) + "*"))
+                    for sdn in dns :
+                        for fn in glob.glob(os.path.join(sdn, "*")) :
+                            if  re.search(r"\/ttyUSB[0-9]+$", fn) :
+                                tty_devs.append("/dev/" + os.path.basename(fn))
+                                pass
+                            pass
+                        pass
+                    pass
+            except ( ValueError, TypeError, AttributeError, OSError, IOError ) :
+                pass
+            pass
+
+        return tty_devs
+
+
+#print find_usb_tty()
+#print find_usb_tty(0x10c4,0xea60)
+#print find_usb_tty(0x0403,0x6001)
--- a/cp210x-driver/Makefile
+++ b/cp210x-driver/Makefile
+obj-m = cp210x.o
+KVERSION = $(shell uname -r)
+all:
+	make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
+clean:
+	make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean
+
--- a/cp210x-driver/cp210x.c
+++ b/cp210x-driver/cp210x.c
--- a/cp210x-driver/cp210x.ko
+++ b/cp210x-driver/cp210x.ko
--- a/cp210x-driver/cp210x.mod.c
+++ b/cp210x-driver/cp210x.mod.c
+#include <linux/module.h>
+#include <linux/vermagic.h>
+#include <linux/compiler.h>
+
+MODULE_INFO(vermagic, VERMAGIC_STRING);
+
+struct module __this_module
+__attribute__((section(".gnu.linkonce.this_module"))) = {
+	.name = KBUILD_MODNAME,
+	.init = init_module,
+#ifdef CONFIG_MODULE_UNLOAD
+	.exit = cleanup_module,
+#endif
+	.arch = MODULE_ARCH_INIT,
+};
+
+static const struct modversion_info ____versions[]
+__used
+__attribute__((section("__versions"))) = {
+	{ 0x35ec255d, "module_layout" },
+	{ 0x1976aa06, "param_ops_bool" },
+	{ 0x3539443, "usb_serial_deregister_drivers" },
+	{ 0xdf6a71a4, "usb_serial_register_drivers" },
+	{ 0x73c9cdb0, "usb_serial_generic_open" },
+	{ 0x6143a69d, "dev_warn" },
+	{ 0x53662107, "tty_encode_baud_rate" },
+	{ 0x6339a8bc, "mutex_unlock" },
+	{ 0xcf510c4a, "mutex_lock" },
+	{ 0x41b8c132, "usb_serial_generic_close" },
+	{ 0xcea0a119, "kmalloc_caches" },
+	{ 0x41ad0272, "kmem_cache_alloc_trace" },
+	{ 0xd44c22ec, "usb_reset_device" },
+	{ 0x93d085b2, "dev_set_drvdata" },
+	{ 0x50eedeb8, "printk" },
+	{ 0x37a0cba, "kfree" },
+	{ 0x64d0da33, "usb_control_msg" },
+	{ 0x12da5bb2, "__kmalloc" },
+	{ 0x35af9caf, "dev_err" },
+	{ 0xddffa24, "dev_get_drvdata" },
+	{ 0xb4390f9a, "mcount" },
+};
+
+static const char __module_depends[]
+__used
+__attribute__((section(".modinfo"))) =
+"depends=usbserial";
+
+MODULE_ALIAS("usb:v045Bp0053d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0471p066Ad*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0489pE000d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0489pE003d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0745p1000d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v08E6p5501d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v08FDp000Ad*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0BEDp1100d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0BEDp1101d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0FCFp1003d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0FCFp1004d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v0FCFp1006d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10A6pAA26d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10ABp10C5d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10B5pAC70d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p0F91d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p1101d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p1601d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p800Ad*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p803Bd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8044d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p804Ed*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8053d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8054d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8066d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p806Fd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p807Ad*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p80CAd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p80DDd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p80F6d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8115d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p813Dd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p813Fd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p814Ad*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p814Bd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8156d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p815Ed*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p818Bd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p819Fd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81A6d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81A9d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81ACd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81ADd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81C8d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81E2d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81E7d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81E8d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p81F2d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8218d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p822Bd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p826Bd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8293d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p82F9d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8341d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8382d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p83A8d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p83D8d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8411d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8418d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p846Ed*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8477d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p85EAd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p85EBd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8664d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4p8665d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pEA60d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pEA61d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pEA70d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pEA80d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pEA71d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pF001d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pF002d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pF003d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C4pF004d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10C5pEA61d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v10CEpEA6Ad*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v13ADp9999d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v1555p0004d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v166Ap0303d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v16D6p0001d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v16DCp0010d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v16DCp0011d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v16DCp0012d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v16DCp0015d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v17A8p0001d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v17A8p0005d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v17F4pAAAAd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v1843p0200d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v18EFpE00Fd*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v1BE3p07A6d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v3195pF190d*dc*dsc*dp*ic*isc*ip*");
+MODULE_ALIAS("usb:v413Cp9500d*dc*dsc*dp*ic*isc*ip*");
+
+MODULE_INFO(srcversion, "FF7E88FED57F3623F48F6A3");
--- a/gnurabbit/python/rr_loader_lib.so
+++ b/gnurabbit/python/rr_loader_lib.so
--- a/gnurabbit/python/rrlib.so
+++ b/gnurabbit/python/rrlib.so
--- a/gnurabbit/user/fpga_loader
+++ b/gnurabbit/user/fpga_loader
--- a/gnurabbit/user/libfpga_loader.so
+++ b/gnurabbit/user/libfpga_loader.so
--- a/test/fmctdc1ns5cha/calibration/firmwares/fmc_delay_spec.bin
+++ b/test/fmctdc1ns5cha/calibration/firmwares/fmc_delay_spec.bin