mpm: comment out functionality to make it work

 - add uio udev find routine
 - add debug prints

Signed-off-by: Andrej Rode <andrej.rode@ettus.com>
Signed-off-by: Moritz Fischer <moritz.fischer@ettus.com>

3 files changed, 99 insertions, 36 deletions

diff --git a/mpm/python/usrp_mpm/periph_manager/base.py b/mpm/python/usrp_mpm/periph_manager/base.py
index c84205a76..77414c034 100644
--- a/mpm/python/usrp_mpm/periph_manager/base.py
+++ b/mpm/python/usrp_mpm/periph_manager/base.py
@@ -21,7 +21,7 @@ Mboard implementation base class
 import os
 from ..types import EEPROM
 from .. import dboard_manager
-from .udev import get_eeprom
+from .udev import get_eeprom_path
 from .udev import get_spidev_nodes
 from six import iteritems
 
@@ -44,17 +44,20 @@ class PeriphManagerBase(object):
     dboard_eeprom_addrs = {}
     dboard_spimaster_addrs = {}
     updateable_components = []
+    sid_endpoints = {}
+    available_endpoints = range(256)
 
     def __init__(self):
         # I know my EEPROM address, lets use it
         self.overlays = ""
         (self._eeprom_head, self._eeprom_rawdata) = EEPROM().read_eeprom(
-            get_eeprom(self.mboard_eeprom_addr))
+            get_eeprom_path(self.mboard_eeprom_addr))
+        print self._eeprom_head
         self._dboard_eeproms = {}
         for dboard_slot, eeprom_addr in self.dboard_eeprom_addrs.iteritems():
             spi_devices = []
             # I know EEPROM adresses for my dboard slots
-            eeprom_data = EEPROM().read_eeprom(get_eeprom(eeprom_addr))
+            eeprom_data = EEPROM().read_eeprom(get_eeprom_path(eeprom_addr))
             # I know spidev masters on the dboard slots
             hw_pid = eeprom_data[0].get("hw_pid", 0)
             if hw_pid in dboard_manager.HW_PIDS:
@@ -116,7 +119,7 @@ class PeriphManagerBase(object):
         # Init dboards
         pass
 
-    def _probe_interface(self, sender_addr):
+    def _allocate_sid(self, sender_addr, sid, xbar_src_addr, xbar_src_port):
         """
         Overload this method in actual device implementation
         """
@@ -127,4 +130,3 @@ class PeriphManagerBase(object):
         Overload this method in actual device implementation
         """
         return []
-
diff --git a/mpm/python/usrp_mpm/periph_manager/n310.py b/mpm/python/usrp_mpm/periph_manager/n310.py
index 1b01ac066..4f193b54b 100644
--- a/mpm/python/usrp_mpm/periph_manager/n310.py
+++ b/mpm/python/usrp_mpm/periph_manager/n310.py
@@ -23,7 +23,13 @@ from .base import PeriphManagerBase
 from .net import get_iface_addrs
 from .net import byte_to_mac
 from .net import get_mac_addr
+from .udev import get_uio_node
+from ..types import SID
+from ..uio import uio
+from .. import libpyusrp_periphs as lib
 from logging import getLogger
+import netaddr
+import socket
 
 LOG = getLogger(__name__)
 
@@ -34,9 +40,9 @@ class n310(PeriphManagerBase):
     """
     hw_pids = "1"
     mboard_type = "n310"
-    mboard_eeprom_addr = "e0007000.spi:ec@0:i2c-tunnel"
-    dboard_eeprom_addrs = {"A": "something", "B": "else"}
-    dboard_spimaster_addrs = {"A": "something", "B": "else"}
+    mboard_eeprom_addr = "e0005000.i2c"
+    # dboard_eeprom_addrs = {"A": "something", "B": "else"}
+    # dboard_spimaster_addrs = {"A": "something", "B": "else"}
     interfaces = {}
 
     def __init__(self, *args, **kwargs):
@@ -44,21 +50,22 @@ class n310(PeriphManagerBase):
         super(n310, self).__init__(*args, **kwargs)
         data = self._read_eeprom_v1(self._eeprom_rawdata)
         # mac 0: mgmt port, mac1: sfp0, mac2: sfp1
-        self.interfaces["mgmt"] = {
-            "mac_addr": byte_to_mac(data[0]),
-            "addrs": get_iface_addrs(byte_to_mac(data[0]))
-        }
-        self.interfaces["sfp0"] = {
-            "mac_addr": byte_to_mac(data[1]),
-            "addrs": get_iface_addrs(byte_to_mac(data[1]))
-        }
-        self.interfaces["sfp1"] = {
-            "mac_addr": byte_to_mac(data[2]),
-            "addrs": get_iface_addrs(byte_to_mac(data[2]))
-        }
-        self.mboard_info["serial"] = data[3]  # some format
+        # self.interfaces["mgmt"] = {
+        #     "mac_addr": byte_to_mac(data[0]),
+        #     "addrs": get_iface_addrs(byte_to_mac(data[0]))
+        # }
+        # self.interfaces["sfp0"] = {
+        #     "mac_addr": byte_to_mac(data[1]),
+        #     "addrs": get_iface_addrs(byte_to_mac(data[1]))
+        # }
+        # self.interfaces["sfp1"] = {
+        #     "mac_addr": byte_to_mac(data[2]),
+        #     "addrs": get_iface_addrs(byte_to_mac(data[2]))
+        # }
+        self.mboard_info["serial"] = data[0]  # some format
+        with open("/sys/class/rfnoc_crossbar/crossbar0/local_addr", "w") as xbar:
+            xbar.write("0x2")
 
-        print(data)
         # if header.get("dataversion", 0) == 1:
 
 
@@ -66,15 +73,17 @@ class n310(PeriphManagerBase):
         """
         read eeprom with data version 1
         """
-        # data_version contains
+        # data contains
+        # 24 bytes header -> ignore them here
+        # 8 bytes serial
         # 6 bytes mac_addr0
         # 2 bytes pad
         # 6 bytes mac_addr1
         # 2 bytes pad
         # 6 bytes mac_addr2
         # 2 bytes pad
-        # 8 bytes serial
-        return struct.unpack_from("6s 2x 6s 2x 6s 2x 8s", data)
+        # 4 bytes CRC
+        return struct.unpack_from("!28x 8s 6s 2x 6s 2x 6s 2x I", data)
 
     def get_interfaces(self):
         """
@@ -89,15 +98,40 @@ class n310(PeriphManagerBase):
         """
         return self.interfaces.get(interface, {}).get("addrs", [])
 
-    def _probe_interface(self, sender_addr):
+    def _allocate_sid(self, sender_addr, port, sid, xbar_src_addr, xbar_src_port):
         """
         Get the MAC address of the sender and store it in the FPGA ARP table
         """
         mac_addr = get_mac_addr(sender_addr)
+        new_ep = self.available_endpoints.pop(0)
         if mac_addr is not None:
-            # Do something with mac_address
-            return True
-        return False
-
-
-
+            if sender_addr not in self.sid_endpoints:
+                self.sid_endpoints.update({sender_addr: (new_ep,)})
+            else:
+                current_allocation = self.sid_endpoints.get(sender_addr)
+                new_allocation = current_allocation + (new_ep,)
+                self.sid_endpoints.update({sender_addr: new_allocation})
+            sid = SID(sid)
+            sid.set_src_addr(xbar_src_addr)
+            sid.set_src_ep(new_ep)
+            my_xbar = lib.xbar.xbar.make("/dev/crossbar0") # TODO
+            my_xbar.set_route(xbar_src_addr, 0) # TODO
+            # uio_path, uio_size = get_uio_node("misc-enet-regs0")
+            uio_path = "/dev/uio0"
+            uio_size = 0x2000
+            LOG.debug("got uio_path and size")
+            uio_obj = uio(uio_path, uio_size, read_only=False)
+            LOG.info("got my uio")
+            LOG.info("ip_addr: %s", sender_addr)
+            # LOG.info("mac_addr: %s", mac_addr)
+            ip_addr = int(netaddr.IPAddress(sender_addr))
+            mac_addr = int(netaddr.EUI(mac_addr))
+            uio_obj.poke32(0x1000 + 4*new_ep, ip_addr)
+            print("sid: %x" % (sid.get()))
+            print("gonna poke: %x %x" % (0x1000+4*new_ep, ip_addr))
+            uio_obj.poke32(0x1800 + 4*new_ep, mac_addr & 0xFFFFFFFF)
+            print("gonna poke: %x %x" % (0x1800+4*new_ep, mac_addr))
+            port = int(port)
+            uio_obj.poke32(0x1400 + 4*new_ep, ((int(port) << 16) | (mac_addr >> 32)))
+            print("gonna poke: %x %x" % (0x1400+4*new_ep, ((port << 16) | (mac_addr >> 32))))
+        return sid.get()
diff --git a/mpm/python/usrp_mpm/periph_manager/udev.py b/mpm/python/usrp_mpm/periph_manager/udev.py
index 014e18ede..a42c95ef5 100644
--- a/mpm/python/usrp_mpm/periph_manager/udev.py
+++ b/mpm/python/usrp_mpm/periph_manager/udev.py
@@ -16,19 +16,22 @@
 #
 
 import pyudev
+import os
+from logging import getLogger
+LOG = getLogger(__name__)
 
 
-def get_eeprom(address):
+def get_eeprom_path(address):
     """
     Return EEPROM device path for a given I2C address
     """
     context = pyudev.Context()
     parent = pyudev.Device.from_name(context, "platform", address)
-    paths = [device.dev_node if device.dev_node is not None else device.sys_path
+    paths = [device.device_node if device.device_node is not None else device.sys_path
              for device in context.list_devices(parent=parent, subsystem="nvmem")]
     if len(paths) != 1:
         raise Exception("{0} paths to EEPROM found!".format(len(paths)))
-    return paths[0]
+    return paths[0] + "/nvmem"
 
 
 def get_spidev_nodes(spi_master):
@@ -37,6 +40,30 @@ def get_spidev_nodes(spi_master):
     """
     context = pyudev.Context()
     parent = pyudev.Device.from_name(context, "platform", spi_master)
-    paths = [device.dev_node if device.dev_node is not None else device.sys_path
+    paths = [device.sys_path
              for device in context.list_devices(parent=parent, subsystem="spidev")]
     return paths
+
+def get_uio_node(uio_name):
+    """
+    Return found uio device path for a give parent name
+    """
+    context = pyudev.Context()
+    paths = [device.sys_path
+             for device in context.list_devices(subsystem="uio")]
+    LOG.debug("get_uio_node")
+    LOG.debug("got paths: %s", paths)
+    for path in paths:
+        with open(os.path.join(path, "maps", "map0", "name"), "r") as uio_file:
+            name = uio_file.read()
+        LOG.debug("uio_node name: %s", name.strip())
+        if name.strip() == uio_name:
+            with open(os.path.join(path, "maps", "map0", "size"), "r") as uio_file:
+                size = uio_file.read()
+            LOG.debug("uio_node size: %s", size.strip())
+            LOG.debug("uio_node syspath: %s", path)
+            # device = pyudev.Device.from_sys_path(context, path)
+            LOG.debug("got udev device")
+            LOG.debug("device_node: %s size: %s", "/dev/uio0", size.strip())
+            return ("/dev/uio0", int(size.strip()))
+    return ("", 0)