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
+# -*- 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.
+"""Provides access to the EEPROM of Silabs CP210x devices
+
+The following classes are available:
+
+class Cp210xProgrammer:
+    Provides direct access to the CP2101, can be used to write single data
+    directly or via an EEPROM image.
+
+class EEPROM:
+    Can be used to read or write a hex file containing the EEPROM content
+    of an CP2101. Provides also access to the single fields in the EEPROM.
+"""
+
+import ctypes
+import usb
+
+__all__ = ['Cp210xProgrammer', 'Cp210xError']
+
+CP2101_UART         = 0x00
+CP2101_CONFIG       = 0xFF
+
+CP2101_UART_ENABLE  = 0x0001
+CP2101_UART_DISABLE = 0x0000
+
+REG_VENDOR_ID       = 0x3701
+REG_PRODUCT_ID      = 0x3702
+REG_PRODUCT_STRING  = 0x3703
+REG_SERIAL_NUMBER   = 0x3704
+REG_CFG_ATTRIBUTES  = 0x3705
+REG_MAX_POWER       = 0x3706
+REG_VERSION         = 0x3707
+REG_UNKNOWN         = 0x3708
+REG_EEPROM          = 0x3709
+REG_LOCK_VALUE      = 0x370A
+REG_PART_NUMBER     = 0x370B
+
+SIZE_EEPROM         = 0x0400
+SIZE_PRODUCT_STRING = 0x007D
+SIZE_SERIAL_NUMBER  = 0x003F
+SIZE_BAUDRATES      = 32
+SIZE_BAUDRATE_CFG   = 10
+SIZE_BAUDRATE_TABLE = SIZE_BAUDRATES * SIZE_BAUDRATE_CFG
+SIZE_VENDOR_STRING  = 24
+
+LCK_LOCKED          = 0x00
+LCK_UNLOCKED        = 0xFF
+
+VID_SILABS          = 0x10C4
+PID_CP210x          = 0xEA60
+
+VALUES = [
+    ('product_string', 'string'),
+    ('serial_number',  'string'),
+    ('product_id',     'id'),
+    ('vendor_id',      'id'),
+    ('version',        'version'),
+    ('bus_powered',    'boolean'),
+    ('max_power',      'int'),
+    ('locked',         'boolean'),
+    ('part_number',    'int'),
+    ('vendor_string',  'string'),
+    ('baudrate_table', 'list'),
+]
+
+def iif(v, a, b):
+    if v:
+        return a
+    else:
+        return b
+
+def to_div2(p):
+    value = int(p / 2)
+    if (value * 2) < p:
+        value += 1
+    return value
+    
+def to_bcd(i):
+    assert i >= 0 and i <= 99
+    return (i // 10) << 4 | (i % 10)
+
+def to_bcd2( (i, j) ):
+    return to_bcd(i) << 8 | to_bcd(j)
+
+def from_bcd(num):
+    return num & 0x0F + (num >> 4) * 10
+
+def from_bcd2(data):
+    return (from_bcd(data >> 8), from_bcd(data & 0xFF))
+
+def from_binary(data, le=True):
+    value = 0
+    if le:
+        data = data[::-1]
+    for byte in data:
+        value = value << 8 | ord(byte)
+    return value
+
+def to_binary(value, size=2, le=True):
+    data = ''
+    for i in range(size):
+        data += chr(value & 0xFF)
+        value >>= 8
+    if le:
+        return data
+    else:
+        return data[::-1]
+    
+def parse_baudrate_cfg(data):
+    return (from_binary(data[0:2], le=False), 
+            from_binary(data[2:4], le=False), 
+            from_binary(data[4:5]),
+            from_binary(data[6:10]))
+
+def build_baudrate_cfg(baudgen, timer0reload, prescaler, baudrate):
+    return (to_binary(baudgen, le=False) + to_binary(timer0reload, le=False) + 
+            to_binary(prescaler, 1) + '\x00' + to_binary(baudrate, 4))
+
+class Cp210xError(IOError):
+    pass
+
+class DeviceLocked(Cp210xError):
+    pass
+
+class Cp210xProgrammer(object):
+    """Program an Silabs CP2101, CP2102 or CP2103
+    
+    This modul provides access to Silabs CP210x devices to set some USB
+    descriptor fields and some USB descriptor strings. 
+
+    The following fields can be set:
+
+     * Vendor ID
+     * Product ID
+     * Product String
+     * Serial Number
+     * Device Version
+     * Bus Powered
+     * max. Power consumption
+ 
+    Either use libusb to find a device, and provide the device description
+    to the constructor, or use Cp210xProgrammer.list_device() to list all
+    devices matching certain pattern.
+    
+    To progamm the device open() it, set the data, and close() it. To have the
+    changed fields reread call reset() before closing it.
+    """
+    
+    TIMEOUT = 300 #ms
+    
+    @classmethod
+    def list_devices(self, patterns=[{ 'idVendor': VID_SILABS, 
+                                       'idProduct': PID_CP210x }]):
+        """Yields a list of devices matching certain patterns.
+        
+        param patterns: This must be a list of dictionaries or pairs of string.
+            Each device in the usb tree is matched against all pattern in the
+            list. 
+            
+            When an item is a dictionary all fields of the descriptors
+            are compared against the corresponding values in the dictionary. If
+            each value is equal, the device is yielded.
+            
+            When an item is a pair of strings. The first string must be the
+            dirname of the bus and the second string the filename of the device.
+        
+        For example:
+
+        >> list(Cp210xProgrammer.list_device([{ 'idVendor': VID_SILABS, 
+                                           'idProduct': PID_CP210x }]))
+        [device(...)]
+        
+        """
+        
+        usb.find_busses()
+        usb.find_devices()
+        
+        bus = usb.get_busses()
+        while bus:
+            dev = bus.contents.devices
+            while dev:
+                for pattern in patterns:
+                    if isinstance(pattern, dict):
+                        for name, value in pattern.items():
+                            if getattr(dev.contents.descriptor, name) != value:
+                                break
+                        else:
+                            yield self(dev)
+                            break
+                    elif isinstance(pattern, tuple):
+                        if (bus.contents.dirname == pattern[0] and
+                            dev.contents.filename == pattern[1]):
+                            yield self(dev)
+                            break
+                dev = dev.contents.next
+            bus = bus.contents.next
+    
+    def __init__(self, dev_info):
+        self.dev_info = dev_info
+        self.handle = None
+        self._locked = None
+        
+    def open(self):
+        """Opens the device.
+        
+        Only after an successful call to open() data can be read from and
+        written to the device. 
+
+        Claims all resources associated with this device.
+        """
+        self.handle = usb.open(self.dev_info)
+        if self.handle == 0:
+            self.handle = None
+            raise Cp210xError("Can't open device.")
+        usb.set_configuration(self.handle, 1)
+        usb.claim_interface(self.handle, 0)
+
+    def reset(self):
+        """Force the USB stack to reset the device.
+        
+        Resets the device through an hard reset over the port to which the
+        device is connected. After that happend the EEPROM content in the device
+        is reread and the device's descriptors are the one written to it.
+        """
+        assert self.handle is not None
+        usb.reset(self.handle)
+    
+    def close(self):
+        """Closes the device.
+        
+        Releases all resources associated with this device.
+        """
+        assert self.handle is not None
+        usb.release_interface(self.handle, 0)
+        usb.close(self.handle)
+        self.handle = None
+    
+    def __del__(self):
+        if self.handle is not None:
+            self.close()
+
+    def _set_config(self, value, index=0, data=None, request=CP2101_CONFIG):
+        assert self.handle is not None
+        if self.get_locked():
+            raise DeviceLocked()
+            
+        if data is not None:
+            data_length = len(data)
+        else:
+            data_length = 0
+        res = usb.control_msg(self.handle, usb.ENDPOINT_OUT | usb.TYPE_VENDOR, 
+                              request, value, index, data, data_length,
+                              self.TIMEOUT)
+        if res < 0:
+            raise Cp210xError("Unable to send request %04X result=%d"
+                              % (value, res))
+
+    def _set_config_string(self, value, content, max_length):
+        assert isinstance(content, basestring)
+        encoded = content.encode('utf-16-le')
+        assert len(encoded) <= max_length
+        self._set_config(value, data=chr(len(encoded) + 2) + "\x03" + encoded)
+
+    def _get_config(self, value, length, index=0, request=CP2101_CONFIG):
+        assert self.handle is not None
+        data = ctypes.create_string_buffer(length)
+        res = usb.control_msg(self.handle, usb.ENDPOINT_IN | usb.TYPE_VENDOR, 
+                              request, value, index, data, length,
+                              self.TIMEOUT)
+        if res < 0:
+            raise Cp210xError("Unable to send request, %04X result=%d"
+                              % (value, res))
+        return data.raw[:res]
+            
+    def _get_int8_config(self, value, index=0, request=CP2101_CONFIG):
+        return ord(self._get_config(value, 1, index=index, request=request))
+
+    def _get_int16_config(self, value, index=0, request=CP2101_CONFIG):
+        data = self._get_config(value, 2, index=index, request=request)
+        return ord(data[0]) << 8 | ord(data[1])
+    
+    def get_eeprom_content(self):
+        """Reads the entire EEPROM content as one big 1024-byte blob.
+        """
+        return self._get_config(REG_EEPROM, SIZE_EEPROM)
+    
+    def get_baudrate_content(self):
+        """Return the baudrate table as binary data.
+        """
+        return self._get_config(REG_EEPROM, SIZE_BAUDRATE_TABLE)
+
+    def get_baudrate_table(self):
+        """Returns the baudrate table.
+        
+        A list containing 4-tuples are returnes.
+        Each tuple containes the following data:
+        
+         * BaudGen: Value used to generate the real baudrate.
+         * Time0Reset: Value used to generate the usb timeout.
+         * Prescaler: Used to generate the real baudrate.
+         * Baudrate: The baudrate which activates this entry.
+        """
+        data = self.get_baudrate_content()
+        return [parse_baudrate_cfg(data[pos:pos+SIZE_BAUDRATE_CFG])
+                for pos in range(0, SIZE_BAUDRATE_TABLE, SIZE_BAUDRATE_CFG)]
+        
+    def set_baudrate_table(self, baudrates):
+        """Writes the baudrate table.
+        
+        See get_baudrate_table() for the structure of the table.
+        """
+        assert len(baudrates) == SIZE_BAUDRATES
+        self.set_baudrate_content(data=''.join(build_baudrate_cfg(*cfg) 
+                                               for cfg in baudrates))
+    baudrate_table = property(get_baudrate_table, set_baudrate_table)
+        
+    def get_part_number(self):
+        """ The part number of the device.
+        
+        Returns: 1 for an CP2101
+                 2 for an CP2102
+                 3 for an CP2103
+        """
+        return self._get_int8_config(REG_PART_NUMBER)
+    
+    def get_locked(self):
+        """ The lock value of the device.
+        
+        When True is returnes no data can be written to the device.
+        """
+        if self._locked is None:
+            self._locked = self._get_int8_config(REG_LOCK_VALUE) == LCK_LOCKED
+        return self._locked
+    
+    def set_eeprom_content(self, content):
+        """Writes an 1024-byte blob to the EEPROM
+        """
+        assert len(content) == SIZE_EEPROM, ("EEPROM data must be %i bytes."
+                                             % SIZE_EEPROM)
+        assert isinstance(content, str), "EEPROM data must be string."
+        self._set_config(REG_EEPROM, data=content)
+    
+    def set_product_id(self, pid):
+        """Sets the Product ID
+        """
+        assert pid > 0x0000 and pid < 0xFFFF
+        self._set_config(REG_PRODUCT_ID, pid)
+        
+    def set_vendor_id(self, vid):
+        """Sets the Vendor ID
+        """
+        assert vid > 0x0000 and vid < 0xFFFF
+        self._set_config(REG_VENDOR_ID, vid)
+    
+    def set_product_string(self, product_string):
+        """Sets the product string.
+        
+        Be aware that the string will be stored as UTF-16 encoded and should not
+        exceed SIZE_PRODUCT_STRING 
+        """
+        self._set_config_string(REG_PRODUCT_STRING, product_string, 
+                                SIZE_PRODUCT_STRING)
+    
+    def set_serial_number(self, serial_number):
+        self._set_config_string(REG_SERIAL_NUMBER, serial_number, 
+                                SIZE_SERIAL_NUMBER)
+    
+    def set_max_power(self, max_power):
+        assert max_power >= 0 and max_power <= 500
+        self._set_config(REG_MAX_POWER, to_div2(max_power))
+    
+    def set_bus_powered(self, bus_powered):
+        if bus_powered:
+            self._set_config(REG_CFG_ATTRIBUTES, 0xC0)
+        else:
+            self._set_config(REG_CFG_ATTRIBUTES, 0x80)
+
+    def set_version(self, version):
+        self._set_config(REG_VERSION, to_bcd2(version))
+
+    def set_locked(self, locked):
+        """ The lock value of the device.
+        
+        When True is returnes no data can be written to the device.
+        """
+        if locked:
+            self._set_config(REG_LOCK_VALUE, LCK_LOCKED)
+        else:
+            self._set_config(REG_LOCK_VALUE, LCK_UNLOCKED)
+
+    def set_values(self, values):
+        for name, value in values.items():
+            if name not in ['part_number', 'vendor_string']:
+                getattr(self, "set_" + name) (value)
+            
--- 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
+/*
+ * Silicon Laboratories CP210x USB to RS232 serial adaptor driver
+ *
+ * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk)
+ *
+ *	This program is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU General Public License version
+ *	2 as published by the Free Software Foundation.
+ *
+ * Support to set flow control line levels using TIOCMGET and TIOCMSET
+ * thanks to Karl Hiramoto karl@hiramoto.org. RTSCTS hardware flow
+ * control thanks to Munir Nassar nassarmu@real-time.com
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/usb.h>
+#include <linux/uaccess.h>
+#include <linux/usb/serial.h>
+
+/*
+ * Version Information
+ */
+#define DRIVER_VERSION "v0.09"
+#define DRIVER_DESC "Silicon Labs CP210x RS232 serial adaptor driver"
+
+/*
+ * Function Prototypes
+ */
+static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *);
+static void cp210x_close(struct usb_serial_port *);
+static int cp210x_ioctl(struct tty_struct *tty,
+	unsigned int cmd, unsigned long arg);
+static void cp210x_get_termios(struct tty_struct *,
+	struct usb_serial_port *port);
+static void cp210x_get_termios_port(struct usb_serial_port *port,
+	unsigned int *cflagp, unsigned int *baudp);
+static void cp210x_change_speed(struct tty_struct *, struct usb_serial_port *,
+							struct ktermios *);
+static void cp210x_set_termios(struct tty_struct *, struct usb_serial_port *,
+							struct ktermios*);
+static int cp210x_tiocmget(struct tty_struct *);
+static int cp210x_tiocmset(struct tty_struct *, unsigned int, unsigned int);
+static int cp210x_tiocmset_port(struct usb_serial_port *port,
+		unsigned int, unsigned int);
+static void cp210x_break_ctl(struct tty_struct *, int);
+static int cp210x_startup(struct usb_serial *);
+static void cp210x_release(struct usb_serial *);
+static void cp210x_dtr_rts(struct usb_serial_port *p, int on);
+
+static bool debug;
+
+static const struct usb_device_id id_table[] = {
+	{ USB_DEVICE(0x045B, 0x0053) }, /* Renesas RX610 RX-Stick */
+	{ USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
+	{ USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
+	{ USB_DEVICE(0x0489, 0xE003) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
+	{ USB_DEVICE(0x0745, 0x1000) }, /* CipherLab USB CCD Barcode Scanner 1000 */
+	{ USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
+	{ USB_DEVICE(0x08FD, 0x000A) }, /* Digianswer A/S , ZigBee/802.15.4 MAC Device */
+	{ USB_DEVICE(0x0BED, 0x1100) }, /* MEI (TM) Cashflow-SC Bill/Voucher Acceptor */
+	{ USB_DEVICE(0x0BED, 0x1101) }, /* MEI series 2000 Combo Acceptor */
+	{ USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
+	{ USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */
+	{ USB_DEVICE(0x0FCF, 0x1006) }, /* Dynastream ANT development board */
+	{ USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
+	{ USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
+	{ USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
+	{ USB_DEVICE(0x10C4, 0x0F91) }, /* Vstabi */
+	{ USB_DEVICE(0x10C4, 0x1101) }, /* Arkham Technology DS101 Bus Monitor */
+	{ USB_DEVICE(0x10C4, 0x1601) }, /* Arkham Technology DS101 Adapter */
+	{ USB_DEVICE(0x10C4, 0x800A) }, /* SPORTident BSM7-D-USB main station */
+	{ USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
+	{ USB_DEVICE(0x10C4, 0x8044) }, /* Cygnal Debug Adapter */
+	{ USB_DEVICE(0x10C4, 0x804E) }, /* Software Bisque Paramount ME build-in converter */
+	{ USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */
+	{ USB_DEVICE(0x10C4, 0x8054) }, /* Enfora GSM2228 */
+	{ USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
+	{ USB_DEVICE(0x10C4, 0x806F) }, /* IMS USB to RS422 Converter Cable */
+	{ USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
+	{ USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
+	{ USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */
+	{ USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
+	{ USB_DEVICE(0x10C4, 0x8115) }, /* Arygon NFC/Mifare Reader */
+	{ USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
+	{ USB_DEVICE(0x10C4, 0x813F) }, /* Tams Master Easy Control */
+	{ USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
+	{ USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
+	{ USB_DEVICE(0x10C4, 0x8156) }, /* B&G H3000 link cable */
+	{ USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
+	{ USB_DEVICE(0x10C4, 0x818B) }, /* AVIT Research USB to TTL */
+	{ USB_DEVICE(0x10C4, 0x819F) }, /* MJS USB Toslink Switcher */
+	{ USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */
+	{ USB_DEVICE(0x10C4, 0x81A9) }, /* Multiplex RC Interface */
+	{ USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */
+	{ USB_DEVICE(0x10C4, 0x81AD) }, /* INSYS USB Modem */
+	{ USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
+	{ USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
+	{ USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
+	{ USB_DEVICE(0x10C4, 0x81E8) }, /* Zephyr Bioharness */
+	{ USB_DEVICE(0x10C4, 0x81F2) }, /* C1007 HF band RFID controller */
+	{ USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
+	{ USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */
+	{ USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
+	{ USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
+	{ USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
+	{ USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
+	{ USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
+	{ USB_DEVICE(0x10C4, 0x83A8) }, /* Amber Wireless AMB2560 */
+	{ USB_DEVICE(0x10C4, 0x83D8) }, /* DekTec DTA Plus VHF/UHF Booster/Attenuator */
+	{ USB_DEVICE(0x10C4, 0x8411) }, /* Kyocera GPS Module */
+	{ USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
+	{ USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
+	{ USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
+	{ USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
+	{ USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
+	{ USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
+	{ USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
+	{ USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
+	{ USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
+	{ USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */
+	{ USB_DEVICE(0x10C4, 0xEA80) }, /* Silicon Labs factory default */
+	{ USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
+	{ USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */
+	{ USB_DEVICE(0x10C4, 0xF002) }, /* Elan Digital Systems USBwave12 */
+	{ USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */
+	{ USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
+	{ USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
+	{ USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */
+	{ USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
+	{ USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */
+	{ USB_DEVICE(0x166A, 0x0303) }, /* Clipsal 5500PCU C-Bus USB interface */
+	{ USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
+	{ USB_DEVICE(0x16DC, 0x0010) }, /* W-IE-NE-R Plein & Baus GmbH PL512 Power Supply */
+	{ USB_DEVICE(0x16DC, 0x0011) }, /* W-IE-NE-R Plein & Baus GmbH RCM Remote Control for MARATON Power Supply */
+	{ USB_DEVICE(0x16DC, 0x0012) }, /* W-IE-NE-R Plein & Baus GmbH MPOD Multi Channel Power Supply */
+	{ USB_DEVICE(0x16DC, 0x0015) }, /* W-IE-NE-R Plein & Baus GmbH CML Control, Monitoring and Data Logger */
+	{ USB_DEVICE(0x17A8, 0x0001) }, /* Kamstrup Optical Eye/3-wire */
+	{ USB_DEVICE(0x17A8, 0x0005) }, /* Kamstrup M-Bus Master MultiPort 250D */
+	{ USB_DEVICE(0x17F4, 0xAAAA) }, /* Wavesense Jazz blood glucose meter */
+	{ USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */
+	{ USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
+	{ USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
+	{ USB_DEVICE(0x3195, 0xF190) }, /* Link Instruments MSO-19 */
+	{ USB_DEVICE(0x413C, 0x9500) }, /* DW700 GPS USB interface */
+	{ } /* Terminating Entry */
+};
+
+MODULE_DEVICE_TABLE(usb, id_table);
+
+struct cp210x_port_private {
+	__u8                    bInterfaceNumber;
+	__u8			bPartNumber;
+};
+
+/*static struct usb_driver cp210x_driver = {
+	.name		= "cp210x",
+	.probe		= usb_serial_probe,
+	.disconnect	= usb_serial_disconnect,
+	.id_table	= id_table,
+	.no_dynamic_id	= 	1,
+};*/
+
+static struct usb_serial_driver cp210x_device = {
+	.driver = {
+		.owner =	THIS_MODULE,
+		.name = 	"cp210x",
+	},
+//	.usb_driver		= &cp210x_driver,
+	.id_table		= id_table,
+	.num_ports		= 1,
+	.bulk_in_size		= 256,
+	.bulk_out_size		= 256,
+	.open			= cp210x_open,
+	.close			= cp210x_close,
+	.ioctl			= cp210x_ioctl,
+	.break_ctl		= cp210x_break_ctl,
+	.set_termios		= cp210x_set_termios,
+	.tiocmget 		= cp210x_tiocmget,
+	.tiocmset		= cp210x_tiocmset,
+	.attach			= cp210x_startup,
+	.release                = cp210x_release,
+	.dtr_rts		= cp210x_dtr_rts
+};
+
+static struct usb_serial_driver * const serial_drivers[] = {
+	&cp210x_device, NULL
+};
+
+
+/* Part number definitions */
+#define CP2101_PARTNUM		0x01
+#define CP2102_PARTNUM		0x02
+#define CP2103_PARTNUM		0x03
+#define CP2104_PARTNUM		0x04
+#define CP2105_PARTNUM		0x05
+#define CP2108_PARTNUM		0x08
+
+/* IOCTLs */
+#define IOCTL_GPIOGET		0x8000
+#define IOCTL_GPIOSET		0x8001
+
+/* Config request types */
+#define REQTYPE_HOST_TO_INTERFACE	0x41
+#define REQTYPE_INTERFACE_TO_HOST	0xc1
+#define REQTYPE_HOST_TO_DEVICE	0x40
+#define REQTYPE_DEVICE_TO_HOST	0xc0
+
+/* Config request codes */
+#define CP210X_IFC_ENABLE	0x00
+#define CP210X_SET_BAUDDIV	0x01
+#define CP210X_GET_BAUDDIV	0x02
+#define CP210X_SET_LINE_CTL	0x03
+#define CP210X_GET_LINE_CTL	0x04
+#define CP210X_SET_BREAK	0x05
+#define CP210X_IMM_CHAR		0x06
+#define CP210X_SET_MHS		0x07
+#define CP210X_GET_MDMSTS	0x08
+#define CP210X_SET_XON		0x09
+#define CP210X_SET_XOFF		0x0A
+#define CP210X_SET_EVENTMASK	0x0B
+#define CP210X_GET_EVENTMASK	0x0C
+#define CP210X_SET_CHAR		0x0D
+#define CP210X_GET_CHARS	0x0E
+#define CP210X_GET_PROPS	0x0F
+#define CP210X_GET_COMM_STATUS	0x10
+#define CP210X_RESET		0x11
+#define CP210X_PURGE		0x12
+#define CP210X_SET_FLOW		0x13
+#define CP210X_GET_FLOW		0x14
+#define CP210X_EMBED_EVENTS	0x15
+#define CP210X_GET_EVENTSTATE	0x16
+#define CP210X_SET_CHARS	0x19
+#define CP210X_GET_BAUDRATE	0x1D
+#define CP210X_SET_BAUDRATE	0x1E
+#define CP210X_VENDOR_SPECIFIC	0xFF
+
+/* CP210X_IFC_ENABLE */
+#define UART_ENABLE		0x0001
+#define UART_DISABLE		0x0000
+
+/* CP210X_VENDOR_SPECIFIC */
+#define CP210X_WRITE_LATCH	0x37E1
+#define CP210X_READ_LATCH	0x00C2
+#define CP210X_GET_PARTNUM	0x370B
+
+/* CP210X_(SET|GET)_BAUDDIV */
+#define BAUD_RATE_GEN_FREQ	0x384000
+
+/* CP210X_(SET|GET)_LINE_CTL */
+#define BITS_DATA_MASK		0X0f00
+#define BITS_DATA_5		0X0500
+#define BITS_DATA_6		0X0600
+#define BITS_DATA_7		0X0700
+#define BITS_DATA_8		0X0800
+#define BITS_DATA_9		0X0900
+
+#define BITS_PARITY_MASK	0x00f0
+#define BITS_PARITY_NONE	0x0000
+#define BITS_PARITY_ODD		0x0010
+#define BITS_PARITY_EVEN	0x0020
+#define BITS_PARITY_MARK	0x0030
+#define BITS_PARITY_SPACE	0x0040
+
+#define BITS_STOP_MASK		0x000f
+#define BITS_STOP_1		0x0000
+#define BITS_STOP_1_5		0x0001
+#define BITS_STOP_2		0x0002
+
+/* CP210X_SET_BREAK */
+#define BREAK_ON		0x0001
+#define BREAK_OFF		0x0000
+
+/* CP210X_(SET_MHS|GET_MDMSTS) */
+#define CONTROL_DTR		0x0001
+#define CONTROL_RTS		0x0002
+#define CONTROL_CTS		0x0010
+#define CONTROL_DSR		0x0020
+#define CONTROL_RING		0x0040
+#define CONTROL_DCD		0x0080
+#define CONTROL_WRITE_DTR	0x0100
+#define CONTROL_WRITE_RTS	0x0200
+
+/*
+ * cp210x_get_config
+ * Reads from the CP210x configuration registers
+ * 'size' is specified in bytes.
+ * 'data' is a pointer to a pre-allocated array of integers large
+ * enough to hold 'size' bytes (with 4 bytes to each integer)
+ */
+static int cp210x_get_config(struct usb_serial_port *port, u8 requestType,
+		u8 request, int value, unsigned int *data, int size)
+{
+	struct usb_serial *serial = port->serial;
+	struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
+	__le32 *buf;
+	int result, i, length;
+
+	/* Number of integers required to contain the array */
+	length = (((size - 1) | 3) + 1)/4;
+
+	buf = kcalloc(length, sizeof(__le32), GFP_KERNEL);
+	if (!buf) {
+		dev_err(&port->dev, "%s - out of memory.\n", __func__);
+		return -ENOMEM;
+	}
+
+	/* Issue the request, attempting to read 'size' bytes */
+	result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
+				request, requestType, value,
+				port_priv->bInterfaceNumber, buf, size, 300);
+
+	/* Convert data into an array of integers */
+	for (i = 0; i < length; i++)
+		data[i] = le32_to_cpu(buf[i]);
+
+	kfree(buf);
+
+	if (result != size) {
+		dbg("%s - Unable to send config request, "
+				"request=0x%x size=%d result=%d\n",
+				__func__, request, size, result);
+		if (result > 0)
+			result = -EPROTO;
+
+		return result;
+	}
+
+	return 0;
+}
+
+/*
+ * cp210x_set_config
+ * Writes to the CP210x configuration registers
+ * Values less than 16 bits wide are sent directly
+ * 'size' is specified in bytes.
+ */
+static int cp210x_set_config(struct usb_serial_port *port, u8 requestType,
+		u8 request, int value, unsigned int *data, int size)
+{
+	struct usb_serial *serial = port->serial;
+	struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
+	__le32 *buf = NULL;
+	int result, i, length = 0;
+
+	if (size)
+	{
+		/* Number of integers required to contain the array */
+		length = (((size - 1) | 3) + 1)/4;
+
+		buf = kmalloc(length * sizeof(__le32), GFP_KERNEL);
+		if (!buf) {
+			dev_err(&port->dev, "%s - out of memory.\n",
+					__func__);
+			return -ENOMEM;
+		}
+
+		/* Array of integers into bytes */
+		for (i = 0; i < length; i++)
+			buf[i] = cpu_to_le32(data[i]);
+	}
+
+	result = usb_control_msg(serial->dev,
+			usb_sndctrlpipe(serial->dev, 0),
+			request, requestType, value,
+			port_priv->bInterfaceNumber, buf, size, 300);
+
+	if (buf)
+		kfree(buf);
+
+	if (result != size) {
+		dbg("%s - Unable to send request, "
+				"request=0x%x size=%d result=%d\n",
+				__func__, request, size, result);
+		if (result > 0)
+			result = -EPROTO;
+
+		return result;
+	}
+
+	return 0;
+}
+
+/*
+ * cp210x_quantise_baudrate
+ * Quantises the baud rate as per AN205 Table 1
+ */
+static unsigned int cp210x_quantise_baudrate(unsigned int baud) {
+	if (baud <= 300)
+		baud = 300;
+	else if (baud <= 600)      baud = 600;
+	else if (baud <= 1200)     baud = 1200;
+	else if (baud <= 1800)     baud = 1800;
+	else if (baud <= 2400)     baud = 2400;
+	else if (baud <= 4000)     baud = 4000;
+	else if (baud <= 4803)     baud = 4800;
+	else if (baud <= 7207)     baud = 7200;
+	else if (baud <= 9612)     baud = 9600;
+	else if (baud <= 14428)    baud = 14400;
+	else if (baud <= 16062)    baud = 16000;
+	else if (baud <= 19250)    baud = 19200;
+	else if (baud <= 28912)    baud = 28800;
+	else if (baud <= 38601)    baud = 38400;
+	else if (baud <= 51558)    baud = 51200;
+	else if (baud <= 56280)    baud = 56000;
+	else if (baud <= 58053)    baud = 57600;
+	else if (baud <= 64111)    baud = 64000;
+	else if (baud <= 77608)    baud = 76800;
+	else if (baud <= 117028)   baud = 115200;
+	else if (baud <= 129347)   baud = 128000;
+	else if (baud <= 156868)   baud = 153600;
+	else if (baud <= 237832)   baud = 230400;
+	else if (baud <= 254234)   baud = 250000;
+	else if (baud <= 273066)   baud = 256000;
+	else if (baud <= 491520)   baud = 460800;
+	else if (baud <= 567138)   baud = 500000;
+	else if (baud <= 670254)   baud = 576000;
+	else if (baud < 1000000)
+		baud = 921600;
+	else if (baud > 2000000)
+		baud = 2000000;
+	return baud;
+}
+
+static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port)
+{
+	int result;
+
+	dbg("%s - port %d", __func__, port->number);
+
+	result = cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_IFC_ENABLE, UART_ENABLE, NULL, 0);
+	if (result) {
+		dev_err(&port->dev, "%s - Unable to enable UART\n", __func__);
+		return result;
+	}
+
+	/* Configure the termios structure */
+	cp210x_get_termios(tty, port);
+
+	/* The baud rate must be initialised on cp2104 */
+	if (tty)
+		cp210x_change_speed(tty, port, NULL);
+
+	return usb_serial_generic_open(tty, port);
+}
+
+static void cp210x_close(struct usb_serial_port *port)
+{
+	dbg("%s - port %d", __func__, port->number);
+
+	usb_serial_generic_close(port);
+
+	mutex_lock(&port->serial->disc_mutex);
+	if (!port->serial->disconnected)
+		cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_IFC_ENABLE, UART_DISABLE, NULL, 0);
+	mutex_unlock(&port->serial->disc_mutex);
+}
+
+static int cp210x_ioctl(struct tty_struct *tty,
+	unsigned int cmd, unsigned long arg)
+{
+	struct usb_serial_port *port = tty->driver_data;
+	struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
+
+	printk("port %x priv %x cmd %x arg %x %x\n", port, port_priv, cmd, arg, *(unsigned char *)arg);
+	if(arg == 0)
+	    return -EINVAL;
+
+	switch (cmd) {
+
+	case IOCTL_GPIOGET:
+		if ((port_priv->bPartNumber == CP2103_PARTNUM) ||
+			(port_priv->bPartNumber == CP2104_PARTNUM)) {
+			cp210x_get_config(port, REQTYPE_DEVICE_TO_HOST,
+					CP210X_VENDOR_SPECIFIC,
+					CP210X_READ_LATCH,
+					(unsigned int*)arg, 1);
+		}
+		else if (port_priv->bPartNumber == CP2105_PARTNUM) {
+			cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+					CP210X_VENDOR_SPECIFIC,
+					CP210X_READ_LATCH,
+					(unsigned int*)arg, 1);
+		}
+		else {
+			return -ENOTSUPP;
+		}
+		break;
+
+	case IOCTL_GPIOSET:
+		if ((port_priv->bPartNumber == CP2103_PARTNUM) ||
+			(port_priv->bPartNumber == CP2104_PARTNUM)) {
+			/*cp210x_set_config(port, REQTYPE_HOST_TO_DEVICE,
+					CP210x_VENDOR_SPECIFIC,
+					CP210x_GPIO_WRITE_LATCH, &val, 2);*/
+//			printk("dev %x arg %x\n", port->serial->dev, arg);
+			usb_control_msg(port->serial->dev,
+					usb_sndctrlpipe(port->serial->dev, 0),
+					CP210X_VENDOR_SPECIFIC,
+					REQTYPE_HOST_TO_DEVICE,
+					CP210X_WRITE_LATCH,
+					*(unsigned long*)arg,
+					NULL, 0, 300);
+		}
+		else if (port_priv->bPartNumber == CP2105_PARTNUM) {
+			cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+					CP210X_VENDOR_SPECIFIC,
+					CP210X_WRITE_LATCH,
+					(unsigned int*)arg, 2);
+		}
+		else {
+			return -ENOTSUPP;
+		}
+		break;
+
+	default:
+	    	return -ENOIOCTLCMD;
+		break;
+	}
+
+	return 0;
+}
+
+/*
+ * cp210x_get_termios
+ * Reads the baud rate, data bits, parity, stop bits and flow control mode
+ * from the device, corrects any unsupported values, and configures the
+ * termios structure to reflect the state of the device
+ */
+static void cp210x_get_termios(struct tty_struct *tty,
+	struct usb_serial_port *port)
+{
+	unsigned int baud;
+
+	if (tty) {
+		cp210x_get_termios_port(tty->driver_data,
+			&tty->termios->c_cflag, &baud);
+		tty_encode_baud_rate(tty, baud, baud);
+	}
+
+	else {
+		unsigned int cflag;
+		cflag = 0;
+		cp210x_get_termios_port(port, &cflag, &baud);
+	}
+}
+
+/*
+ * cp210x_get_termios_port
+ * This is the heart of cp210x_get_termios which always uses a &usb_serial_port.
+ */
+static void cp210x_get_termios_port(struct usb_serial_port *port,
+	unsigned int *cflagp, unsigned int *baudp)
+{
+	unsigned int cflag, modem_ctl[4];
+	unsigned int baud;
+	unsigned int bits;
+
+	dbg("%s - port %d", __func__, port->number);
+
+	cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+			CP210X_GET_BAUDRATE, 0, &baud, 4);
+
+	dbg("%s - baud rate = %d", __func__, baud);
+	*baudp = baud;
+
+	cflag = *cflagp;
+
+	cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+			CP210X_GET_LINE_CTL, 0, &bits, 2);
+	cflag &= ~CSIZE;
+	switch (bits & BITS_DATA_MASK) {
+	case BITS_DATA_5:
+		dbg("%s - data bits = 5", __func__);
+		cflag |= CS5;
+		break;
+	case BITS_DATA_6:
+		dbg("%s - data bits = 6", __func__);
+		cflag |= CS6;
+		break;
+	case BITS_DATA_7:
+		dbg("%s - data bits = 7", __func__);
+		cflag |= CS7;
+		break;
+	case BITS_DATA_8:
+		dbg("%s - data bits = 8", __func__);
+		cflag |= CS8;
+		break;
+	case BITS_DATA_9:
+		dbg("%s - data bits = 9 (not supported, using 8 data bits)",
+								__func__);
+		cflag |= CS8;
+		bits &= ~BITS_DATA_MASK;
+		bits |= BITS_DATA_8;
+		cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2);
+		break;
+	default:
+		dbg("%s - Unknown number of data bits, using 8", __func__);
+		cflag |= CS8;
+		bits &= ~BITS_DATA_MASK;
+		bits |= BITS_DATA_8;
+		cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2);
+		break;
+	}
+
+	switch (bits & BITS_PARITY_MASK) {
+	case BITS_PARITY_NONE:
+		dbg("%s - parity = NONE", __func__);
+		cflag &= ~PARENB;
+		break;
+	case BITS_PARITY_ODD:
+		dbg("%s - parity = ODD", __func__);
+		cflag |= (PARENB|PARODD);
+		break;
+	case BITS_PARITY_EVEN:
+		dbg("%s - parity = EVEN", __func__);
+		cflag &= ~PARODD;
+		cflag |= PARENB;
+		break;
+	case BITS_PARITY_MARK:
+		dbg("%s - parity = MARK", __func__);
+		cflag |= (PARENB|PARODD|CMSPAR);
+		break;
+	case BITS_PARITY_SPACE:
+		dbg("%s - parity = SPACE", __func__);
+		cflag &= ~PARODD;
+		cflag |= (PARENB|CMSPAR);
+		break;
+	default:
+		dbg("%s - Unknown parity mode, disabling parity", __func__);
+		cflag &= ~PARENB;
+		bits &= ~BITS_PARITY_MASK;
+		cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2);
+		break;
+	}
+
+	cflag &= ~CSTOPB;
+	switch (bits & BITS_STOP_MASK) {
+	case BITS_STOP_1:
+		dbg("%s - stop bits = 1", __func__);
+		break;
+	case BITS_STOP_1_5:
+		dbg("%s - stop bits = 1.5 (not supported, using 1 stop bit)",
+								__func__);
+		bits &= ~BITS_STOP_MASK;
+		cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2);
+		break;
+	case BITS_STOP_2:
+		dbg("%s - stop bits = 2", __func__);
+		cflag |= CSTOPB;
+		break;
+	default:
+		dbg("%s - Unknown number of stop bits, using 1 stop bit",
+								__func__);
+		bits &= ~BITS_STOP_MASK;
+		cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2);
+		break;
+	}
+
+	cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+			CP210X_GET_FLOW, 0, modem_ctl, 16);
+	if (modem_ctl[0] & 0x0008) {
+		dbg("%s - flow control = CRTSCTS", __func__);
+		cflag |= CRTSCTS;
+	} else {
+		dbg("%s - flow control = NONE", __func__);
+		cflag &= ~CRTSCTS;
+	}
+
+	*cflagp = cflag;
+}
+
+/*
+ * CP2101 supports the following baud rates:
+ *
+ *	300, 600, 1200, 1800, 2400, 4800, 7200, 9600, 14400, 19200, 28800,
+ *	38400, 56000, 57600, 115200, 128000, 230400, 460800, 921600
+ *
+ * CP2102 and CP2103 support the following additional rates:
+ *
+ *	4000, 16000, 51200, 64000, 76800, 153600, 250000, 256000, 500000,
+ *	576000
+ *
+ * The device will map a requested rate to a supported one, but the result
+ * of requests for rates greater than 1053257 is undefined (see AN205).
+ *
+ * CP2104, CP2105 and CP2110 support most rates up to 2M, 921k and 1M baud,
+ * respectively, with an error less than 1%. The actual rates are determined
+ * by
+ *
+ *	div = round(freq / (2 x prescale x request))
+ *	actual = freq / (2 x prescale x div)
+ *
+ * For CP2104 and CP2105 freq is 48Mhz and prescale is 4 for request <= 365bps
+ * or 1 otherwise.
+ * For CP2110 freq is 24Mhz and prescale is 4 for request <= 300bps or 1
+ * otherwise.
+ */
+static void cp210x_change_speed(struct tty_struct *tty,
+		struct usb_serial_port *port, struct ktermios *old_termios)
+{
+	u32 baud;
+
+	baud = tty->termios->c_ospeed;
+
+	/* This maps the requested rate to a rate valid on cp2102 or cp2103,
+	 * or to an arbitrary rate in [1M,2M].
+	 *
+	 * NOTE: B0 is not implemented.
+	 */
+	baud = cp210x_quantise_baudrate(baud);
+
+	dbg("%s - setting baud rate to %u", __func__, baud);
+	if (cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+			CP210X_SET_BAUDRATE, 0, &baud, sizeof(baud))) {
+		dev_warn(&port->dev, "failed to set baud rate to %u\n", baud);
+		if (old_termios)
+			baud = old_termios->c_ospeed;
+		else
+			baud = 9600;
+	}
+
+	tty_encode_baud_rate(tty, baud, baud);
+}
+
+static void cp210x_set_termios(struct tty_struct *tty,
+		struct usb_serial_port *port, struct ktermios *old_termios)
+{
+	unsigned int cflag, old_cflag;
+	unsigned int bits;
+	unsigned int modem_ctl[4];
+
+	dbg("%s - port %d", __func__, port->number);
+
+	if (!tty)
+		return;
+
+	cflag = tty->termios->c_cflag;
+	old_cflag = old_termios->c_cflag;
+
+	cp210x_change_speed(tty, port, old_termios);
+
+	/* If the number of data bits is to be updated */
+	if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
+		cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+				CP210X_GET_LINE_CTL, 0, &bits, 2);
+		bits &= ~BITS_DATA_MASK;
+		switch (cflag & CSIZE) {
+		case CS5:
+			bits |= BITS_DATA_5;
+			dbg("%s - data bits = 5", __func__);
+			break;
+		case CS6:
+			bits |= BITS_DATA_6;
+			dbg("%s - data bits = 6", __func__);
+			break;
+		case CS7:
+			bits |= BITS_DATA_7;
+			dbg("%s - data bits = 7", __func__);
+			break;
+		case CS8:
+			bits |= BITS_DATA_8;
+			dbg("%s - data bits = 8", __func__);
+			break;
+		/*case CS9:
+			bits |= BITS_DATA_9;
+			dbg("%s - data bits = 9", __func__);
+			break;*/
+		default:
+			dbg("cp210x driver does not "
+					"support the number of bits requested,"
+					" using 8 bit mode\n");
+				bits |= BITS_DATA_8;
+				break;
+		}
+		if (cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2))
+			dbg("Number of data bits requested "
+					"not supported by device\n");
+	}
+
+	if ((cflag     & (PARENB|PARODD|CMSPAR)) !=
+	    (old_cflag & (PARENB|PARODD|CMSPAR))) {
+		cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+				CP210X_GET_LINE_CTL, 0, &bits, 2);
+		bits &= ~BITS_PARITY_MASK;
+		if (cflag & PARENB) {
+			if (cflag & CMSPAR) {
+			    if (cflag & PARODD) {
+				    bits |= BITS_PARITY_MARK;
+				    dbg("%s - parity = MARK", __func__);
+			    } else {
+				    bits |= BITS_PARITY_SPACE;
+				    dbg("%s - parity = SPACE", __func__);
+			    }
+			} else {
+			    if (cflag & PARODD) {
+				    bits |= BITS_PARITY_ODD;
+				    dbg("%s - parity = ODD", __func__);
+			    } else {
+				    bits |= BITS_PARITY_EVEN;
+				    dbg("%s - parity = EVEN", __func__);
+			    }
+			}
+		}
+		if (cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2))
+			dbg("Parity mode not supported "
+					"by device\n");
+	}
+
+	if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
+		cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+				CP210X_GET_LINE_CTL, 0, &bits, 2);
+		bits &= ~BITS_STOP_MASK;
+		if (cflag & CSTOPB) {
+			bits |= BITS_STOP_2;
+			dbg("%s - stop bits = 2", __func__);
+		} else {
+			bits |= BITS_STOP_1;
+			dbg("%s - stop bits = 1", __func__);
+		}
+		if (cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_LINE_CTL, 0, &bits, 2))
+			dbg("Number of stop bits requested "
+					"not supported by device\n");
+	}
+
+	if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
+		cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+				CP210X_GET_FLOW, 0, modem_ctl, 16);
+		dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
+				__func__, modem_ctl[0], modem_ctl[1],
+				modem_ctl[2], modem_ctl[3]);
+
+		if (cflag & CRTSCTS) {
+			modem_ctl[0] &= ~0x7B;
+			modem_ctl[0] |= 0x09;
+			modem_ctl[1] = 0x80;
+			dbg("%s - flow control = CRTSCTS", __func__);
+		} else {
+			modem_ctl[0] &= ~0x7B;
+			modem_ctl[0] |= 0x01;
+			modem_ctl[1] |= 0x40;
+			dbg("%s - flow control = NONE", __func__);
+		}
+
+		dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
+				__func__, modem_ctl[0], modem_ctl[1],
+				modem_ctl[2], modem_ctl[3]);
+		cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_FLOW, 0, modem_ctl, 16);
+	}
+
+}
+
+static int cp210x_tiocmset (struct tty_struct *tty,
+		unsigned int set, unsigned int clear)
+{
+	struct usb_serial_port *port = tty->driver_data;
+	return cp210x_tiocmset_port(port, set, clear);
+}
+
+static int cp210x_tiocmset_port(struct usb_serial_port *port,
+		unsigned int set, unsigned int clear)
+{
+	unsigned int control = 0;
+
+	dbg("%s - port %d", __func__, port->number);
+
+	if (set & TIOCM_RTS) {
+		control |= CONTROL_RTS;
+		control |= CONTROL_WRITE_RTS;
+	}
+	if (set & TIOCM_DTR) {
+		control |= CONTROL_DTR;
+		control |= CONTROL_WRITE_DTR;
+	}
+	if (clear & TIOCM_RTS) {
+		control &= ~CONTROL_RTS;
+		control |= CONTROL_WRITE_RTS;
+	}
+	if (clear & TIOCM_DTR) {
+		control &= ~CONTROL_DTR;
+		control |= CONTROL_WRITE_DTR;
+	}
+
+	dbg("%s - control = 0x%.4x", __func__, control);
+
+	return cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+				CP210X_SET_MHS, 0, &control, 2);
+}
+
+static void cp210x_dtr_rts(struct usb_serial_port *p, int on)
+{
+	if (on)
+		cp210x_tiocmset_port(p, TIOCM_DTR|TIOCM_RTS, 0);
+	else
+		cp210x_tiocmset_port(p, 0, TIOCM_DTR|TIOCM_RTS);
+}
+
+static int cp210x_tiocmget (struct tty_struct *tty)
+{
+	struct usb_serial_port *port = tty->driver_data;
+	unsigned int control;
+	int result;
+
+	dbg("%s - port %d", __func__, port->number);
+
+	cp210x_get_config(port, REQTYPE_INTERFACE_TO_HOST,
+			CP210X_GET_MDMSTS, 0, &control, 1);
+
+	result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
+		|((control & CONTROL_RTS) ? TIOCM_RTS : 0)
+		|((control & CONTROL_CTS) ? TIOCM_CTS : 0)
+		|((control & CONTROL_DSR) ? TIOCM_DSR : 0)
+		|((control & CONTROL_RING)? TIOCM_RI  : 0)
+		|((control & CONTROL_DCD) ? TIOCM_CD  : 0);
+
+	dbg("%s - control = 0x%.2x", __func__, control);
+
+	return result;
+}
+
+static void cp210x_break_ctl (struct tty_struct *tty, int break_state)
+{
+	struct usb_serial_port *port = tty->driver_data;
+	unsigned int state;
+
+	dbg("%s - port %d", __func__, port->number);
+	if (break_state == 0)
+		state = BREAK_OFF;
+	else
+		state = BREAK_ON;
+	dbg("%s - turning break %s", __func__,
+			state == BREAK_OFF ? "off" : "on");
+	cp210x_set_config(port, REQTYPE_HOST_TO_INTERFACE,
+			CP210X_SET_BREAK, 0, &state, 2);
+}
+
+static int cp210x_startup(struct usb_serial *serial)
+{
+	struct cp210x_port_private *port_priv;
+	int i;
+	unsigned int partNum;
+
+	/* cp210x buffers behave strangely unless device is reset */
+	usb_reset_device(serial->dev);
+
+	for (i = 0; i < serial->num_ports; i++) {
+		port_priv = kzalloc(sizeof(*port_priv), GFP_KERNEL);
+		if (!port_priv)
+			return -ENOMEM;
+
+		memset(port_priv, 0x00, sizeof(*port_priv));
+		port_priv->bInterfaceNumber =
+			serial->interface->cur_altsetting->desc.bInterfaceNumber;
+
+		usb_set_serial_port_data(serial->port[i], port_priv);
+
+		/* Get the 1-byte part number of the cp210x device */
+		cp210x_get_config(serial->port[i],
+			REQTYPE_DEVICE_TO_HOST, CP210X_VENDOR_SPECIFIC,
+			CP210X_GET_PARTNUM, &partNum, 1);
+		port_priv->bPartNumber = partNum & 0xFF;
+	}
+
+	return 0;
+}
+
+static void cp210x_release(struct usb_serial *serial)
+{
+	struct cp210x_port_private *port_priv;
+	int i;
+
+	for (i = 0; i < serial->num_ports; i++) {
+		port_priv = usb_get_serial_port_data(serial->port[i]);
+		kfree(port_priv);
+		usb_set_serial_port_data(serial->port[i], NULL);
+	}
+}
+/*
+static int __init cp210x_init(void)
+{
+	int retval;
+
+	retval = usb_serial_register(&cp210x_device);
+	if (retval)
+		return retval; 
+
+	retval = usb_register(&cp210x_driver);
+	if (retval) {
+		usb_serial_deregister(&cp210x_device);
+		return retval;
+	}
+
+	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+	       DRIVER_DESC "\n");
+	return 0;
+}
+
+static void __exit cp210x_exit(void)
+{
+	usb_deregister(&cp210x_driver);
+	usb_serial_deregister(&cp210x_device);
+}
+
+module_init(cp210x_init);
+module_exit(cp210x_exit);
+*/
+
+module_usb_serial_driver(serial_drivers, id_table);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
--- 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