[device/celestica]: Implement Sfp APIs based on the new platform API (s…

…onic-net#3290)

* [platform/cel]: update qsfp driver for dx010

* [device/celestica]: add sfp api

* [device/celestica]: add eeprom api

device/celestica/x86_64-cel_e1031-r0/sonic_platform/chassis.py

@@ -21,13 +21,15 @@
     from sonic_platform.component import Component
     from sonic_platform.watchdog import Watchdog
     from sonic_platform.thermal import Thermal
+    from sonic_platform.sfp import Sfp
+    from sonic_platform.eeprom import Tlv
 except ImportError as e:
     raise ImportError(str(e) + "- required module not found")
 
 NUM_FAN = 3
 NUM_PSU = 2
 NUM_THERMAL = 7
-CONFIG_DB_PATH = "/etc/sonic/config_db.json"
+NUM_SFP = 52
 RESET_REGISTER = "0x112"
 REBOOT_CAUSE_PATH = "/host/reboot-cause/previous-reboot-cause.txt"
 COMPONENT_NAME_LIST = ["SMC_CPLD", "MMC_CPLD", "BIOS"]
@@ -47,17 +49,13 @@ def __init__(self):
         for index in range(0, NUM_THERMAL):
             thermal = Thermal(index)
             self._thermal_list.append(thermal)
+        for index in range(0, NUM_SFP):
+            sfp = Sfp(index)
+            self._sfp_list.append(sfp)
         ChassisBase.__init__(self)
         self._component_name_list = COMPONENT_NAME_LIST
         self._watchdog = Watchdog()
-
-    def __read_config_db(self):
-        try:
-            with open(CONFIG_DB_PATH, 'r') as fd:
-                data = json.load(fd)
-                return data
-        except IOError:
-            raise IOError("Unable to open config_db file !")
+        self._eeprom = Tlv()
 
     def __read_txt_file(self, file_path):
         try:
@@ -74,12 +72,25 @@ def get_base_mac(self):
             A string containing the MAC address in the format
             'XX:XX:XX:XX:XX:XX'
         """
-        try:
-            self.config_data = self.__read_config_db()
-            base_mac = self.config_data["DEVICE_METADATA"]["localhost"]["mac"]
-            return str(base_mac)
-        except KeyError:
-            return str(None)
+        return self._eeprom.get_mac()
+
+    def get_serial_number(self):
+        """
+        Retrieves the hardware serial number for the chassis
+        Returns:
+            A string containing the hardware serial number for this chassis.
+        """
+        return self._eeprom.get_serial()
+
+    def get_system_eeprom_info(self):
+        """
+        Retrieves the full content of system EEPROM information for the chassis
+        Returns:
+            A dictionary where keys are the type code defined in
+            OCP ONIE TlvInfo EEPROM format and values are their corresponding
+            values.
+        """
+        return self._eeprom.get_eeprom()
 
     def get_firmware_version(self, component_name):
         """

device/celestica/x86_64-cel_e1031-r0/sonic_platform/eeprom.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+#############################################################################
+# Celestica Haliburton
+#
+# Platform and model specific eeprom subclass, inherits from the base class,
+# and provides the followings:
+# - the eeprom format definition
+# - specific encoder/decoder if there is special need
+#############################################################################
+
+try:
+    import glob
+    import os
+    import sys
+    import imp
+    import re
+    from array import array
+    from cStringIO import StringIO
+    from sonic_platform_base.sonic_eeprom import eeprom_dts
+    from sonic_platform_base.sonic_eeprom import eeprom_tlvinfo
+except ImportError, e:
+    raise ImportError(str(e) + "- required module not found")
+
+CACHE_ROOT = '/var/cache/sonic/decode-syseeprom'
+CACHE_FILE = 'syseeprom_cache'
+
+
+class Tlv(eeprom_tlvinfo.TlvInfoDecoder):
+
+    EEPROM_DECODE_HEADLINES = 6
+
+    def __init__(self):
+        self._eeprom_path = "/sys/class/i2c-adapter/i2c-2/2-0050/eeprom"
+        super(Tlv, self).__init__(self._eeprom_path, 0, '', True)
+        self._eeprom = self._load_eeprom()
+
+    def __parse_output(self, decode_output):
+        decode_output.replace('\0', '')
+        lines = decode_output.split('\n')
+        lines = lines[self.EEPROM_DECODE_HEADLINES:]
+        _eeprom_info_dict = dict()
+
+        for line in lines:
+            try:
+                match = re.search(
+                    '(0x[0-9a-fA-F]{2})([\s]+[\S]+[\s]+)([\S]+)', line)
+                if match is not None:
+                    idx = match.group(1)
+                    value = match.group(3).rstrip('\0')
+
+                _eeprom_info_dict[idx] = value
+            except:
+                pass
+        return _eeprom_info_dict
+
+    def _load_eeprom(self):
+        original_stdout = sys.stdout
+        sys.stdout = StringIO()
+        err = self.read_eeprom_db()
+        if err:
+            # Failed to read EEPROM information from database. Read from cache file
+            pass
+        else:
+            decode_output = sys.stdout.getvalue()
+            sys.stdout = original_stdout
+            return self.__parse_output(decode_output)
+
+        status = self.check_status()
+        if status <> 'ok':
+            return False
+
+        if not os.path.exists(CACHE_ROOT):
+            try:
+                os.makedirs(CACHE_ROOT)
+            except:
+                pass
+
+        #
+        # only the eeprom classes that inherit from eeprom_base
+        # support caching. Others will work normally
+        #
+        try:
+            self.set_cache_name(os.path.join(CACHE_ROOT, CACHE_FILE))
+        except:
+            pass
+
+        e = self.read_eeprom()
+        if e is None:
+            return 0
+
+        try:
+            self.update_cache(e)
+        except:
+            pass
+
+        self.decode_eeprom(e)
+        decode_output = sys.stdout.getvalue()
+        sys.stdout = original_stdout
+
+        (is_valid, valid_crc) = self.is_checksum_valid(e)
+        if not is_valid:
+            return False
+
+        return self.__parse_output(decode_output)
+
+    def get_eeprom(self):
+        return self._eeprom
+
+    def get_serial(self):
+        return self._eeprom.get('0x23', "Undefined.")
+
+    def get_mac(self):
+        return self._eeprom.get('0x24', "Undefined.")