[inventec/d7054q28b] Add new platform APIs chassis, eeprom,fan, psu, thermal, sfp (#3577)

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/setup.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+
+import os
+import sys
+from setuptools import setup
+os.listdir
+
+setup(
+   name='sonic_platform',
+   version='1.0',
+   description='Module to initialize Inventec D7054Q28B platforms',
+   
+   packages=['sonic_platform'],
+)
+

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/sonic_platform/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["platform", "chassis"]
+from sonic_platform import *
+

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/sonic_platform/chassis.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python
+#
+# Name: chassis.py, version: 1.0
+#
+# Description: Module contains the definitions of SONiC platform APIs 
+#
+
+try:
+    import os
+    from sonic_platform_base.chassis_base import ChassisBase
+    from sonic_platform.eeprom import Eeprom
+    from sonic_platform.psu import Psu
+    from sonic_platform.sfp import Sfp
+    from sonic_platform.fan import Fan
+    from sonic_platform.watchdog import Watchdog
+    from sonic_platform.thermal import Thermal
+
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+class Chassis(ChassisBase):
+
+    def __init__(self):
+        ChassisBase.__init__(self)
+        self.__num_of_psus     = 2
+        self.__num_of_ports    = 54
+        self.__num_of_sfps     = 48
+        self.__num_of_fans     = 4
+        self.__num_of_thermals = 6
+
+        # Initialize EEPROM
+        self._eeprom = Eeprom()
+       
+        # Initialize watchdog
+        #self._watchdog = Watchdog()
+
+        # Initialize FAN 
+        for index in range(1, self.__num_of_fans + 1):
+            fan = Fan(index)
+            self._fan_list.append(fan)
+        
+        # Initialize thermal
+        for index in range(1, self.__num_of_thermals + 1):
+            thermal = Thermal(index)
+            self._thermal_list.append(thermal)
+
+        # Initialize PSU and PSU_FAN
+        for index in range(1, self.__num_of_psus + 1):
+            psu = Psu(index)
+            self._psu_list.append(psu)
+            fan = Fan(index, True)
+            self._fan_list.append(fan)
+
+        # Initialize SFP
+        for index in range(0, self.__num_of_ports):
+           if index in range(0,self.__num_of_sfps):
+               sfp = Sfp(index, 'SFP')
+           else:
+               sfp = Sfp(index, 'QSFP')
+
+           self._sfp_list.append(sfp)
+           
+##############################################
+# Device methods
+##############################################
+
+    def get_name(self):
+        """
+        Retrieves the name of the chassis
+        Returns:
+            string: The name of the chassis
+        """
+        return self._eeprom.modelstr()
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the chassis
+        Returns:
+            bool: True if chassis is present, False if not
+        """
+        return True
+
+    def get_model(self):
+        """
+        Retrieves the model number (or part number) of the chassis
+        Returns:
+            string: Model/part number of chassis
+        """
+        return self._eeprom.part_number_str()
+
+    def get_serial(self):
+        """
+        Retrieves the serial number of the chassis
+        Returns:
+            string: Serial number of chassis
+        """
+        return self._eeprom.serial_number_str()
+
+    def get_status(self):
+        """
+        Retrieves the operational status of the chassis
+        Returns:
+            bool: A boolean value, True if chassis is operating properly
+            False if not
+        """
+        return True
+
+##############################################
+# Chassis methods
+##############################################
+
+    def get_base_mac(self):
+        """
+        Retrieves the base MAC address for the chassis
+
+        Returns:
+            A string containing the MAC address in the format
+            'XX:XX:XX:XX:XX:XX'
+        """
+        return self._eeprom.base_mac_addr()
+
+    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.serial_number_str()
+
+    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.
+            Ex. { '0x21':'AG9064', '0x22':'V1.0', '0x23':'AG9064-0109867821',
+                  '0x24':'001c0f000fcd0a', '0x25':'02/03/2018 16:22:00',
+                  '0x26':'01', '0x27':'REV01', '0x28':'AG9064-C2358-16G'}
+        """
+        return self._eeprom.system_eeprom_info()
+
+    def get_reboot_cause(self):
+        """
+        Retrieves the cause of the previous reboot
+        Returns:
+            A tuple (string, string) where the first element is a string
+            containing the cause of the previous reboot. This string must be
+            one of the predefined strings in this class. If the first string
+            is "REBOOT_CAUSE_HARDWARE_OTHER", the second string can be used
+            to pass a description of the reboot cause.
+        """
+        raise NotImplementedError

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/sonic_platform/eeprom.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+#
+# Name: eeprom.py, version: 1.0
+#
+# Description: Module contains the definitions of SONiC platform APIs 
+#
+
+try:
+    from sonic_eeprom import eeprom_tlvinfo
+    import binascii
+except ImportError, e:
+    raise ImportError(str(e) + "- required module not found")
+
+class Eeprom(eeprom_tlvinfo.TlvInfoDecoder):
+
+    def __init__(self):
+        self.__eeprom_path = "/sys/class/i2c-adapter/i2c-0/0-0053/eeprom"
+        super(Eeprom, self).__init__(self.__eeprom_path, 0, '', True)
+        self.__eeprom_tlv_dict = dict()
+        try:
+            self.__eeprom_data = self.read_eeprom()
+        except:
+            self.__eeprom_data = "N/A"
+            raise RuntimeError("Eeprom is not Programmed")
+        else:
+            eeprom = self.__eeprom_data
+
+            if not self.is_valid_tlvinfo_header(eeprom):
+                return
+
+            total_length = (ord(eeprom[9]) << 8) | ord(eeprom[10])
+            tlv_index = self._TLV_INFO_HDR_LEN
+            tlv_end = self._TLV_INFO_HDR_LEN + total_length
+
+            while (tlv_index + 2) < len(eeprom) and tlv_index < tlv_end:
+                if not self.is_valid_tlv(eeprom[tlv_index:]):
+                    break
+
+                tlv = eeprom[tlv_index:tlv_index + 2
+                             + ord(eeprom[tlv_index + 1])]
+                code = "0x%02X" % (ord(tlv[0]))
+
+                if ord(tlv[0]) == self._TLV_CODE_VENDOR_EXT:
+                    value = str((ord(tlv[2]) << 24) | (ord(tlv[3]) << 16) |
+                                (ord(tlv[4]) << 8) | ord(tlv[5]))
+                    value += str(tlv[6:6 + ord(tlv[1])])
+                else:
+                    name, value = self.decoder(None, tlv)
+
+                self.__eeprom_tlv_dict[code] = value
+                if ord(eeprom[tlv_index]) == self._TLV_CODE_CRC_32:
+                    break
+
+                tlv_index += ord(eeprom[tlv_index+1]) + 2
+
+    def serial_number_str(self):
+        (is_valid, results) = self.get_tlv_field(
+                         self.__eeprom_data, self._TLV_CODE_SERIAL_NUMBER)
+        if not is_valid:
+            return "N/A"
+        return results[2]
+
+    def base_mac_addr(self):
+        (is_valid, t) = self.get_tlv_field(
+                          self.__eeprom_data, self._TLV_CODE_MAC_BASE)
+        if not is_valid or t[1] != 6:
+            return super(TlvInfoDecoder, self).switchaddrstr(e)
+
+        return ":".join([binascii.b2a_hex(T) for T in t[2]])
+
+    def modelstr(self):
+        (is_valid, results) = self.get_tlv_field(
+                        self.__eeprom_data, self._TLV_CODE_PRODUCT_NAME)
+        if not is_valid:
+            return "N/A"
+
+        return results[2]
+
+    def part_number_str(self):
+        (is_valid, results) = self.get_tlv_field(
+                    self.__eeprom_data, self._TLV_CODE_PART_NUMBER)
+        if not is_valid:
+            return "N/A"
+
+        return results[2]
+
+    def serial_tag_str(self):
+        (is_valid, results) = self.get_tlv_field(
+                    self.__eeprom_data, self._TLV_CODE_SERVICE_TAG)
+        if not is_valid:
+            return "N/A"
+
+        return results[2]
+
+    def revision_str(self):
+        (is_valid, results) = self.get_tlv_field(
+                    self.__eeprom_data, self._TLV_CODE_DEVICE_VERSION)
+        if not is_valid:
+            return "N/A"
+
+        return results[2]
+
+    def system_eeprom_info(self):
+        """
+        Returns a dictionary, where keys are the type code defined in
+        ONIE EEPROM format and values are their corresponding values
+        found in the system EEPROM.
+        """
+        return self.__eeprom_tlv_dict
+

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/sonic_platform/fan.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+
+#############################################################################
+# Inventec d7264
+#
+# Module contains an implementation of SONiC Platform Base API and
+# provides the FAN information
+#
+#############################################################################
+
+try:
+    import os
+    from sonic_platform_base.fan_base import FanBase
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+
+###############
+# Global
+###############
+FAN_DIR      = "/sys/bus/i2c/devices/0-0066/"
+MAX_PWM      = 255
+class Fan(FanBase):
+    """Platform-specific Fan class"""
+
+    def __init__(self, index, is_psu_fan=False):
+        self.is_psu_fan = is_psu_fan
+
+        self.fan_gpi                        = "fan_gpi"
+        self.fan_index                      = index
+        if self.is_psu_fan:
+            self.fan_pwm                        = "pwm_psu{}".format(self.fan_index)
+            self.psu_fan_rpm                    = "rpm_psu{}".format(self.fan_index)
+        else:
+            self.fan_pwm                        = "pwm{}".format(self.fan_index)
+            self.fan_status_led_green_color     = "fan_led_grn{}".format(self.fan_index)
+            self.fan_status_led_red_color       = "fan_led_red{}".format(self.fan_index)
+            self.fan_front_rpm                  = "fan{}_input".format(self.fan_index * 2 - 1)
+            self.fan_rear_rpm                   = "fan{}_input".format(self.fan_index * 2)
+
+
+#######################
+# private function
+#######################
+
+    def __get_attr_value(self, attr_path):
+
+        retval = 'ERR'
+        if (not os.path.isfile(attr_path)):
+            return retval
+
+        try:
+            with open(attr_path, 'r') as fd:
+                retval = fd.read()
+        except Exception as error:
+            logging.error("Unable to open ", attr_path, " file !")
+
+        retval = retval.rstrip(' \t\n\r')
+        return retval
+
+
+    ####################
+    # Device base
+    ####################
+
+    def get_name(self):
+        """
+        Retrieves the name of the device
+
+        Returns:
+            string: The name of the device
+        """
+        if self.is_psu_fan:
+            return "PSU-{}_FAN".format(self.fan_index)
+        else:
+            return "FAN-{}".format(self.fan_index)
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the device
+
+        Returns:
+            bool: True if device is present, False if not
+
+        Note:
+            fan_gpi define 8 bits
+            low byte means fan presense
+            high byte means fan direction
+        """
+        presence = False
+        attr_path = FAN_DIR + self.fan_gpi
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            not_presence_bit = 1 << (self.fan_index - 1)
+            if not (int(attr_rv,16) and not_presence_bit):
+                presence = True
+
+        return presence
+
+    def get_status(self):
+        """
+        Retrieves the operational status of the device
+
+        Returns:
+            A boolean value, True if device is operating properly, False if not
+        """
+        if not self.is_psu_fan:
+            status = False
+            attr_grn_path = FAN_DIR + self.fan_status_led_green_color
+
+            attr_grn_rv = self.__get_attr_value(attr_grn_path)
+            if (attr_grn_rv != 'ERR' and attr_grn_rv == '1'):
+                status = True
+            return status
+
+    #################
+    # fan base
+    #################
+
+    def get_direction(self):
+        """
+        Retrieves the direction of fan
+
+        Returns:
+            A string, either FAN_DIRECTION_INTAKE or FAN_DIRECTION_EXHAUST
+            depending on fan direction
+
+        Note:
+            fan_gpi define 8 bits
+            low byte means fan presense
+            high byte means fan direction
+        """
+        direction = self.FAN_DIRECTION_INTAKE
+        attr_path = FAN_DIR + self.fan_gpi
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            #attr_rv = attr_rv >> 4
+            direction_bit = 1 << ((self.fan_index - 1)+4)
+            if not (int(attr_rv,16) and direction_bit):
+                direction = self.FAN_DIRECTION_EXHAUST
+
+        return direction
+
+    def get_speed(self):
+        """
+        Retrieves the speed of fan as a percentage of full speed
+
+        Returns:
+            An integer, the percentage of full fan speed, in the range 0 (off)
+                 to 100 (full speed)
+        """
+        speed = 0
+        attr_path = FAN_DIR + self.fan_pwm
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            pwm = int(attr_rv,10)if attr_rv else 0
+            speed = float(pwm*100/MAX_PWM)
+
+        return int(speed)
+
+    def get_target_speed(self):
+        """
+        Retrieves the target (expected) speed of the fan
+
+        Returns:
+            An integer, the percentage of full fan speed, in the range 0 (off)
+                 to 100 (full speed)
+        """
+        speed = 0
+        attr_path = FAN_DIR + self.fan_pwm
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            pwm = int(attr_rv,10)if attr_rv else 0
+            speed = float(pwm*100/MAX_PWM)
+
+        return int(speed)
+
+    def get_speed_tolerance(self):
+        """
+        Retrieves the speed tolerance of the fan
+
+        Returns:
+            An integer, the percentage of variance from target speed which is
+                 considered tolerable
+        """
+        return 20
+
+    def get_status_led(self):
+        """
+        Gets the state of the fan status LED
+
+        Returns:
+            A string, one of the predefined STATUS_LED_COLOR_* strings above
+        """
+        if self.is_psu_fan:
+            return self.STATUS_LED_COLOR_OFF
+
+        attr_grn_path = FAN_DIR + self.fan_status_led_green_color
+        attr_red_path = FAN_DIR + self.fan_status_led_red_color
+
+        attr_grn_rv = self.__get_attr_value(attr_grn_path)
+        attr_red_rv = self.__get_attr_value(attr_red_path)
+        if (attr_grn_rv != 'ERR' and attr_red_rv != 'ERR'):
+            if (attr_grn_rv == '1'):
+                return self.STATUS_LED_COLOR_GREEN
+            elif (attr_red_rv == '1'):
+                return self.STATUS_LED_COLOR_RED
+            else:
+                return self.STATUS_LED_COLOR_OFF

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/sonic_platform/platform.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+#
+# Name: platform.py, version: 1.0
+#
+# Description: Module contains the definitions of SONiC platform APIs 
+#
+
+
+try:
+    from sonic_platform_base.platform_base import PlatformBase
+    from sonic_platform.chassis import Chassis
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+ 
+ 
+class Platform(PlatformBase):
+
+    def __init__(self):
+        PlatformBase.__init__(self)
+        self._chassis = Chassis()

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/sonic_platform/psu.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python
+#
+# Name: psu.py, version: 1.0
+#
+# Description: Module contains the definitions of SONiC platform APIs 
+#
+
+try:
+    import os
+    from sonic_platform_base.psu_base import PsuBase
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+PSU_DIR = "/sys/bus/i2c/devices/0-0066/"
+
+class Psu(PsuBase):
+    def __init__(self, index):
+        self.index                = index
+        self.psu_presence_attr    = "psu{}".format(self.index-1)
+        self.psu_status_attr      = "psoc_psu{}_iout".format(self.index)
+        self.psu_power_in_attr    = "power{}_input".format(self.index)
+        self.psu_power_out_attr   = "power{}_input".format(self.index)
+        self.psu_voltage_out_attr = "psoc_psu{}_vin".format(self.index)
+        self.psu_current_out_attr = "psoc_psu{}_iout".format(self.index)
+        self.psu_serial_attr      = "psoc_psu{}_serial".format(self.index)
+        self.psu_model_attr       = "psoc_psu{}_vender".format(self.index)
+
+    def __get_attr_value(self, attr_path):
+
+        retval = 'ERR'
+        if (not os.path.isfile(attr_path)):
+            return retval
+
+        try:
+            with open(attr_path, 'r') as fd:
+                retval = fd.read()
+        except Exception as error:
+            logging.error("Unable to open ", attr_path, " file !")
+
+        retval = retval.rstrip(' \t\n\r')
+        return retval
+
+##############################################
+# Device methods
+##############################################
+
+    def get_name(self):
+        """
+        Retrieves the name of the device
+
+        Returns:
+            string: The name of the device
+        """
+        return "PSU{}".format(self.index)
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the device
+
+        Returns:
+            bool: True if device is present, False if not
+        """
+        presence = False
+        attr_path = PSU_DIR+self.psu_presence_attr
+        attr_normal = "0 : normal"
+        
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            if (attr_rv == attr_normal):
+                presence = True
+
+        return presence
+
+    def get_model(self):
+        """
+        Retrieves the model number (or part number) of the device
+
+        Returns:
+            string: Model/part number of device
+        """
+        model = "N/A"
+        attr_path = PSU_DIR+self.psu_model_attr
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            model = attr_rv
+
+        return model 
+
+    def get_serial(self):
+        """
+        Retrieves the serial number of the device
+
+        Returns:
+            string: Serial number of device
+        """
+        serial = "N/A"
+        attr_path = PSU_DIR+self.psu_serial_attr
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            serial = attr_rv
+
+        return serial 
+
+    def get_status(self):
+        """
+        Retrieves the operational status of the device
+
+        Returns:
+            A boolean value, True if device is operating properly, False if not
+        """
+        status = False
+        attr_path = PSU_DIR+self.psu_status_attr
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            if (int(attr_rv) != 0):
+                status = True
+
+        return status
+
+##############################################
+# PSU methods
+##############################################
+
+    def get_voltage(self):
+        """
+        Retrieves current PSU voltage output
+
+        Returns:
+            A float number, the output voltage in volts,
+            e.g. 12.1
+        """
+        voltage_out = 0.0
+        attr_path = PSU_DIR+self.psu_voltage_out_attr
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            voltage_out = float(attr_rv) / 1000
+
+        return voltage_out
+
+    def get_current(self):
+        """
+        Retrieves present electric current supplied by PSU
+
+        Returns:
+            A float number, the electric current in amperes, e.g 15.4
+        """
+        current_out = 0.0
+        attr_path = PSU_DIR+self.psu_current_out_attr
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            current_out = float(attr_rv) / 1000
+
+        return current_out
+
+    def get_power(self):
+        """
+        Retrieves current energy supplied by PSU
+
+        Returns:
+            A float number, the power in watts, e.g. 302.6
+        """
+        power_out = 0.0
+        attr_path = PSU_DIR+self.psu_power_out_attr
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            power_out = float(attr_rv) / 1000000
+
+        return power_out
+
+    def get_powergood_status(self):
+        """
+        Retrieves the powergood status of PSU
+
+        Returns:
+            A boolean, True if PSU has stablized its output voltages and passed all
+            its internal self-tests, False if not.
+        """
+        return self.get_status()
+
+    def get_status_led(self):
+        """
+        Gets the state of the PSU status LED
+
+        Returns:
+            A string, one of the predefined STATUS_LED_COLOR_* strings above
+        """
+        if self.get_powergood_status():
+            return self.STATUS_LED_COLOR_GREEN
+        else:
+            return self.STATUS_LED_COLOR_OFF
+

platform/broadcom/sonic-platform-modules-inventec/d7054q28b/sonic_platform/thermal.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+ 
+#############################################################################
+# Inventec d7264
+#
+# Module contains an implementation of SONiC Platform Base API and
+# provides the Thermal information
+#
+#############################################################################
+
+import os
+
+try:
+    from sonic_platform_base.thermal_base import ThermalBase
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+THERMAL_PATH = "/sys/bus/i2c/devices/0-0066/"
+
+thermal_name_tup = (
+    "FrontSide Temperature",
+    "FanBoard Temperature",
+    "NearASIC Temperature",
+    "Center(U10) Temperature",
+    "CPU Board Temperature",
+    "ASIC Temperature"
+)
+
+class Thermal(ThermalBase):
+    """Platform-specific Thermal class"""
+
+    def __init__(self, thermal_index):
+        self.index                  = thermal_index-1
+        self.thermal_tmp            = "temp{}_input".format(self.index)
+
+
+    def __get_attr_value(self, attr_path):
+
+        retval = 'ERR'
+        if (not os.path.isfile(attr_path)):
+            return retval
+
+        try:
+            with open(attr_path, 'r') as fd:
+                retval = fd.read()
+        except Exception as error:
+            logging.error("Unable to open ", attr_path, " file !")
+
+        retval = retval.rstrip(' \t\n\r')
+        return retval
+
+    def get_name(self):
+        """
+        Retrieves the name of the device
+
+        Returns:
+            string: The name of the device
+        """
+        return thermal_name_tup[self.index]
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the device
+
+        Returns:
+            bool: True if device is present, False if not
+        """
+        attr_path = THERMAL_PATH + self.thermal_tmp
+        return os.path.isfile(attr_path)
+
+    def get_status(self):
+        """
+        Retrieves the operational status of the device
+
+        Returns:
+            A boolean value, True if device is operating properly, False if not
+        """
+        status = False
+        if (self.get_temperature() > 0):
+            status = True
+
+        return status
+
+    def get_temperature(self):
+        """
+        Retrieves current temperature reading from thermal
+
+        Returns:
+            A float number of current temperature in Celsius up to nearest thousandth
+            of one degree Celsius, e.g. 30.125
+        """
+        temperature = 0.0
+        attr_path = THERMAL_PATH + self.thermal_tmp
+
+        attr_rv = self.__get_attr_value(attr_path)
+        if (attr_rv != 'ERR'):
+            temperature = float(attr_rv) / 1000
+
+        return temperature
+

platform/broadcom/sonic-platform-modules-inventec/debian/platform-modules-d7054q28b.install

@@ -1,4 +1,5 @@
 d7054q28b/utils/inventec_d7054_util.py usr/local/bin
+d7054q28b/utils/sonic_platform-1.0-py2-none-any.whl usr/share/sonic/device/x86_64-inventec_d7054q28b-r0
 common/utils/transceiver_monitor.py usr/share/sonic/device/x86_64-inventec_d7054q28b-r0/plugins
 common/utils/led_proc.py usr/share/sonic/device/x86_64-inventec_d7054q28b-r0/plugins
 common/utils/asic_monitor.py usr/share/sonic/device/x86_64-inventec_d7054q28b-r0/plugins

platform/broadcom/sonic-platform-modules-inventec/debian/rules

@@ -22,7 +22,7 @@ MODULE_DIRS:= d7032q28b d7054q28b d6254qs d6556 d6356 d7264q28b
 override_dh_auto_build:
 	(for mod in $(MODULE_DIRS); do \
 		make -C $(KERNEL_SRC)/build M=$(MOD_SRC_DIR)/$${mod}/modules; \
-		if [ $$mod = "d6356" ]; then \
+    if [ $$mod = "d7054q28b" ] || [ $$mod = "d6356" ]; then \
 			cd $(MOD_SRC_DIR)/$${mod}; \
 			python2 setup.py build; \
 			python2 setup.py bdist_wheel -d $(MOD_SRC_DIR)/$${mod}/utils; \
@@ -36,7 +36,7 @@ override_dh_auto_install:
 			$(KERNEL_SRC)/$(INSTALL_MOD_DIR); \
 		cp $(MOD_SRC_DIR)/$${mod}/modules/*.ko \
 			debian/platform-modules-$${mod}/$(KERNEL_SRC)/$(INSTALL_MOD_DIR); \
-		if [ $$mod = "d6356" ]; then \
+    if [ $$mod = "d7054q28b" ] || [ $$mod = "d6356" ]; then \
 			cd $(MOD_SRC_DIR)/$${mod}; \
 			python2 setup.py install --root=$(MOD_SRC_DIR)/debian/platform-modules-$${mod} --install-layout=deb; \
 			cd $(MOD_SRC_DIR); \