mpm: Moved over to new logging infrastructure

Also currently hardcodes some settings.

4 files changed, 55 insertions, 40 deletions

diff --git a/mpm/python/usrp_mpm/periph_manager/base.py b/mpm/python/usrp_mpm/periph_manager/base.py
index 77414c034..459f8833f 100644
--- a/mpm/python/usrp_mpm/periph_manager/base.py
+++ b/mpm/python/usrp_mpm/periph_manager/base.py
@@ -19,12 +19,13 @@ Mboard implementation base class
 """
 
 import os
+from six import iteritems
+from ..mpmlog import get_logger
+from logging import getLogger
 from ..types import EEPROM
 from .. import dboard_manager
 from .udev import get_eeprom_path
 from .udev import get_spidev_nodes
-from six import iteritems
-
 
 class PeriphManagerBase(object):
     """"
@@ -48,22 +49,38 @@ class PeriphManagerBase(object):
     available_endpoints = range(256)
 
     def __init__(self):
+        self.log = get_logger('PeriphManager')
         # I know my EEPROM address, lets use it
         self.overlays = ""
-        (self._eeprom_head, self._eeprom_rawdata) = EEPROM().read_eeprom(
-            get_eeprom_path(self.mboard_eeprom_addr))
-        print self._eeprom_head
+        # (self._eeprom_head, self._eeprom_rawdata) = EEPROM().read_eeprom(
+            # 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_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:
-                spi_devices = get_spidev_nodes(self.dboard_spimaster_addrs.get(dboard_slot))
-            dboard = dboard_manager.HW_PIDS.get(hw_pid, dboard_manager.unknown)
-            self.dboards.update({dboard_slot: dboard(spi_devices, eeprom_data)})
+        self.log.debug("Initializing dboards")
+        # for dboard_slot, eeprom_addr in self.dboard_eeprom_addrs.iteritems():
+            # self.log.debug("Adding dboard for slot {0}".format(dboard_slot))
+            # spi_devices = []
+            # # I know EEPROM adresses for my dboard slots
+            # 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:
+                # spi_devices = get_spidev_nodes(self.dboard_spimaster_addrs.get(dboard_slot))
+            # dboard = dboard_manager.HW_PIDS.get(hw_pid, dboard_manager.unknown)
+            # self.dboards.update({dboard_slot: dboard(spi_devices, eeprom_data)})
+        dboard_slot = "A"
+        self.log.debug("Adding dboard for slot {0}".format(dboard_slot))
+        spi_devices = []
+        # I know EEPROM adresses for my dboard slots
+        # eeprom_data = EEPROM().read_eeprom(get_eeprom_path(eeprom_addr))
+        eeprom_data = None
+        # I know spidev masters on the dboard slots
+        hw_pid = 2
+        if hw_pid in dboard_manager.HW_PIDS:
+            spi_devices = get_spidev_nodes("e0006000.spi")
+            self.log.debug("found spidev nodes: {0}".format(spi_devices))
+        dboard = dboard_manager.HW_PIDS.get(hw_pid, dboard_manager.unknown)
+        self.dboards.update({dboard_slot: dboard(spi_devices, eeprom_data)})
 
     def safe_list_updateable_components(self):
         """
diff --git a/mpm/python/usrp_mpm/periph_manager/n310.py b/mpm/python/usrp_mpm/periph_manager/n310.py
index 4f193b54b..364d50908 100644
--- a/mpm/python/usrp_mpm/periph_manager/n310.py
+++ b/mpm/python/usrp_mpm/periph_manager/n310.py
@@ -31,9 +31,6 @@ from logging import getLogger
 import netaddr
 import socket
 
-LOG = getLogger(__name__)
-
-
 class n310(PeriphManagerBase):
     """
     Holds N310 specific attributes and methods
@@ -42,13 +39,15 @@ class n310(PeriphManagerBase):
     mboard_type = "n310"
     mboard_eeprom_addr = "e0005000.i2c"
     # dboard_eeprom_addrs = {"A": "something", "B": "else"}
+    # dboard_eeprom_addrs = {"A": "e0004000.i2c",}
     # dboard_spimaster_addrs = {"A": "something", "B": "else"}
+    dboard_spimaster_addrs = {"A": "e0006000.spi",}
     interfaces = {}
 
     def __init__(self, *args, **kwargs):
         # First initialize parent class - will populate self._eeprom_head and self._eeprom_rawdata
         super(n310, self).__init__(*args, **kwargs)
-        data = self._read_eeprom_v1(self._eeprom_rawdata)
+        # 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]),
@@ -62,12 +61,15 @@ class n310(PeriphManagerBase):
         #     "mac_addr": byte_to_mac(data[2]),
         #     "addrs": get_iface_addrs(byte_to_mac(data[2]))
         # }
-        self.mboard_info["serial"] = data[0]  # some format
+        # self.mboard_info["serial"] = data[0]  # some format
+        self.mboard_info["serial"] = '123'  # some format
         with open("/sys/class/rfnoc_crossbar/crossbar0/local_addr", "w") as xbar:
             xbar.write("0x2")
-
         # if header.get("dataversion", 0) == 1:
 
+        # Initialize our daughterboards:
+        self.log.debug("Initializing A-side dboard")
+        self.dboards['A'].init_device()
 
     def _read_eeprom_v1(self, data):
         """
@@ -119,11 +121,11 @@ class n310(PeriphManagerBase):
             # uio_path, uio_size = get_uio_node("misc-enet-regs0")
             uio_path = "/dev/uio0"
             uio_size = 0x2000
-            LOG.debug("got uio_path and size")
+            self.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)
+            self.log.info("got my uio")
+            self.log.info("ip_addr: %s", sender_addr)
+            # self.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)
diff --git a/mpm/python/usrp_mpm/periph_manager/net.py b/mpm/python/usrp_mpm/periph_manager/net.py
index 2df771549..4eb1890cb 100644
--- a/mpm/python/usrp_mpm/periph_manager/net.py
+++ b/mpm/python/usrp_mpm/periph_manager/net.py
@@ -20,10 +20,7 @@ N310 implementation module
 import itertools
 import socket
 from pyroute2 import IPRoute
-from logging import getLogger
-
-LOG = getLogger(__name__)
-
+from ..mpmlog import get_logger
 
 def get_iface_addrs(mac_addr):
     """
@@ -57,7 +54,7 @@ def get_mac_addr(remote_addr):
     ip2 = IPRoute()
     addrs = ip2.get_neighbours(dst=remote_addr)
     if len(addrs) > 1:
-        LOG.warning("More than one device with the same IP address found. Picking entry at random")
+        get_logger('get_mac_addr').warning("More than one device with the same IP address found. Picking entry at random")
     if not addrs:
         return None
     return addrs[0].get_attr('NDA_LLADDR')
diff --git a/mpm/python/usrp_mpm/periph_manager/udev.py b/mpm/python/usrp_mpm/periph_manager/udev.py
index a42c95ef5..73601e85c 100644
--- a/mpm/python/usrp_mpm/periph_manager/udev.py
+++ b/mpm/python/usrp_mpm/periph_manager/udev.py
@@ -17,9 +17,7 @@
 
 import pyudev
 import os
-from logging import getLogger
-LOG = getLogger(__name__)
-
+from ..mpmlog import get_logger
 
 def get_eeprom_path(address):
     """
@@ -51,19 +49,20 @@ def get_uio_node(uio_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)
+    log = get_logger('get_uio_node')
+    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())
+        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)
+            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())
+            log.debug("got udev device")
+            log.debug("device_node: %s size: %s", "/dev/uio0", size.strip())
             return ("/dev/uio0", int(size.strip()))
     return ("", 0)