tools: Added b2x0_side_channel.py (FX3 debug util)

1 files changed, 650 insertions, 0 deletions

diff --git a/tools/b200/b2x0_side_channel.py b/tools/b200/b2x0_side_channel.py
new file mode 100755
index 000000000..cf88bd35f
--- /dev/null
+++ b/tools/b200/b2x0_side_channel.py
@@ -0,0 +1,650 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2013-2014 Ettus Research LLC
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+Tool to read log buffers from the FX3. Use to debug USB connection issues.
+Requires PyUSB 1.0.
+"""
+
+import sys
+import time
+import struct
+from optparse import OptionParser
+import serial
+
+try:
+    import usb.core
+    import usb.util
+except Exception as e:
+    print "Failed to import usb - please have pyusb in your PYTHONPATH"
+    raise e
+
+VRT_OUT = usb.util.CTRL_TYPE_VENDOR | usb.util.CTRL_OUT
+VRT_IN = usb.util.CTRL_TYPE_VENDOR | usb.util.CTRL_IN
+
+VRQS = {}
+B200_VREQ_GET_LOG                 = 0x23
+VRQS[B200_VREQ_GET_LOG]           = 'B200_VREQ_GET_LOG'
+B200_VREQ_GET_COUNTERS            = 0x24
+VRQS[B200_VREQ_GET_COUNTERS]      = 'B200_VREQ_GET_COUNTERS'
+B200_VREQ_CLEAR_COUNTERS          = 0x25
+VRQS[B200_VREQ_CLEAR_COUNTERS]    = 'B200_VREQ_CLEAR_COUNTERS'
+B200_VREQ_GET_USB_EVENT_LOG       = 0x26
+VRQS[B200_VREQ_GET_USB_EVENT_LOG] = 'B200_VREQ_GET_USB_EVENT_LOG'
+B200_VREQ_SET_CONFIG              = 0x27
+VRQS[B200_VREQ_SET_CONFIG]        = 'B200_VREQ_SET_CONFIG'
+B200_VREQ_GET_CONFIG              = 0x28
+VRQS[B200_VREQ_GET_CONFIG]        = 'B200_VREQ_GET_CONFIG'
+B200_VREQ_GET_USB_SPEED           = 0x80
+VRQS[B200_VREQ_GET_USB_SPEED]     ='B200_VREQ_GET_USB_SPEED'
+B200_VREQ_WRITE_SB                = 0x29
+VRQS[B200_VREQ_WRITE_SB]          = 'B200_VREQ_WRITE_SB'
+B200_VREQ_SET_SB_BAUD_DIV         = 0x30
+VRQS[B200_VREQ_SET_SB_BAUD_DIV]   = 'B200_VREQ_SET_SB_BAUD_DIV'
+B200_VREQ_FLUSH_DATA_EPS          = 0x31
+VRQS[B200_VREQ_FLUSH_DATA_EPS]    = 'B200_VREQ_FLUSH_DATA_EPS'
+B200_VREQ_AD9361_LOOPBACK         = 0x92
+VRQS[B200_VREQ_AD9361_LOOPBACK]   = 'B200_VREQ_AD9361_LOOPBACK'
+
+COUNTER_MAGIC                     = 0x10024001
+"""
+typedef struct Counters {
+    int magic;
+
+    DMA_COUNTERS dma_to_host;
+    DMA_COUNTERS dma_from_host;
+
+    int log_overrun_count;
+
+    int usb_error_update_count;
+    USB_ERROR_COUNTERS usb_error_counters;
+
+    int usb_ep_underrun_count;
+
+    int heap_size;
+} COUNTERS, *PCOUNTERS;
+
+typedef struct USBErrorCounters {
+    int phy_error_count;
+    int link_error_count;
+
+    int PHY_LOCK_EV;
+    int TRAINING_ERROR_EV;
+    int RX_ERROR_CRC32_EV;
+    int RX_ERROR_CRC16_EV;
+    int RX_ERROR_CRC5_EV;
+    int PHY_ERROR_DISPARITY_EV;
+    int PHY_ERROR_EB_UND_EV;
+    int PHY_ERROR_EB_OVR_EV;
+    int PHY_ERROR_DECODE_EV;
+} USB_ERROR_COUNTERS, *PUSB_ERROR_COUNTERS;
+
+typedef struct DMACounters {
+    int XFER_CPLT;
+    int SEND_CPLT;
+    int RECV_CPLT;
+    int PROD_EVENT;
+    int CONS_EVENT;
+    int ABORTED;
+    int ERROR;
+    int PROD_SUSP;
+    int CONS_SUSP;
+
+    int BUFFER_MARKER;
+    int BUFFER_EOP;
+    int BUFFER_ERROR;
+    int BUFFER_OCCUPIED;
+
+    int last_count;
+    int last_size;
+
+    int last_sid;
+    int bad_sid_count;
+
+    int resume_count;
+} DMA_COUNTERS, *PDMA_COUNTERS;
+"""
+DMA_COUNTERS = [
+    'XFER_CPLT',
+    'SEND_CPLT',
+    'RECV_CPLT',
+    'PROD_EVENT',
+    'CONS_EVENT',
+    'ABORTED',
+    'ERROR',
+    'PROD_SUSP',
+    'CONS_SUSP',
+
+    'BUFFER_MARKER',
+    'BUFFER_EOP',
+    'BUFFER_ERROR',
+    'BUFFER_OCCUPIED',
+
+    'last_count',
+    'last_size',
+
+    'last_sid',
+    'bad_sid_count'
+]
+
+USB_ERROR_COUNTERS = [
+    'phy_error_count',
+    'link_error_count'
+]
+
+USB_PHY_ERROR_REGISTERS = [
+    'PHY_LOCK_EV',
+    'TRAINING_ERROR_EV',
+    'RX_ERROR_CRC32_EV',
+    'RX_ERROR_CRC16_EV',
+    'RX_ERROR_CRC5_EV',
+    'PHY_ERROR_DISPARITY_EV',
+    'PHY_ERROR_EB_UND_EV',
+    'PHY_ERROR_EB_OVR_EV',
+    'PHY_ERROR_DECODE_EV'
+]
+
+USB_ERROR_COUNTERS += USB_PHY_ERROR_REGISTERS
+
+COUNTERS = [
+    'magic',
+
+    ('dma_to_host', DMA_COUNTERS),
+    ('dma_from_host', DMA_COUNTERS),
+
+    'log_overrun_count',
+
+    'usb_error_update_count',
+    ('usb_error_counters', USB_ERROR_COUNTERS),
+
+    'usb_ep_underrun_count',
+
+    'heap_size',
+
+    'resume_count'
+]
+
+USB_EVENTS = {}
+USB_EVENTS[0x01] = ('CYU3P_USB_LOG_VBUS_OFF'          , 'Indicates VBus turned off.')
+USB_EVENTS[0x02] = ('CYU3P_USB_LOG_VBUS_ON'           , 'Indicates VBus turned on.')
+USB_EVENTS[0x03] = ('CYU3P_USB_LOG_USB2_PHY_OFF'      , 'Indicates that the 2.0 PHY has been turned off.')
+USB_EVENTS[0x04] = ('CYU3P_USB_LOG_USB3_PHY_OFF'      , 'Indicates that the 3.0 PHY has been turned off.')
+USB_EVENTS[0x05] = ('CYU3P_USB_LOG_USB2_PHY_ON'       , 'Indicates that the 2.0 PHY has been turned on.')
+USB_EVENTS[0x06] = ('CYU3P_USB_LOG_USB3_PHY_ON'       , 'Indicates that the 3.0 PHY has been turned on.')
+USB_EVENTS[0x10] = ('CYU3P_USB_LOG_USBSS_DISCONNECT'  , 'Indicates that the USB 3.0 link has been disabled.')
+USB_EVENTS[0x11] = ('CYU3P_USB_LOG_USBSS_RESET'       , 'Indicates that a USB 3.0 reset (warm/hot) has happened.')
+USB_EVENTS[0x12] = ('CYU3P_USB_LOG_USBSS_CONNECT'     , 'Indicates that USB 3.0 Rx Termination has been detected.')
+USB_EVENTS[0x14] = ('CYU3P_USB_LOG_USBSS_CTRL'        , 'Indicates that a USB 3.0 control request has been received.')
+USB_EVENTS[0x15] = ('CYU3P_USB_LOG_USBSS_STATUS'      , 'Indicates completion of status stage for a 3.0 control request.')
+USB_EVENTS[0x16] = ('CYU3P_USB_LOG_USBSS_ACKSETUP'    , 'Indicates that the CyU3PUsbAckSetup API has been called.')
+USB_EVENTS[0x21] = ('CYU3P_USB_LOG_LGO_U1'            , 'Indicates that a LGO_U1 command has been received.')
+USB_EVENTS[0x22] = ('CYU3P_USB_LOG_LGO_U2'            , 'Indicates that a LGO_U2 command has been received.')
+USB_EVENTS[0x23] = ('CYU3P_USB_LOG_LGO_U3'            , 'Indicates that a LGO_U3 command has been received.')
+USB_EVENTS[0x40] = ('CYU3P_USB_LOG_USB2_SUSP'         , 'Indicates that a USB 2.0 suspend condition has been detected.')
+USB_EVENTS[0x41] = ('CYU3P_USB_LOG_USB2_RESET'        , 'Indicates that a USB 2.0 bus reset has been detected.')
+USB_EVENTS[0x42] = ('CYU3P_USB_LOG_USB2_HSGRANT'      , 'Indicates that the USB High-Speed handshake has been completed.')
+USB_EVENTS[0x44] = ('CYU3P_USB_LOG_USB2_CTRL'         , 'Indicates that a FS/HS control request has been received.')
+USB_EVENTS[0x45] = ('CYU3P_USB_LOG_USB2_STATUS'       , 'Indicates completion of status stage for a FS/HS control transfer.')
+USB_EVENTS[0x50] = ('CYU3P_USB_LOG_USB_FALLBACK'      , 'Indicates that the USB connection is dropping from 3.0 to 2.0')
+USB_EVENTS[0x51] = ('CYU3P_USB_LOG_USBSS_ENABLE'      , 'Indicates that a USB 3.0 connection is being attempted again.')
+USB_EVENTS[0x52] = ('CYU3P_USB_LOG_USBSS_LNKERR'      , 'The number of link errors has crossed the threshold.')
+USB_EVENTS[0x80] = ('CYU3P_USB_LOG_LTSSM_CHG'         , 'Base of values that indicate a USB 3.0 LTSSM state change.')
+
+LTSSM_STATES = {}
+LTSSM_STATES[0x00] = ['00000',    "SS.Disabled"]
+LTSSM_STATES[0x01] = ['00001',    "Rx.Detect.Reset"]
+LTSSM_STATES[0x02] = ['00010',    "Rx.Detect.Active"]
+LTSSM_STATES[0x03] = ['00011',    "Rx.Detect.Quiet"]
+LTSSM_STATES[0x04] = ['00100',    "SS.Inactive.Quiet"]
+LTSSM_STATES[0x05] = ['00101',    "SS.Inactive.Disconnect.Detect"]
+LTSSM_STATES[0x06] = ['00110',    "Hot Reset.Active"]
+LTSSM_STATES[0x07] = ['00111',    "Hot Reset.Exit"]
+LTSSM_STATES[0x08] = ['01000',    "Polling.LFPS"]
+LTSSM_STATES[0x09] = ['01001',    "Polling.RxEQ"]
+LTSSM_STATES[0x0a] = ['01010',    "Polling.Active"]
+LTSSM_STATES[0x0b] = ['01011',    "Polling.Configuration"]
+LTSSM_STATES[0x0c] = ['01100',    "Polling.Idle"]
+LTSSM_STATES[0x0d] = ['01101',    "(none)"]
+#LTSSM_STATES[0x0X] = ['0111X',    "(none)"]
+LTSSM_STATES[0x0e] = ['0111X',    "(none)"]
+LTSSM_STATES[0x0f] = ['0111X',    "(none)"]
+LTSSM_STATES[0x10] = ['10000',    "U0"]
+LTSSM_STATES[0x11] = ['10001',    "U1"]
+LTSSM_STATES[0x12] = ['10010',    "U2"]
+LTSSM_STATES[0x13] = ['10011',    "U3"]
+LTSSM_STATES[0x14] = ['10100',    "Loopback.Active"]
+LTSSM_STATES[0x15] = ['10101',    "Loopback.Exit"]
+LTSSM_STATES[0x16] = ['10110',    "(none)"]
+LTSSM_STATES[0x17] = ['10111',    "Compliance"]
+LTSSM_STATES[0x18] = ['11000',    "Recovery.Active"]
+LTSSM_STATES[0x19] = ['11001',    "Recovery.Configuration"]
+LTSSM_STATES[0x1a] = ['11010',    "Recovery.Idle"]
+LTSSM_STATES[0x1b] = ['11011',    "(none)"]
+#LTSSM_STATES[0x1X] = ['111XX',    "(none)"]
+LTSSM_STATES[0x1c] = ['111XX',    "(none)"]
+LTSSM_STATES[0x1d] = ['111XX',    "(none)"]
+LTSSM_STATES[0x1c] = ['111XX',    "(none)"]
+LTSSM_STATES[0x1f] = ['111XX',    "(none)"]
+LTSSM_STATES[0x2c] = ['101100',    "Cypress/Intel workaround"]
+
+def _parse_usb_event_log(data):
+    l = []
+    for d in data:
+        if d == 0x14 or d == 0x15 or d == 0x16:    # CTRL, STATUS, ACKSETUP
+            continue
+        elif (d & 0x80):
+            #l += [(USB_EVENTS[0x80][0] + "+%i" % (d & ~0x80), USB_EVENTS[0x80][1])]
+            ltssm_key = (d & ~0x80)
+            ltssm_val = "(unknown)"
+            if LTSSM_STATES.has_key(ltssm_key):
+                ltssm_val = LTSSM_STATES[ltssm_key][1]
+            ltssm_val = "LTSSM: " + ltssm_val
+            l += [(USB_EVENTS[0x80][0] + "+%i" % (d & ~0x80), ltssm_val)]
+        elif USB_EVENTS.has_key(d):
+            l += [USB_EVENTS[d]]
+        #else:
+        #    l += [("?", "?")]
+    return l
+
+class counter_set():
+    def __init__(self, counters, name='(top)'):
+        self._counters = counters
+        self._counter_names = []
+        self._name = name
+        for c in counters:
+            o = 0
+            default_value = False
+            if isinstance(c, str):
+                name = c
+                default_value = True
+            elif isinstance(c, tuple):
+                name = c[0]
+                o = counter_set(c[1])
+            elif isinstance(c, dict):
+                raise Exception('Not implemented yet')
+            else:
+                raise Exception('Unknown counter format')
+            setattr(self, name, o)
+            self._counter_names += [(name, default_value)]
+        self._fmt_str = self._get_struct_format()
+
+    def _get_struct_format(self):
+        fmt_str = ""
+        for name, default_value in self._counter_names:
+            if default_value:
+                fmt_str += "i"
+            else:
+                o = getattr(self, name)
+                fmt_str += o._get_struct_format()
+        return fmt_str
+
+    def _update(self, data, parents=[]):
+        if len(data) == 0:
+            raise Exception('Ran out of data entering %s' % (self._name))
+            #return []
+        for name, default_value in self._counter_names:
+            if default_value:
+                if len(data) == 0:
+                    raise Exception('Ran out of data setting %s in %s' % (name, self._name))
+                setattr(self, name, data[0])
+                data = data[1:]
+            else:
+                o = getattr(self, name)
+                data = o._update(data, parents+[self])
+        return data
+
+    def update(self, data):
+        try:
+            vals = struct.unpack(self._fmt_str, data)
+            self._update(vals)
+        except Exception, e:
+            print e
+
+    def __str__(self):
+        return self.to_string()
+
+    def to_string(self, parents=[]):
+        s = ""
+        cnt = 0
+        for name, default_value in self._counter_names:
+            o = getattr(self, name)
+            if default_value:
+                if cnt > 0:
+                    s += "\t"
+                s += "%s: %05i" % (name, o)
+                cnt += 1
+            else:
+                if cnt > 0:
+                    s += "\n"
+                s += "\t"*(len(parents) + 1)
+                s += o.to_string(parents+[self])
+                cnt = 0
+        s += "\n"
+        return s
+
+class usb_device():
+    def __init__(self):
+        #self.max_buffer_size = 64        # Default to USB2
+        self.max_buffer_size = 1024*4    # Apparently it'll frag bigger packets
+        self.counters = counter_set(COUNTERS)
+        self.timeout = 2000
+
+    def open(self, idVendor, idProduct):
+        print "Finding %04x:%04x..." % (idVendor, idProduct)
+        self.dev = usb.core.find(idVendor=idVendor, idProduct=idProduct)
+        if self.dev is None:
+            raise ValueError('Device not found: %04x:%04x' % (idVendor, idProduct))
+
+        self.log_index = 0
+        self.log_read_count = 0
+        self.usb_event_log_read_count = 0
+        self.counters_read_count = 0
+
+        #if self.dev.is_kernel_driver_active(0):
+        #    print "Detaching kernel driver..."
+        #    self.dev.detach_kernel_driver(0)
+
+        #self.dev.set_configuration()    # This will throw as device is already claimed
+
+        print "Opened %04x:%04x" % (idVendor, idProduct)
+
+        #self.dev.ctrl_transfer(0x21,          0x09,     0,        0,        [0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00] )
+        #self.dev.ctrl_transfer(bmRequestType, bRequest, wValue=0, wIndex=0, data_or_wLength = None,                   timeout = None
+
+        #res = self.dev.ctrl_transfer(VRT_IN, 0x83, 0, 0, 1024)
+        # Can give 1024 byte size for IN, result will be actual payload size
+        # Invalid VREQ results in usb.core.USBError 32 Pipe error
+        #print res
+
+        #res = self.dev.ctrl_transfer(VRT_IN, B200_VREQ_GET_USB_SPEED, 0, 0, 1)
+        #self.usb_speed = res[0]
+        while True:
+            #l = self.vrt_get(B200_VREQ_GET_USB_SPEED)
+            l = []
+            try:
+                l = self.dev.ctrl_transfer(VRT_IN, B200_VREQ_GET_USB_SPEED, 0, 0, 1)
+            except usb.core.USBError, e:
+                if e.errno == 32:
+                    print e
+                    sys.exit(0)
+            if len(l) > 0:
+                self.usb_speed = l[0]
+                print "Operating at USB", self.usb_speed
+                break
+            else:
+                print "Retrying..."
+        #if self.usb_speed == 3:
+        #    self.max_buffer_size = 512
+        print "Max buffer size:", self.max_buffer_size
+        print
+
+    def _handle_error(self, e, vrt):
+        if e.errno == 19:    # No such device
+            raise e
+        vrt_str = "0x%02x" % (vrt)
+        if VRQS.has_key(vrt):
+            vrt_str += " (%s)" % (VRQS[vrt])
+        print "%s: %s" % (vrt_str, str(e))
+
+    def vrt_get(self, vrt):
+        try:
+            return self.dev.ctrl_transfer(VRT_IN, vrt, 0, 0, self.max_buffer_size, self.timeout)
+        except usb.core.USBError, e:
+            self._handle_error(e, vrt)
+        return []
+
+    def vrt_set(self, vrt, data=""):
+        try:
+            return self.dev.ctrl_transfer(VRT_OUT, vrt, 0, 0, data, self.timeout)
+        except usb.core.USBError, e:
+            self._handle_error(e, vrt)
+        return None
+
+    def get_log(self, with_log_index=True):
+        lines = []
+        raw = self.vrt_get(B200_VREQ_GET_LOG)
+        if len(raw) == 0:
+            return lines
+        if raw[0] == 0:
+            return lines
+        self.log_read_count += 1
+        raw = list(raw)
+        last = 0
+        while raw[last] != 0:
+            try:
+                idx = raw.index(0, last)
+                self.log_index += 1
+                line = "".join(map(chr, raw[last:idx]))
+                #print "[%05i %05i] %s" % (self.log_index, self.log_read_count, line)
+                if with_log_index:
+                    lines += [(self.log_index, line)]
+                else:
+                    lines += [line]
+                last = idx + 1
+                if last >= len(raw):
+                    break
+            except Exception, e:
+                print e
+                break
+        return lines
+
+    def print_log(self):
+        lines = self.get_log()
+        if len(lines) == 0:
+            return
+        for l in lines:
+            #print l
+            print "[%05i %05i] %s" % (l[0], self.log_read_count, l[1])
+        print
+
+    def get_counters(self):
+        data = self.vrt_get(B200_VREQ_GET_COUNTERS)
+        if len(data) == 0:
+            return
+        self.counters_read_count += 1
+        self.counters.update(data)
+
+    def print_counters(self):
+        self.get_counters()
+        print "[%05i]" % (self.counters_read_count)
+        print self.counters
+
+    def get_usb_event_log(self):
+        data = self.vrt_get(B200_VREQ_GET_USB_EVENT_LOG)
+        if len(data) == 0:
+            return []
+        if len(data) == self.max_buffer_size:    # ZLP when no new events have been recorded
+            return []
+        if len(data) > 64:
+            raise Exception("USB event log data len = %i" % (len(data)))
+        self.usb_event_log_read_count += 1
+        return _parse_usb_event_log(data)
+
+    def print_usb_event_log(self):
+        l = self.get_usb_event_log()
+        if len(l) == 0:
+            return
+        print "\n".join(map(lambda x: ("[%05i] " % (self.usb_event_log_read_count)) + x[0] + ":\t" + x[1], l))
+        print
+
+def run_log(dev, options):
+    items = [
+        (options.log,            dev.print_log),
+        (options.counters,        dev.print_counters),
+        (options.usb_events,    dev.print_usb_event_log)
+    ]
+    items = filter(lambda x: x[0] > 0, items)
+    smallest_interval = min(map(lambda x: x[0], items))
+    time_now = time.time()
+    last = [time_now]*len(items)
+
+    try:
+        for i in items:
+            if i[0] < 0:
+                i[1]()
+        while True:
+            time_now = time.time()
+            cleared = False
+            for i in range(len(items)):
+                time_last = last[i]
+                if time_now < (time_last + items[i][0]):
+                    continue
+                if options.clear_screen and not cleared:
+                    print chr(27) + "[2J"
+                    cleared = True
+                #print items[i][1]
+                items[i][1]()
+                last[i] = time.time()
+            time.sleep(smallest_interval)
+    except KeyboardInterrupt:
+        return
+
+def hex_to_int(s):
+    radix = 10
+    s = s.lower()
+    if (len(s) > 1 and s[0] == 'x') or (len(s) > 2 and s[0:2] == "0x"):
+        radix = 16
+    return int(s, radix)
+
+def recv_serial_data(ser):
+    data = ""
+    usb_event_log_read_count = 0
+    time_start = time.time()
+    while True:
+        c = ser.read()
+        data += c
+        #if c == '\n':
+        if len(data) >= 2 and data[-2:] == "\r\n":
+            time_now_str = "[%06d]" % (int(time.time() - time_start))
+            data = data[0:-2]
+            if data == "":
+                #print "[Received an empty line]"
+                print
+            elif data[0] == ' ':
+                print time_now_str, data[1:]
+            elif data[0] == 'U':
+                data = data[1:]
+                cur_type = 0
+                i = 0
+                usb_events = []
+                while len(data) > 0:
+                    c = data[0]
+
+                    if cur_type == 0:
+                        if c == 'a':
+                            cur_type = 1
+                        elif (c >= 'A') and (c <= 'P'):
+                            i = ord(c) - ord('A')
+                            cur_type = 2
+                        else:
+                            print time_now_str, "[Unknown type: '%s' (0x%02x) in '%s']" % (c, ord(c), data)
+
+                    elif cur_type == 1:
+                        i = ord(c) - ord('a')
+                        if (i < 0) or (i >= len(USB_PHY_ERROR_REGISTERS)):
+                            print time_now_str, "[Unknown PHY error register index: '%s' (0x%02x) (%d) in '%s']" % (c, ord(c), i, data)
+                        else:
+                            print time_now_str, USB_PHY_ERROR_REGISTERS[i]
+                        cur_type = 0
+
+                    elif cur_type == 2:
+                        i2 = ord(c) - ord('A')
+                        if (c < 'A') or (c > 'P'):
+                            print time_now_str, "[Unknown second USB event part: '%s' (0x%02x) (%d) in '%s']" % (c, ord(c), i2, data)
+                        else:
+                            i = (i << 4) | i2
+                            usb_events += [i]
+
+                        cur_type = 0
+
+                    data = data[1:]
+
+                if len(usb_events) > 0:
+                    usb_event_log_read_count += 1
+                    l = _parse_usb_event_log(usb_events)
+                    print "\n".join(map(lambda x: time_now_str + ("[%05i] " % (usb_event_log_read_count)) + x[0] + ":\t" + x[1], l))
+                    #print
+
+            data = ""
+
+def main():
+    parser = OptionParser(usage="%prog: [options]")    #option_class=eng_option,
+
+    parser.add_option("-v", "--vid", type="string", default="0x2500", help="VID [default=%default]")
+    parser.add_option("-p", "--pid", type="string", default="0x0020", help="PID [default=%default]")
+    parser.add_option("-t", "--tty", type="string", default=None, help="TTY [default=%default]")
+    parser.add_option("-c", "--cmd", type="string", default="", help="Command (empty opens prompt)")
+    parser.add_option("-n", "--counters", type="float", default="5.0", help="Counter print interval [default=%default]")
+    parser.add_option("-l", "--log", type="float", default="0.25", help="Log print interval [default=%default]")
+    parser.add_option("-e", "--usb-events", type="float", default="0.25", help="USB event log print interval [default=%default]")
+    parser.add_option("-s", "--sb", type="string", default=None, help="Settings Bus write message [default=%default]")
+    parser.add_option("-d", "--sb-baud-div", type="int", default=None, help="Settings Bus baud rate divisor [default=%default]")
+    parser.add_option("-b", "--sb-baud", type="int", default=None, help="Settings Bus baud rate [default=%default]")
+    parser.add_option("-r", "--clear-screen", action="store_true", default=False, help="Clear screen [default=%default]")
+    parser.add_option("-R", "--reset-counters", action="store_true", default=False, help="Reset counters [default=%default]")
+    parser.add_option("-f", "--flush-data-eps", action="store_true", default=False, help="Flush data endpoints [default=%default]")
+    parser.add_option("-L", "--fe-loopback", type="int", default=None, help="Change AD9361 digital loopback [default=%default]")
+
+    (options, args) = parser.parse_args()
+
+    if options.tty is not None and options.tty != "":
+        while True:
+            try:
+                ser = serial.Serial(port=options.tty, baudrate=115200, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=None)    # timeout: None (blocking), 0 (non-blocking)
+                print "Opened", options.tty
+
+                try:
+                    recv_serial_data(ser)
+                except KeyboardInterrupt:
+                    break
+            except Exception, e:
+                print e
+            break
+    else:
+        dev = usb_device()
+
+        while True:
+            try:
+                dev.open(idVendor=hex_to_int(options.vid), idProduct=hex_to_int(options.pid))
+                if options.flush_data_eps:
+                    dev.vrt_set(B200_VREQ_FLUSH_DATA_EPS)
+                if options.sb_baud_div is not None:
+                    dev.vrt_set(B200_VREQ_SET_SB_BAUD_DIV, struct.pack('H', options.sb_baud_div))
+                if options.sb is not None and len(options.sb) > 0:
+                    dev.vrt_set(B200_VREQ_WRITE_SB, " " + options.sb)
+                if options.reset_counters:
+                    dev.vrt_set(B200_VREQ_CLEAR_COUNTERS)
+                if options.fe_loopback is not None:
+                    dev.vrt_set(B200_VREQ_AD9361_LOOPBACK, struct.pack('B', int(options.fe_loopback)))
+                if len(options.cmd) == 0:
+                    run_log(dev, options)
+                    pass
+                else:
+                    pass
+
+                break
+            except usb.core.USBError, e:
+                if e.errno == 19:    # No such device
+                    pass
+                print e
+                break
+
+    return 0
+
+if __name__ == '__main__':
+    main()