[BFN] Move qsfp eeprom reading to new cached api (#9909)

* Move qsfp eeprom reading to new cached api

* provide reading multiple pages in recursive manner

* workaround with flat memory on cmis

* remove workaround with memory model

* Remove unused imports

Author: dmytroxIntel

platform/barefoot/sonic-platform-modules-bfn-montara/sonic_platform/platform_thrift_client.py

@@ -1,12 +1,10 @@
 #!/usr/bin/env python
 
 try:
-    import os
-    import sys
     import time
-    import importlib
 
-    sys.path.append(os.path.dirname(__file__))
+    from sonic_platform.pltfm_mgr_rpc.pltfm_mgr_rpc import Client
+    from sonic_platform.pltfm_mgr_rpc.pltfm_mgr_rpc import InvalidPltfmMgrOperation
 
     from thrift.transport import TSocket
     from thrift.transport import TTransport
@@ -25,9 +23,8 @@ def open(self):
         self.transport = TTransport.TBufferedTransport(self.transport)
         bprotocol = TBinaryProtocol.TBinaryProtocol(self.transport)
 
-        self.pltfm_mgr_module = importlib.import_module(".".join(["pltfm_mgr_rpc", "pltfm_mgr_rpc"]))
         pltfm_mgr_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "pltfm_mgr_rpc")
-        self.pltfm_mgr = self.pltfm_mgr_module.Client(pltfm_mgr_protocol)
+        self.pltfm_mgr = Client(pltfm_mgr_protocol)
 
         self.transport.open()
         return self
@@ -59,7 +56,7 @@ def pltfm_mgr_try(func, default=None, thrift_attempts=35):
     def pm_cb_run(client):
        try:
            return (None, func(client.pltfm_mgr))
-       except client.pltfm_mgr_module.InvalidPltfmMgrOperation as ouch:
+       except InvalidPltfmMgrOperation as ouch:
            return (ouch.code, default)
 
     return thrift_try(pm_cb_run)

platform/barefoot/sonic-platform-modules-bfn-montara/sonic_platform/pltfm_mgr_rpc/ttypes.py

@@ -11,29 +11,38 @@
 SFP_TYPE = "SFP"
 QSFP_TYPE = "QSFP"
 QSFP_DD_TYPE = "QSFP_DD"
+EEPROM_PAGE_SIZE = 128
 
+try:
+    from thrift.Thrift import TApplicationException
+
+    def cached_num_bytes_get(client):
+        return client.pltfm_mgr.pltfm_mgr_qsfp_cached_num_bytes_get(1, 0, 0, 0)
+    thrift_try(cached_num_bytes_get, 1)
+    EEPROM_CACHED_API_SUPPORT = True
+except TApplicationException as e:
+    EEPROM_CACHED_API_SUPPORT = False
 
 class Sfp(SfpOptoeBase):
     """
     BFN Platform-specific SFP class
     """
 
-    SFP_EEPROM_PATH = "/var/run/platform/sfp/"
-
     def __init__(self, port_num):
         SfpOptoeBase.__init__(self)
         self.index = port_num
         self.port_num = port_num
         self.sfp_type = QSFP_TYPE
+        self.SFP_EEPROM_PATH = "/var/run/platform/sfp/"
 
-        if not os.path.exists(self.SFP_EEPROM_PATH):
-            try:
-                os.makedirs(self.SFP_EEPROM_PATH)
-            except OSError as e:
-                if e.errno != errno.EEXIST:
-                    raise
-
-        self.eeprom_path = self.SFP_EEPROM_PATH + "sfp{}-eeprom-cache".format(self.index)
+        if not EEPROM_CACHED_API_SUPPORT:
+            if not os.path.exists(self.SFP_EEPROM_PATH):
+                try:
+                    os.makedirs(self.SFP_EEPROM_PATH)
+                except OSError as e:
+                    if e.errno != errno.EEXIST:
+                        raise
+            self.eeprom_path = self.SFP_EEPROM_PATH + "sfp{}-eeprom-cache".format(self.index)
 
     def get_presence(self):
         """
@@ -47,7 +56,7 @@ def qsfp_presence_get(client):
         try:
             presence = thrift_try(qsfp_presence_get)
         except Exception as e:
-            print( e.__doc__)
+            print(e.__doc__)
             print(e.message)
 
         return presence
@@ -75,14 +84,31 @@ def get_eeprom_path(self):
         def qsfp_info_get(client):
             return client.pltfm_mgr.pltfm_mgr_qsfp_info_get(self.index)
 
-        if self.get_presence():
-            eeprom_hex = thrift_try(qsfp_info_get)
-            eeprom_raw = bytearray.fromhex(eeprom_hex)
-            with open(self.eeprom_path, 'wb') as fp:
-                fp.write(eeprom_raw)
-            return self.eeprom_path
+        eeprom_hex = thrift_try(qsfp_info_get)
+        eeprom_raw = bytearray.fromhex(eeprom_hex)
+        with open(self.eeprom_path, 'wb') as fp:
+            fp.write(eeprom_raw)
+        return self.eeprom_path
+
+    def read_eeprom(self, offset, num_bytes):
+        if not self.get_presence():
+            return None
+
+        if not EEPROM_CACHED_API_SUPPORT:
+            return super().read_eeprom(offset, num_bytes)
+
+        def cached_num_bytes_get(page, offset, num_bytes):
+            def qsfp_cached_num_bytes_get(client):
+                return client.pltfm_mgr.pltfm_mgr_qsfp_cached_num_bytes_get(self.index, page, offset, num_bytes)
+            return bytearray.fromhex(thrift_try(qsfp_cached_num_bytes_get))
+
+        page_offset = offset % EEPROM_PAGE_SIZE
+        if page_offset + num_bytes > EEPROM_PAGE_SIZE:
+            curr_page_num_bytes_left = EEPROM_PAGE_SIZE - page_offset
+            curr_page_bytes = cached_num_bytes_get(offset // EEPROM_PAGE_SIZE, page_offset, curr_page_num_bytes_left)
+            return curr_page_bytes + self.read_eeprom(offset + curr_page_num_bytes_left, num_bytes - curr_page_num_bytes_left)
 
-        return None
+        return cached_num_bytes_get(offset // EEPROM_PAGE_SIZE, page_offset, num_bytes)
 
     def write_eeprom(self, offset, num_bytes, write_buffer):
         # Not supported at the moment