[Platform] Accton add to support as4630-54te platform. (#6683)

Add support for Accton as4630-54te platform

device/accton/x86_64-accton_as4630_54te-r0/Accton-AS4630-54TE/port_config.ini

@@ -0,0 +1,55 @@
+# name          lanes                 alias             index   speed           autoneg
+Ethernet0       26                    thousandE1        1         1000           1
+Ethernet1       25                    thousandE2        2         1000           1
+Ethernet2       28                    thousandE3        3         1000           1
+Ethernet3       27                    thousandE4        4         1000           1
+Ethernet4       30                    thousandE5        5         1000           1
+Ethernet5       29                    thousandE6        6         1000           1
+Ethernet6       32                    thousandE7        7         1000           1
+Ethernet7       31                    thousandE8        8         1000           1
+Ethernet8       38                    thousandE9        9         1000           1
+Ethernet9       37                    thousandE10       10        1000           1
+Ethernet10      40                    thousandE11       11        1000           1
+Ethernet11      39                    thousandE12       12        1000           1
+Ethernet12      34                    thousandE13       13        1000           1
+Ethernet13      33                    thousandE14       14        1000           1
+Ethernet14      36                    thousandE15       15        1000           1
+Ethernet15      35                    thousandE16       16        1000           1
+Ethernet16      46                    thousandE17       17        1000           1
+Ethernet17      45                    thousandE18       18        1000           1
+Ethernet18      48                    thousandE19       19        1000           1
+Ethernet19      47                    thousandE20       20        1000           1
+Ethernet20      42                    thousandE21       21        1000           1
+Ethernet21      41                    thousandE22       22        1000           1
+Ethernet22      44                    thousandE23       23        1000           1
+Ethernet23      43                    thousandE24       24        1000           1
+Ethernet24      2                     thousandE25       25        1000           1
+Ethernet25      1                     thousandE26       26        1000           1
+Ethernet26      4                     thousandE27       27        1000           1
+Ethernet27      3                     thousandE28       28        1000           1
+Ethernet28      6                     thousandE29       29        1000           1
+Ethernet29      5                     thousandE30       30        1000           1
+Ethernet30      8                     thousandE31       31        1000           1
+Ethernet31      7                     thousandE32       32        1000           1
+Ethernet32      10                    thousandE33       33        1000           1
+Ethernet33      9                     thousandE34       34        1000           1
+Ethernet34      12                    thousandE35       35        1000           1
+Ethernet35      11                    thousandE36       36        1000           1
+Ethernet36      14                    thousandE37       37        1000           1
+Ethernet37      13                    thousandE38       38        1000           1
+Ethernet38      16                    thousandE39       39        1000           1
+Ethernet39      15                    thousandE40       40        1000           1
+Ethernet40      18                    thousandE41       41        1000           1
+Ethernet41      17                    thousandE42       42        1000           1
+Ethernet42      20                    thousandE43       43        1000           1
+Ethernet43      19                    thousandE44       44        1000           1
+Ethernet44      22                    thousandE45       45        1000           1
+Ethernet45      21                    thousandE46       46        1000           1
+Ethernet46      24                    thousandE47       47        1000           1
+Ethernet47      23                    thousandE48       48        1000           1
+Ethernet48      67                    twentyfiveGigE49  49       25000           0
+Ethernet49      66                    twentyfiveGigE50  50       25000           0
+Ethernet50      65                    twentyfiveGigE51  51       25000           0
+Ethernet51      68                    twentyfiveGigE52  52       25000           0
+Ethernet52      73,74,75,76           hundredGigE53     53      100000           0
+Ethernet56      69,70,71,72           hundredGigE54     54      100000           0

device/accton/x86_64-accton_as4630_54te-r0/default_sku

@@ -0,0 +1 @@
+Accton-AS4630-54TE t1

device/accton/x86_64-accton_as4630_54te-r0/installer.conf

@@ -0,0 +1,3 @@
+CONSOLE_PORT=0x3f8
+CONSOLE_DEV=0
+CONSOLE_SPEED=115200

device/accton/x86_64-accton_as4630_54te-r0/plugins/eeprom.py

@@ -0,0 +1,13 @@
+try:
+    from sonic_eeprom import eeprom_tlvinfo
+
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+
+class board(eeprom_tlvinfo.TlvInfoDecoder):
+    _TLV_INFO_MAX_LEN = 256
+
+    def __init__(self, name, path, cpld_root, ro):
+        self.eeprom_path = "/sys/bus/i2c/devices/1-0057/eeprom"
+        super(board, self).__init__(self.eeprom_path, 0, '', True)

device/accton/x86_64-accton_as4630_54te-r0/plugins/psuutil.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+#############################################################################
+# Accton
+#
+# Module contains an implementation of SONiC PSU Base API and
+# provides the PSUs status which are available in the platform
+#
+#############################################################################
+
+
+try:
+    from sonic_psu.psu_base import PsuBase
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+
+class PsuUtil(PsuBase):
+    """Platform-specific PSUutil class"""
+
+    def __init__(self):
+        PsuBase.__init__(self)
+
+        self.psu_path = "/sys/bus/i2c/devices/"
+        self.psu_presence = "/psu_present"
+        self.psu_oper_status = "/psu_power_good"
+        self.psu_mapping = {
+            1: "10-0050",
+            2: "11-0051",
+        }
+
+    def get_num_psus(self):
+        return len(self.psu_mapping)
+
+    def get_psu_status(self, index):
+        if index is None:
+            return False
+
+        status = 0
+        node = self.psu_path + self.psu_mapping[index] + self.psu_oper_status
+        try:
+            with open(node, 'r') as power_status:
+                status = int(power_status.read())
+        except IOError:
+            return False
+
+        return status == 1
+
+    def get_psu_presence(self, index):
+        if index is None:
+            return False
+
+        status = 0
+        node = self.psu_path + self.psu_mapping[index] + self.psu_presence
+        try:
+            with open(node, 'r') as presence_status:
+                status = int(presence_status.read())
+        except IOError:
+            return False
+
+        return status == 1

device/accton/x86_64-accton_as4630_54te-r0/plugins/sfputil.py

@@ -0,0 +1,196 @@
+# sfputil.py
+#
+# Platform-specific SFP transceiver interface for SONiC
+#
+
+try:
+    import sys
+    import time
+    from ctypes import create_string_buffer
+    from sonic_sfp.sfputilbase import SfpUtilBase
+except ImportError as e:
+    raise ImportError("%s - required module not found" % str(e))
+
+SFP_STATUS_INSERTED = '1'
+SFP_STATUS_REMOVED = '0'
+
+
+class SfpUtil(SfpUtilBase):
+    """Platform-specific SfpUtil class"""
+
+    PORT_START = 49
+    PORT_END = 54
+    PORTS_IN_BLOCK = 54
+    QSFP_START = 53
+
+    BASE_OOM_PATH = "/sys/bus/i2c/devices/{0}-0050/"
+    BASE_CPLD_PATH = "/sys/bus/i2c/devices/3-0060/"
+
+    _port_to_is_present = {}
+    _port_to_lp_mode = {}
+
+    _port_to_eeprom_mapping = {}
+    _port_to_i2c_mapping = {
+        49: [18],
+        50: [19],
+        51: [20],
+        52: [21],
+        53: [22],
+        54: [23],
+    }
+
+    @property
+    def port_start(self):
+        return self.PORT_START
+
+    @property
+    def port_end(self):
+        return self.PORT_END
+
+    @property
+    def qsfp_ports(self):
+        return range(self.PORT_START, self.PORTS_IN_BLOCK + 1)
+
+    @property
+    def port_to_eeprom_mapping(self):
+        return self._port_to_eeprom_mapping
+
+    def __init__(self):
+        eeprom_path = self.BASE_OOM_PATH + "eeprom"
+        for x in range(self.port_start, self.port_end + 1):
+            self.port_to_eeprom_mapping[x] = eeprom_path.format(
+                self._port_to_i2c_mapping[x][0])
+        SfpUtilBase.__init__(self)
+
+    def get_presence(self, port_num):
+        # Check for invalid port_num
+        if port_num < self.port_start or port_num > self.port_end:
+            return False
+
+        present_path = self.BASE_CPLD_PATH + "module_present_" + str(port_num)
+        self.__port_to_is_present = present_path
+
+        try:
+            val_file = open(self.__port_to_is_present)
+            content = val_file.readline().rstrip()
+            val_file.close()
+        except IOError as e:
+            print ('Error: unable to access file: %s') % str(e)
+            return False
+
+        if content == "1":
+            return True
+
+        return False
+
+    def get_low_power_mode(self, port_num):
+        # Check for invalid port_num
+        if port_num < self.QSFP_START or port_num > self.port_end:
+            return False
+
+        try:
+            eeprom = None
+            if not self.get_presence(port_num):
+                return False
+            eeprom = open(self.port_to_eeprom_mapping[port_num], "rb")
+            eeprom.seek(93)
+            lpmode = ord(eeprom.read(1))
+
+            # if "Power override" bit is 1 and "Power set" bit is 1
+            if ((lpmode & 0x3) == 0x3):
+                return True
+
+            # High Power Mode if one of the following conditions is matched:
+            # 1. "Power override" bit is 0
+            # 2. "Power override" bit is 1 and "Power set" bit is 0
+            else:
+                return False
+
+        except IOError as e:
+            print ('Error: unable to open file: %s') % str(e)
+            return False
+        finally:
+            if eeprom is not None:
+                eeprom.close()
+                time.sleep(0.01)
+
+    def set_low_power_mode(self, port_num, lpmode):
+        # Check for invalid port_num
+        if port_num < self.QSFP_START or port_num > self.port_end:
+            return False
+
+        try:
+            eeprom = None
+            if not self.get_presence(port_num):
+                return False  # Port is not present, unable to set the eeprom
+
+            # Fill in write buffer
+            # 0x3:Low Power Mode, 0x1:High Power Mode
+            regval = 0x3 if lpmode else 0x1
+
+            buffer = create_string_buffer(1)
+            if sys.version_info[0] >= 3:
+                buffer[0] = regval
+            else:
+                buffer[0] = chr(regval)
+
+            # Write to eeprom
+            eeprom = open(self.port_to_eeprom_mapping[port_num], "r+b")
+            eeprom.seek(93)
+            eeprom.write(buffer[0])
+            return True
+        except IOError as e:
+            print ('Error: unable to open file: %s') % str(e)
+            return False
+        finally:
+            if eeprom is not None:
+                eeprom.close()
+                time.sleep(0.01)
+
+    def reset(self, port_num):
+        raise NotImplementedError
+
+    @property
+    def _get_presence_bitmap(self):
+
+        bits = []
+        for x in range(self.port_start, self.port_end + 1):
+            bits.append(str(int(self.get_presence(x))))
+
+        rev = "".join(bits[::-1])
+        return int(rev, 2)
+
+    data = {'present': 0}
+
+    def get_transceiver_change_event(self, timeout=0):
+        port_dict = {}
+
+        if timeout == 0:
+            cd_ms = sys.maxsize
+        else:
+            cd_ms = timeout
+
+        # poll per second
+        while cd_ms > 0:
+            reg_value = self._get_presence_bitmap
+            changed_ports = self.data['present'] ^ reg_value
+            if changed_ports != 0:
+                break
+            time.sleep(1)
+            cd_ms = cd_ms - 1000
+
+        if changed_ports != 0:
+            for port in range(self.port_start, self.port_end + 1):
+                # Mask off the bit corresponding to our port
+                mask = (1 << (port - self.port_start))
+                if changed_ports & mask:
+                    if (reg_value & mask) == 0:
+                        port_dict[port] = SFP_STATUS_REMOVED
+                    else:
+                        port_dict[port] = SFP_STATUS_INSERTED
+
+            # Update cache
+            self.data['present'] = reg_value
+            return True, port_dict
+        else:
+            return True, {}

device/accton/x86_64-accton_as4630_54te-r0/pmon_daemon_control.json

@@ -0,0 +1,5 @@
+{
+    "skip_ledd": true,
+    "skip_thermalctld": true
+}
+

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ['chassis', 'eeprom', 'platform', 'psu', 'sfp', 'thermal', 'fan']
+from . import platform 

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/chassis.py

@@ -0,0 +1,194 @@
+#############################################################################
+# Edgecore
+#
+# Module contains an implementation of SONiC Platform Base API and
+# provides the Chassis information which are available in the platform
+#
+#############################################################################
+
+import os
+
+try:
+    from sonic_platform_base.chassis_base import ChassisBase
+    from .helper import APIHelper
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+NUM_FAN_TRAY = 3
+NUM_FAN = 2
+NUM_PSU = 2
+NUM_THERMAL = 3
+NUM_QSFP = 6
+PORT_START = 49
+PORT_END = 54
+NUM_COMPONENT = 2
+HOST_REBOOT_CAUSE_PATH = "/host/reboot-cause/"
+PMON_REBOOT_CAUSE_PATH = "/usr/share/sonic/platform/api_files/reboot-cause/"
+REBOOT_CAUSE_FILE = "reboot-cause.txt"
+PREV_REBOOT_CAUSE_FILE = "previous-reboot-cause.txt"
+HOST_CHK_CMD = "docker > /dev/null 2>&1"
+
+
+class Chassis(ChassisBase):
+    """Platform-specific Chassis class"""
+
+    def __init__(self):
+        ChassisBase.__init__(self)
+        self._api_helper = APIHelper()
+        self._api_helper = APIHelper()
+        self.is_host = self._api_helper.is_host()
+
+        self.config_data = {}
+
+        self.__initialize_fan()
+        self.__initialize_psu()
+        self.__initialize_thermals()
+        self.__initialize_components()
+        self.__initialize_sfp()
+        self.__initialize_eeprom()
+
+    def __initialize_sfp(self):
+        from sonic_platform.sfp import Sfp
+        for index in range(0, PORT_END):
+            sfp = Sfp(index)
+            self._sfp_list.append(sfp)
+        self.sfp_module_initialized = True
+
+    def __initialize_fan(self):
+        from sonic_platform.fan import Fan
+        for fant_index in range(0, NUM_FAN_TRAY):
+            for fan_index in range(0, NUM_FAN):
+                fan = Fan(fant_index, fan_index)
+                self._fan_list.append(fan)
+
+    def __initialize_psu(self):
+        from sonic_platform.psu import Psu
+        for index in range(0, NUM_PSU):
+            psu = Psu(index)
+            self._psu_list.append(psu)
+
+    def __initialize_thermals(self):
+        from sonic_platform.thermal import Thermal
+        for index in range(0, NUM_THERMAL):
+            thermal = Thermal(index)
+            self._thermal_list.append(thermal)
+
+    def __initialize_eeprom(self):
+        from sonic_platform.eeprom import Tlv
+        self._eeprom = Tlv()
+
+    def __initialize_components(self):
+        from sonic_platform.component import Component
+        for index in range(0, NUM_COMPONENT):
+            component = Component(index)
+            self._component_list.append(component)
+
+    def __initialize_watchdog(self):
+        from sonic_platform.watchdog import Watchdog
+        self._watchdog = Watchdog()
+
+
+    def __is_host(self):
+        return os.system(HOST_CHK_CMD) == 0
+
+    def __read_txt_file(self, file_path):
+        try:
+            with open(file_path, 'r') as fd:
+                data = fd.read()
+                return data.strip()
+        except IOError:
+            pass
+        return None
+
+    def get_name(self):
+        """
+        Retrieves the name of the device
+            Returns:
+            string: The name of the device
+        """
+
+        return self._api_helper.hwsku
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the Chassis
+        Returns:
+            bool: True if Chassis is present, False if not
+        """
+        return True
+
+    def get_status(self):
+        """
+        Retrieves the operational status of the device
+        Returns:
+            A boolean value, True if device is operating properly, False if not
+        """
+        return True
+
+    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.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_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.
+        """
+
+        reboot_cause_path = (HOST_REBOOT_CAUSE_PATH + REBOOT_CAUSE_FILE)
+        sw_reboot_cause = self._api_helper.read_txt_file(
+            reboot_cause_path) or "Unknown"
+
+
+        return ('REBOOT_CAUSE_NON_HARDWARE', sw_reboot_cause)
+
+    def get_sfp(self, index):
+        """
+        Retrieves sfp represented by (1-based) index <index>
+        Args:
+            index: An integer, the index (1-based) of the sfp to retrieve.
+            The index should be the sequence of a physical port in a chassis,
+            starting from 1.
+            For example, 1 for Ethernet0, 2 for Ethernet4 and so on.
+        Returns:
+            An object dervied from SfpBase representing the specified sfp
+        """
+        sfp = None
+        if not self.sfp_module_initialized:
+            self.__initialize_sfp()
+
+        try:
+            # The index will start from 1
+            sfp = self._sfp_list[index-1]
+        except IndexError:
+            sys.stderr.write("SFP index {} out of range (1-{})\n".format(
+                             index, len(self._sfp_list)))
+        return sfp

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/component.py

@@ -0,0 +1,121 @@
+#############################################################################
+# Accton
+#
+# Component contains an implementation of SONiC Platform Base API and
+# provides the components firmware management function
+#
+#############################################################################
+
+import shlex
+import subprocess
+
+
+try:
+    from sonic_platform_base.component_base import ComponentBase
+    from .helper import APIHelper
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+CPLD_ADDR_MAPPING = {
+    "CPLD1": "3-0060"
+}
+SYSFS_PATH = "/sys/bus/i2c/devices/"
+BIOS_VERSION_PATH = "/sys/class/dmi/id/bios_version"
+COMPONENT_LIST= [
+   ("CPLD1", "CPLD 1"),
+   ("BIOS", "Basic Input/Output System")
+
+]
+
+class Component(ComponentBase):
+    """Platform-specific Component class"""
+
+    DEVICE_TYPE = "component"
+
+    def __init__(self, component_index=0):
+        self._api_helper=APIHelper()
+        ComponentBase.__init__(self)
+        self.index = component_index
+        self.name = self.get_name()        
+
+    def __run_command(self, command):
+        # Run bash command and print output to stdout
+        try:
+            process = subprocess.Popen(
+                shlex.split(command), stdout=subprocess.PIPE)
+            while True:
+                output = process.stdout.readline()
+                if output == '' and process.poll() is not None:
+                    break
+            rc = process.poll()
+            if rc != 0:
+                return False
+        except Exception:
+            return False
+        return True
+
+    def __get_bios_version(self):
+        # Retrieves the BIOS firmware version
+        try:
+            with open(BIOS_VERSION_PATH, 'r') as fd:
+                bios_version = fd.read()
+                return bios_version.strip()
+        except Exception as e:
+            return None
+
+    def __get_cpld_version(self):
+        # Retrieves the CPLD firmware version
+        cpld_version = dict()
+        for cpld_name in CPLD_ADDR_MAPPING:
+            try:
+                cpld_path = "{}{}{}".format(SYSFS_PATH, CPLD_ADDR_MAPPING[cpld_name], '/version')
+                cpld_version_raw= self._api_helper.read_txt_file(cpld_path)               
+                cpld_version[cpld_name] = "{}".format(int(cpld_version_raw,16))
+            except Exception as e:
+                print('Get exception when read cpld')
+                cpld_version[cpld_name] = 'None'
+
+        return cpld_version
+
+    def get_name(self):
+        """
+        Retrieves the name of the component
+         Returns:
+            A string containing the name of the component
+        """
+        return COMPONENT_LIST[self.index][0]
+
+    def get_description(self):
+        """
+        Retrieves the description of the component
+            Returns:
+            A string containing the description of the component
+        """
+        return COMPONENT_LIST[self.index][1]
+
+
+    def get_firmware_version(self):
+        """
+        Retrieves the firmware version of module
+        Returns:
+            string: The firmware versions of the module
+        """
+        fw_version = None
+
+        if self.name == "BIOS":
+            fw_version = self.__get_bios_version()
+        elif "CPLD" in self.name:
+            cpld_version = self.__get_cpld_version()           
+            fw_version = cpld_version.get(self.name)
+
+        return fw_version
+
+    def install_firmware(self, image_path):
+        """
+        Install firmware to module
+        Args:
+            image_path: A string, path to firmware image
+        Returns:
+            A boolean, True if install successfully, False if not
+        """
+        raise NotImplementedError

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/eeprom.py

@@ -0,0 +1,102 @@
+try:
+    import os
+    import sys
+    import re
+    if sys.version_info[0] >= 3:
+        from io import StringIO
+    else:
+        from cStringIO import StringIO
+
+    from sonic_platform_base.sonic_eeprom import eeprom_tlvinfo
+except ImportError as 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/bus/i2c/devices/1-0057/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 Exception:
+                pass
+
+        return _eeprom_info_dict
+
+    def _load_eeprom(self):
+        original_stdout = sys.stdout
+        sys.stdout = StringIO()
+        try:
+            self.read_eeprom_db()
+        except Exception:
+            decode_output = sys.stdout.getvalue()
+            sys.stdout = original_stdout
+            return self.__parse_output(decode_output)
+
+        status = self.check_status()
+        if 'ok' not in status:
+            return False
+
+        if not os.path.exists(CACHE_ROOT):
+            try:
+                os.makedirs(CACHE_ROOT)
+            except Exception:
+                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 Exception:
+            pass
+
+        e = self.read_eeprom()
+        if e is None:
+            return 0
+
+        try:
+            self.update_cache(e)
+        except Exception:
+            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.")

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/fan.py

@@ -0,0 +1,171 @@
+#############################################################################
+# Edgecore
+#
+# Module contains an implementation of SONiC Platform Base API and
+# provides the fan status which are available in the platform
+#
+#############################################################################
+
+try:
+    from sonic_platform_base.fan_base import FanBase
+    from .helper import APIHelper
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+PSU_FAN_MAX_RPM = 26688
+
+CPLD_I2C_PATH = "/sys/bus/i2c/devices/3-0060/fan_"
+PSU_HWMON_I2C_PATH ="/sys/bus/i2c/devices/{}-00{}/"
+PSU_I2C_MAPPING = {
+    0: {
+        "num": 10,
+        "addr": "58"
+    },
+    1: {
+        "num": 11,
+        "addr": "59"
+    },
+}
+
+
+class Fan(FanBase):
+    """Platform-specific Fan class"""
+
+    def __init__(self, fan_tray_index, fan_index=0, is_psu_fan=False, psu_index=0):
+        self._api_helper=APIHelper()
+        self.fan_index = fan_index
+        self.fan_tray_index = fan_tray_index
+        self.is_psu_fan = is_psu_fan
+
+        if self.is_psu_fan:
+            self.psu_index = psu_index
+            self.psu_i2c_num = PSU_I2C_MAPPING[self.psu_index]['num']
+            self.psu_i2c_addr = PSU_I2C_MAPPING[self.psu_index]['addr']
+            self.psu_hwmon_path = PSU_HWMON_I2C_PATH.format(
+                self.psu_i2c_num, self.psu_i2c_addr)
+
+        FanBase.__init__(self)  
+
+
+    def get_direction(self):
+        """
+        Retrieves the direction of fan
+        Returns:
+            A string, either FAN_DIRECTION_INTAKE or FAN_DIRECTION_EXHAUST
+            depending on fan direction
+        """
+
+
+        if not self.is_psu_fan:
+            dir_str = "{}{}{}".format(CPLD_I2C_PATH, 'direction_', self.fan_tray_index)
+            val=self._api_helper.read_txt_file(dir_str)
+            if val is not None:
+                if val==0:#F2B
+                    direction=self.FAN_DIRECTION_EXHAUST
+                else:
+                    direction=self.FAN_DIRECTION_INTAKE
+            else:
+                direction=self.FAN_DIRECTION_EXHAUST
+
+        else: #For PSU
+            dir_str = "{}{}".format(self.psu_hwmon_path,'psu_fan_dir')
+            val=self._api_helper.read_txt_file(dir_str)
+            if val is not None:
+                if val=='F2B':
+                    direction=self.FAN_DIRECTION_EXHAUST
+                else:
+                    direction=self.FAN_DIRECTION_INTAKE
+            else:
+                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
+        if self.is_psu_fan:
+            psu_fan_path= "{}{}".format(self.psu_hwmon_path, 'psu_fan1_speed_rpm')
+            fan_speed_rpm = self._api_helper.read_txt_file(psu_fan_path)
+            if fan_speed_rpm is not None:
+                speed = (int(fan_speed_rpm,10))*100/26688
+                if speed > 100:
+                    speed=100
+            else:
+                return 0
+        elif self.get_presence():            
+            speed_path = "{}{}".format(CPLD_I2C_PATH, 'duty_cycle_percentage')
+            speed=self._api_helper.read_txt_file(speed_path)
+            if speed is None:
+                return 0
+        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)
+        Note:
+            speed_pc = pwm_target/255*100
+            0   : when PWM mode is use
+            pwm : when pwm mode is not use
+        """
+        return False #Not supported
+
+    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 False #Not supported
+
+    def set_speed(self, speed):
+        """
+        Sets the fan speed
+        Args:
+            speed: An integer, the percentage of full fan speed to set fan to,
+                   in the range 0 (off) to 100 (full speed)
+        Returns:
+            A boolean, True if speed is set successfully, False if not
+        """
+
+        if not self.is_psu_fan and self.get_presence():            
+            speed_path = "{}{}".format(CPLD_I2C_PATH, 'duty_cycle_percentage')
+            return self._api_helper.write_txt_file(speed_path, int(speed))
+
+        return False
+
+    def set_status_led(self, color):
+        """
+        Sets the state of the fan module status LED
+        Args:
+            color: A string representing the color with which to set the
+                   fan module status LED
+        Returns:
+            bool: True if status LED state is set successfully, False if not
+        """
+        return False #Not supported
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the FAN
+        Returns:
+            bool: True if FAN is present, False if not
+        """
+        present_path = "{}{}{}".format(CPLD_I2C_PATH, 'present_', self.fan_index+1)
+        val=self._api_helper.read_txt_file(present_path)
+        if not self.is_psu_fan:
+            if val is not None:
+                return int(val, 10)==1
+            else:
+                return False
+        else:
+            return True

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/helper.py

@@ -0,0 +1,117 @@
+import os
+import struct
+import subprocess
+from mmap import *
+from sonic_py_common import device_info
+
+HOST_CHK_CMD = "docker > /dev/null 2>&1"
+EMPTY_STRING = ""
+
+
+class APIHelper():
+
+    def __init__(self):
+        (self.platform, self.hwsku) = device_info.get_platform_and_hwsku()
+
+    def is_host(self):
+        return os.system(HOST_CHK_CMD) == 0
+
+    def pci_get_value(self, resource, offset):
+        status = True
+        result = ""
+        try:
+            fd = os.open(resource, os.O_RDWR)
+            mm = mmap(fd, 0)
+            mm.seek(int(offset))
+            read_data_stream = mm.read(4)
+            result = struct.unpack('I', read_data_stream)
+        except Exception:
+            status = False
+        return status, result
+
+    def run_command(self, cmd):
+        status = True
+        result = ""
+        try:
+            p = subprocess.Popen(
+                cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            raw_data, err = p.communicate()
+            if err == '':
+                result = raw_data.strip()
+        except Exception:
+            status = False
+        return status, result
+
+    def run_interactive_command(self, cmd):
+        try:
+            os.system(cmd)
+        except Exception:
+            return False
+        return True
+
+    def read_txt_file(self, file_path):
+        try:
+            with open(file_path, 'r') as fd:
+                data = fd.read()
+                return data.strip()
+        except IOError:
+            pass
+        return None
+
+    def write_txt_file(self, file_path, value):
+        try:
+            with open(file_path, 'w') as fd:
+                fd.write(str(value))
+        except IOError:
+            return False
+        return True
+
+    def ipmi_raw(self, netfn, cmd):
+        status = True
+        result = ""
+        try:
+            cmd = "ipmitool raw {} {}".format(str(netfn), str(cmd))
+            p = subprocess.Popen(
+                cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            raw_data, err = p.communicate()
+            if err == '':
+                result = raw_data.strip()
+            else:
+                status = False
+        except Exception:
+            status = False
+        return status, result
+
+    def ipmi_fru_id(self, id, key=None):
+        status = True
+        result = ""
+        try:
+            cmd = "ipmitool fru print {}".format(str(
+                id)) if not key else "ipmitool fru print {0} | grep '{1}' ".format(str(id), str(key))
+
+            p = subprocess.Popen(
+                cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            raw_data, err = p.communicate()
+            if err == '':
+                result = raw_data.strip()
+            else:
+                status = False
+        except Exception:
+            status = False
+        return status, result
+
+    def ipmi_set_ss_thres(self, id, threshold_key, value):
+        status = True
+        result = ""
+        try:
+            cmd = "ipmitool sensor thresh '{}' {} {}".format(str(id), str(threshold_key), str(value))
+            p = subprocess.Popen(
+                cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            raw_data, err = p.communicate()
+            if err == '':
+                result = raw_data.strip()
+            else:
+                status = False
+        except Exception:
+            status = False
+        return status, result

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/platform.py

@@ -0,0 +1,21 @@
+#############################################################################
+# Edgecore
+#
+# Module contains an implementation of SONiC Platform Base API and
+# provides the platform information
+#
+#############################################################################
+
+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):
+    """Platform-specific Platform class"""
+
+    def __init__(self):
+        PlatformBase.__init__(self)
+        self._chassis = Chassis()

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/psu.py

@@ -0,0 +1,228 @@
+#############################################################################
+# Edgecore
+#
+# Module contains an implementation of SONiC Platform Base API and
+# provides the PSUs status which are available in the platform
+#
+#############################################################################
+
+#import sonic_platform
+
+try:
+    from sonic_platform_base.psu_base import PsuBase
+    #from sonic_platform.fan import Fan
+    from .helper import APIHelper
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+
+I2C_PATH ="/sys/bus/i2c/devices/{0}-00{1}/"
+
+PSU_NAME_LIST = ["PSU-1", "PSU-2"]
+PSU_NUM_FAN = [1, 1]
+PSU_HWMON_I2C_MAPPING = {
+    0: {
+        "num": 10,
+        "addr": "58"
+    },
+    1: {
+        "num": 11,
+        "addr": "59"
+    },
+}
+
+PSU_CPLD_I2C_MAPPING = {
+    0: {
+        "num": 10,
+        "addr": "50"
+    },
+    1: {
+        "num": 11,
+        "addr": "51"
+    },
+}
+
+class Psu(PsuBase):
+    """Platform-specific Psu class"""
+
+    def __init__(self, psu_index=0):
+        PsuBase.__init__(self)
+        self.index = psu_index
+        self._api_helper = APIHelper()
+
+        self.i2c_num = PSU_HWMON_I2C_MAPPING[self.index]["num"]
+        self.i2c_addr = PSU_HWMON_I2C_MAPPING[self.index]["addr"]
+        self.hwmon_path = I2C_PATH.format(self.i2c_num, self.i2c_addr)
+
+        self.i2c_num = PSU_CPLD_I2C_MAPPING[self.index]["num"]
+        self.i2c_addr = PSU_CPLD_I2C_MAPPING[self.index]["addr"]
+        self.cpld_path = I2C_PATH.format(self.i2c_num, self.i2c_addr)
+        self.__initialize_fan()
+        '''
+        for fan_index in range(0, PSU_NUM_FAN[self.index]):
+            #def __init__(self, fan_tray_index, fan_index=0, is_psu_fan=False, psu_index=0):
+            #fan = Fan(fan_index, 0, is_psu_fan=True, psu_index=self.index)
+            fan = Fan(fan_index, 0, True, self.index)
+            self._fan_list.append(fan)
+        '''
+
+    def __initialize_fan(self):
+        from sonic_platform.fan import Fan
+        for fan_index in range(0, PSU_NUM_FAN[self.index]):
+            fan = Fan(fan_index, 0, is_psu_fan=True, psu_index=self.index)
+            self._fan_list.append(fan)
+
+    def get_voltage(self):
+        """
+        Retrieves current PSU voltage output
+        Returns:
+            A float number, the output voltage in volts,
+            e.g. 12.1
+        """
+        vout_path = "{}{}".format(self.hwmon_path, 'psu_v_out')        
+        vout_val=self._api_helper.read_txt_file(vout_path)
+        if vout_val is not None:
+            return float(vout_val)/ 1000
+        else:
+            return 0
+
+    def get_current(self):
+        """
+        Retrieves present electric current supplied by PSU
+        Returns:
+            A float number, the electric current in amperes, e.g 15.4
+        """
+        iout_path = "{}{}".format(self.hwmon_path, 'psu_i_out')        
+        val=self._api_helper.read_txt_file(iout_path)
+        if val is not None:
+            return float(val)/1000
+        else:
+            return 0
+
+    def get_power(self):
+        """
+        Retrieves current energy supplied by PSU
+        Returns:
+            A float number, the power in watts, e.g. 302.6
+        """
+        pout_path = "{}{}".format(self.hwmon_path, 'psu_p_out')        
+        val=self._api_helper.read_txt_file(pout_path)
+        if val is not None:
+            return float(val)/1000
+        else:
+            return 0
+
+    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 set_status_led(self, color):
+        """
+        Sets the state of the PSU status LED
+        Args:
+            color: A string representing the color with which to set the PSU status LED
+                   Note: Only support green and off
+        Returns:
+            bool: True if status LED state is set successfully, False if not
+        """
+
+        return False  #Controlled by HW
+
+    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
+        """
+
+        return False  #Controlled by HW
+
+    def get_temperature(self):
+        """
+        Retrieves current temperature reading from PSU
+        Returns:
+            A float number of current temperature in Celsius up to nearest thousandth
+            of one degree Celsius, e.g. 30.125 
+        """
+        temp_path = "{}{}".format(self.hwmon_path, 'psu_temp1_input')        
+        val=self._api_helper.read_txt_file(temp_path)
+        if val is not None:
+            return float(val)/1000
+        else:
+            return 0
+
+    def get_temperature_high_threshold(self):
+        """
+        Retrieves the high threshold temperature of PSU
+        Returns:
+            A float number, the high threshold temperature of PSU in Celsius
+            up to nearest thousandth of one degree Celsius, e.g. 30.125
+        """
+        return False #Not supported
+
+    def get_voltage_high_threshold(self):
+        """
+        Retrieves the high threshold PSU voltage output
+        Returns:
+            A float number, the high threshold output voltage in volts, 
+            e.g. 12.1 
+        """
+        vout_path = "{}{}".format(self.hwmon_path, 'psu_mfr_vout_max')        
+        vout_val=self._api_helper.read_txt_file(vout_path)
+        if vout_val is not None:
+            return float(vout_val)/ 1000
+        else:
+            return 0
+
+    def get_voltage_low_threshold(self):
+        """
+        Retrieves the low threshold PSU voltage output
+        Returns:
+            A float number, the low threshold output voltage in volts, 
+            e.g. 12.1 
+        """
+        vout_path = "{}{}".format(self.hwmon_path, 'psu_mfr_vout_min')        
+        vout_val=self._api_helper.read_txt_file(vout_path)
+        if vout_val is not None:
+            return float(vout_val)/ 1000
+        else:
+            return 0
+
+    def get_name(self):
+        """
+        Retrieves the name of the device
+            Returns:
+            string: The name of the device
+        """
+        return PSU_NAME_LIST[self.index]
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the PSU
+        Returns:
+            bool: True if PSU is present, False if not
+        """        
+        presence_path="{}{}".format(self.cpld_path, 'psu_present')
+        val=self._api_helper.read_txt_file(presence_path)
+        if val is not None:
+            return int(val, 10) == 1
+        else:
+            return 0
+
+    def get_status(self):
+        """
+        Retrieves the operational status of the device
+        Returns:
+            A boolean value, True if device is operating properly, False if not
+        """
+        power_path="{}{}".format(self.cpld_path, 'psu_power_good')
+        val=self._api_helper.read_txt_file(power_path)
+        if val is not None:
+            return int(val, 10) == 1
+        else:
+            return 0

device/accton/x86_64-accton_as4630_54te-r0/sonic_platform/thermal.py

@@ -0,0 +1,145 @@
+#############################################################################
+# Edgecore
+#
+# Thermal contains an implementation of SONiC Platform Base API and
+# provides the thermal device status which are available in the platform
+#
+#############################################################################
+
+import os
+import os.path
+import glob
+
+try:
+    from sonic_platform_base.thermal_base import ThermalBase
+except ImportError as e:
+    raise ImportError(str(e) + "- required module not found")
+
+
+class Thermal(ThermalBase):
+    """Platform-specific Thermal class"""
+
+    THERMAL_NAME_LIST = []
+    SYSFS_PATH = "/sys/bus/i2c/devices"
+
+    def __init__(self, thermal_index=0):
+        self.THERMAL_NAME_LIST = []
+        self.SYSFS_PATH = "/sys/bus/i2c/devices"
+        self.index = thermal_index
+        # Add thermal name
+        self.THERMAL_NAME_LIST.append("Temp sensor 1")
+        self.THERMAL_NAME_LIST.append("Temp sensor 2")
+        self.THERMAL_NAME_LIST.append("Temp sensor 3")        
+
+        # Set hwmon path
+        i2c_path = {
+            0: "14-0048/hwmon/hwmon*/", 
+            1: "24-004b/hwmon/hwmon*/", 
+            2: "25-004a/hwmon/hwmon*/"
+        }.get(self.index, None)
+
+        self.hwmon_path = "{}/{}".format(self.SYSFS_PATH, i2c_path)
+        self.ss_key = self.THERMAL_NAME_LIST[self.index]
+        self.ss_index = 1
+
+    def __read_txt_file(self, file_path):
+        for filename in glob.glob(file_path):
+            try:
+                with open(filename, 'r') as fd:                    
+                    data =fd.readline().rstrip()
+                    return data
+            except IOError as e:
+                pass
+
+        return None
+
+    def __get_temp(self, temp_file):
+        temp_file_path = os.path.join(self.hwmon_path, temp_file)
+        raw_temp = self.__read_txt_file(temp_file_path)
+        if raw_temp is not None:
+            return float(raw_temp)/1000
+        else:
+            return 0        
+
+    def __set_threshold(self, file_name, temperature):
+        temp_file_path = os.path.join(self.hwmon_path, file_name)
+        for filename in glob.glob(temp_file_path):
+            try:
+                with open(filename, 'w') as fd:
+                    fd.write(str(temperature))
+                return True
+            except IOError as e:
+                print("IOError")
+
+
+    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
+        """
+        temp_file = "temp{}_input".format(self.ss_index)
+        return self.__get_temp(temp_file)
+
+    def get_high_threshold(self):
+        """
+        Retrieves the high threshold temperature of thermal
+        Returns:
+            A float number, the high threshold temperature of thermal in Celsius
+            up to nearest thousandth of one degree Celsius, e.g. 30.125
+        """
+        temp_file = "temp{}_max".format(self.ss_index)
+        return self.__get_temp(temp_file)
+
+    def set_high_threshold(self, temperature):
+        """
+        Sets the high threshold temperature of thermal
+        Args :
+            temperature: A float number up to nearest thousandth of one degree Celsius,
+            e.g. 30.125
+        Returns:
+            A boolean, True if threshold is set successfully, False if not
+        """
+        temp_file = "temp{}_max".format(self.ss_index)
+        temperature = temperature *1000
+        self.__set_threshold(temp_file, temperature)
+
+        return True
+
+    def get_name(self):
+        """
+        Retrieves the name of the thermal device
+            Returns:
+            string: The name of the thermal device
+        """
+        return self.THERMAL_NAME_LIST[self.index]
+
+    def get_presence(self):
+        """
+        Retrieves the presence of the Thermal
+        Returns:
+            bool: True if Thermal is present, False if not
+        """
+        temp_file = "temp{}_input".format(self.ss_index)
+        temp_file_path = os.path.join(self.hwmon_path, temp_file)
+        raw_txt = self.__read_txt_file(temp_file_path)
+        if raw_txt is not None:
+            return True
+        else:
+            return False
+
+    def get_status(self):
+        """
+        Retrieves the operational status of the device
+        Returns:
+            A boolean value, True if device is operating properly, False if not
+        """
+
+        file_str = "temp{}_input".format(self.ss_index)
+        file_path = os.path.join(self.hwmon_path, file_str)
+        raw_txt = self.__read_txt_file(file_path)
+        if raw_txt is None:
+            return False
+        else:     
+            return int(raw_txt) != 0

platform/broadcom/one-image.mk

@@ -29,6 +29,7 @@ $(SONIC_ONE_IMAGE)_LAZY_INSTALLS += $(DELL_S6000_PLATFORM_MODULE) \
                                $(ACCTON_AS6712_32X_PLATFORM_MODULE) \
                                $(ACCTON_AS7726_32X_PLATFORM_MODULE) \
                                $(ACCTON_AS4630_54PE_PLATFORM_MODULE) \
+                               $(ACCTON_AS4630_54TE_PLATFORM_MODULE) \
                                $(ACCTON_MINIPACK_PLATFORM_MODULE) \
                                $(ACCTON_AS5812_54X_PLATFORM_MODULE) \
                                $(ACCTON_AS5812_54T_PLATFORM_MODULE) \

platform/broadcom/platform-modules-accton.mk

@@ -10,6 +10,7 @@ ACCTON_AS7716_32XB_PLATFORM_MODULE_VERSION = 1.1
 ACCTON_AS6712_32X_PLATFORM_MODULE_VERSION = 1.1
 ACCTON_AS7726_32X_PLATFORM_MODULE_VERSION = 1.1
 ACCTON_AS4630_54PE_PLATFORM_MODULE_VERSION = 1.1
+ACCTON_AS4630_54TE_PLATFORM_MODULE_VERSION = 1.1
 ACCTON_MINIPACK_PLATFORM_MODULE_VERSION = 1.1
 ACCTON_AS5812_54X_PLATFORM_MODULE_VERSION = 1.1
 ACCTON_AS5812_54T_PLATFORM_MODULE_VERSION = 1.1
@@ -29,6 +30,7 @@ export ACCTON_AS7716_32XB_PLATFORM_MODULE_VERSION
 export ACCTON_AS6712_32X_PLATFORM_MODULE_VERSION
 export ACCTON_AS7726_32X_PLATFORM_MODULE_VERSION
 export ACCTON_AS4630_54PE_PLATFORM_MODULE_VERSION
+export ACCTON_AS4630_54TE_PLATFORM_MODULE_VERSION
 export ACCTON_MINIPACK_PLATFORM_MODULE_VERSION
 export ACCTON_AS5812_54X_PLATFORM_MODULE_VERSION
 export ACCTON_AS5812_54T_PLATFORM_MODULE_VERSION
@@ -84,6 +86,10 @@ ACCTON_AS4630_54PE_PLATFORM_MODULE = sonic-platform-accton-as4630-54pe_$(ACCTON_
 $(ACCTON_AS4630_54PE_PLATFORM_MODULE)_PLATFORM = x86_64-accton_as4630_54pe-r0
 $(eval $(call add_extra_package,$(ACCTON_AS7712_32X_PLATFORM_MODULE),$(ACCTON_AS4630_54PE_PLATFORM_MODULE)))
 
+ACCTON_AS4630_54TE_PLATFORM_MODULE = sonic-platform-accton-as4630-54te_$(ACCTON_AS4630_54TE_PLATFORM_MODULE_VERSION)_amd64.deb
+$(ACCTON_AS4630_54TE_PLATFORM_MODULE)_PLATFORM = x86_64-accton_as4630_54te-r0
+$(eval $(call add_extra_package,$(ACCTON_AS7712_32X_PLATFORM_MODULE),$(ACCTON_AS4630_54TE_PLATFORM_MODULE)))
+
 ACCTON_MINIPACK_PLATFORM_MODULE = sonic-platform-accton-minipack_$(ACCTON_MINIPACK_PLATFORM_MODULE_VERSION)_amd64.deb
 $(ACCTON_MINIPACK_PLATFORM_MODULE)_PLATFORM = x86_64-accton_minipack-r0
 $(eval $(call add_extra_package,$(ACCTON_AS7712_32X_PLATFORM_MODULE),$(ACCTON_MINIPACK_PLATFORM_MODULE)))

platform/broadcom/sonic-platform-modules-accton/as4630-54te/classes/fanutil.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+# Copyright (c) 2019 Edgecore Networks Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
+# LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS
+# FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
+#
+# See the Apache Version 2.0 License for specific language governing
+# permissions and limitations under the License.
+#
+# ------------------------------------------------------------------
+# HISTORY:
+#    mm/dd/yyyy (A.D.)
+#    10/24/2019:Jostar craete for as4630_54te
+# ------------------------------------------------------------------
+
+try:
+    import logging
+except ImportError as e:
+    raise ImportError('%s - required module not found' % str(e))
+
+
+class FanUtil(object):
+    """Platform-specific FanUtil class"""
+
+    FAN_NUM_ON_MAIN_BROAD = 3
+    FAN_NUM_1_IDX = 1
+    FAN_NUM_2_IDX = 2
+    FAN_NUM_3_IDX = 3
+
+    FAN_NODE_NUM_OF_MAP = 4
+    FAN_NODE_FAULT_IDX_OF_MAP = 1
+    FAN_NODE_DIR_IDX_OF_MAP = 2
+    FAN_NODE_PRESENT_IDX_OF_MAP = 3
+    FAN_NODE_SPEED_IDX_OF_MAP = 4
+
+    BASE_VAL_PATH = '/sys/bus/i2c/devices/3-0060/{0}'
+    FAN_DUTY_PATH = '/sys/bus/i2c/devices/3-0060/fan_duty_cycle_percentage'
+
+    """ Dictionary where
+        key1 = fan id index (integer) starting from 1
+        key2 = fan node index (interger) starting from 1
+        value = path to fan device file (string) """
+    _fan_device_path_mapping = {}
+
+    _fan_device_node_mapping = {
+        (FAN_NUM_1_IDX, FAN_NODE_FAULT_IDX_OF_MAP): 'fan_fault_1',
+        (FAN_NUM_1_IDX, FAN_NODE_DIR_IDX_OF_MAP): 'fan_direction_1',
+        (FAN_NUM_1_IDX, FAN_NODE_PRESENT_IDX_OF_MAP): 'fan_present_1',
+        (FAN_NUM_1_IDX, FAN_NODE_SPEED_IDX_OF_MAP): 'fan1_input',
+
+
+        (FAN_NUM_2_IDX, FAN_NODE_FAULT_IDX_OF_MAP): 'fan_fault_2',
+        (FAN_NUM_2_IDX, FAN_NODE_DIR_IDX_OF_MAP): 'fan_direction_2',
+        (FAN_NUM_2_IDX, FAN_NODE_PRESENT_IDX_OF_MAP): 'fan_present_2',
+        (FAN_NUM_2_IDX, FAN_NODE_SPEED_IDX_OF_MAP): 'fan2_input',
+
+        (FAN_NUM_3_IDX, FAN_NODE_FAULT_IDX_OF_MAP): 'fan_fault_3',
+        (FAN_NUM_3_IDX, FAN_NODE_DIR_IDX_OF_MAP): 'fan_direction_3',
+        (FAN_NUM_3_IDX, FAN_NODE_PRESENT_IDX_OF_MAP): 'fan_present_3',
+        (FAN_NUM_3_IDX, FAN_NODE_SPEED_IDX_OF_MAP): 'fan3_input',
+    }
+
+    def _get_fan_device_node(self, fan_num, node_num):
+        return self._fan_device_node_mapping[(fan_num, node_num)]
+
+    def _get_fan_node_val(self, fan_num, node_num):
+        if fan_num < self.FAN_NUM_1_IDX or fan_num > self.FAN_NUM_ON_MAIN_BROAD:
+            logging.debug('GET. Parameter error. fan_num:%d', fan_num)
+            return None
+
+        if node_num < self.FAN_NODE_FAULT_IDX_OF_MAP or node_num > self.FAN_NODE_NUM_OF_MAP:
+            logging.debug('GET. Parameter error. node_num:%d', node_num)
+            return None
+
+        device_path = self.get_fan_device_path(fan_num, node_num)
+
+        try:
+            val_file = open(device_path, 'r')
+        except IOError as e:
+            logging.error('GET. unable to open file: %s', str(e))
+            return None
+
+        content = val_file.readline().rstrip()
+        if content == '':
+            logging.debug('GET. content is NULL. device_path:%s', device_path)
+            return None
+
+        try:
+            val_file.close()
+        except Exception:
+            logging.debug(
+                'GET. unable to close file. device_path:%s',
+                device_path)
+            return None
+
+        return int(content)
+
+    def _set_fan_node_val(self, fan_num, node_num, val):
+        if fan_num < self.FAN_NUM_1_IDX or fan_num > self.FAN_NUM_ON_MAIN_BROAD:
+            logging.debug('GET. Parameter error. fan_num:%d', fan_num)
+            return None
+
+        if node_num < self.FAN_NODE_FAULT_IDX_OF_MAP or node_num > self.FAN_NODE_NUM_OF_MAP:
+            logging.debug('GET. Parameter error. node_num:%d', node_num)
+            return None
+
+        content = str(val)
+        if content == '':
+            logging.debug('GET. content is NULL. device_path:%s', device_path)
+            return None
+
+        device_path = self.get_fan_device_path(fan_num, node_num)
+        try:
+            val_file = open(device_path, 'w')
+        except IOError as e:
+            logging.error('GET. unable to open file: %s', str(e))
+            return None
+
+        val_file.write(content)
+
+        try:
+            val_file.close()
+        except BaseException:
+            logging.debug(
+                'GET. unable to close file. device_path:%s',
+                device_path)
+            return None
+
+        return True
+
+    def __init__(self):
+        fan_path = self.BASE_VAL_PATH
+        for fan_num in range(
+                self.FAN_NUM_1_IDX,
+                self.FAN_NUM_ON_MAIN_BROAD + 1):
+            for node_num in range(
+                    self.FAN_NODE_FAULT_IDX_OF_MAP,
+                    self.FAN_NODE_NUM_OF_MAP + 1):
+                self._fan_device_path_mapping[(fan_num, node_num)] = fan_path.format(
+                    self._fan_device_node_mapping[(fan_num, node_num)])
+
+    def get_size_node_map(self):
+        return len(self._fan_device_node_mapping)
+
+    def get_fan_device_path(self, fan_num, node_num):
+        return self._fan_device_path_mapping[(fan_num, node_num)]
+
+    def get_fan_fault(self, fan_num):
+        return self._get_fan_node_val(fan_num, self.FAN_NODE_FAULT_IDX_OF_MAP)
+
+    def get_fan_present(self, fan_num):
+        return self._get_fan_node_val(
+            fan_num, self.FAN_NODE_PRESENT_IDX_OF_MAP)
+
+    def get_fan_dir(self, fan_num):
+        return self._get_fan_node_val(fan_num, self.FAN_NODE_DIR_IDX_OF_MAP)
+
+    def get_fan_duty_cycle(self):
+        try:
+            val_file = open(self.FAN_DUTY_PATH)
+        except IOError as e:
+            print "Error: unable to open file: %s" % str(e)
+            return False
+
+        content = val_file.readline().rstrip()
+        val_file.close()
+
+        return int(content)
+
+    def set_fan_duty_cycle(self, val):
+        try:
+            fan_file = open(self.FAN_DUTY_PATH, 'r+')
+        except IOError as e:
+            print "Error: unable to open file: %s" % str(e)
+            return False
+
+        fan_file.write(str(val))
+        fan_file.close()
+        return True
+
+    def get_fan_speed(self, fan_num):
+        return self._get_fan_node_val(fan_num, self.FAN_NODE_SPEED_IDX_OF_MAP)
+
+    def get_fan_status(self, fan_num):
+        if fan_num < self.FAN_NUM_1_IDX or fan_num > self.FAN_NUM_ON_MAIN_BROAD:
+            logging.debug('GET. Parameter error. fan_num, %d', fan_num)
+            return None
+        if self.get_fan_fault(
+                fan_num) == 0 and self.get_fan_present(fan_num) > 0:
+            return 1
+        else:
+            logging.debug('GET. FAN fault. fan_num, %d', fan_num)
+            return 0
+
+
+def main():
+    fan = FanUtil()
+    logging.debug('fan_duty_cycle=%d', fan.get_fan_duty_cycle())
+    for i in range(1, 4):
+        logging.debug('fan-%d speed=%d', i, fan.get_fan_speed(i))
+        logging.debug('fan-%d present=%d', i, fan.get_fan_present(i))
+        logging.debug('fan-%d fault=%d', i, fan.get_fan_fault(i))
+        logging.debug('fan-%d status=%d', i, fan.get_fan_status(i))
+
+
+if __name__ == '__main__':
+    main()

platform/broadcom/sonic-platform-modules-accton/as4630-54te/classes/thermalutil.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+# Copyright (c) 2019 Edgecore Networks Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
+# LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS
+# FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
+#
+# See the Apache Version 2.0 License for specific language governing
+# permissions and limitations under the License.
+#
+# ------------------------------------------------------------------
+# HISTORY:
+#    mm/dd/yyyy (A.D.)
+#    10/24/2019:Jostar craete for as4630_54te
+# ------------------------------------------------------------------
+
+try:
+    import logging
+    import glob
+except ImportError as e:
+    raise ImportError('%s - required module not found' % str(e))
+
+
+class ThermalUtil(object):
+    """Platform-specific ThermalUtil class"""
+    THERMAL_NUM_MAX = 4
+    THERMAL_NUM_1_IDX = 1
+    THERMAL_NUM_2_IDX = 2
+    THERMAL_NUM_3_IDX = 3
+    THERMAL_NUM_4_IDX = 4
+
+    """ Dictionary where
+        key1 = thermal id index (integer) starting from 1
+        value = path to fan device file (string) """
+
+    thermal_sysfspath = {
+        THERMAL_NUM_1_IDX: ["/sys/bus/i2c/devices/14-0048/hwmon/hwmon*/temp1_input"],
+        THERMAL_NUM_2_IDX: ["/sys/bus/i2c/devices/24-004b/hwmon/hwmon*/temp1_input"],
+        THERMAL_NUM_3_IDX: ["/sys/bus/i2c/devices/25-004a/hwmon/hwmon*/temp1_input"],
+        THERMAL_NUM_4_IDX: ["/sys/class/hwmon/hwmon1/temp1_input"],
+    }
+
+    def _get_thermal_val(self, thermal_num):
+        if thermal_num < self.THERMAL_NUM_1_IDX or thermal_num > self.THERMAL_NUM_MAX:
+            logging.debug('GET. Parameter error. thermal_num, %d', thermal_num)
+            return None
+
+        device_path = self.get_thermal_path(thermal_num)
+        for filename in glob.glob(device_path):
+            try:
+                val_file = open(filename, 'r')
+            except IOError as e:
+                logging.error('GET. unable to open file: %s', str(e))
+                return None
+            content = val_file.readline().rstrip()
+            if content == '':
+                logging.debug(
+                    'GET. content is NULL. device_path:%s',
+                    device_path)
+                return None
+            try:
+                val_file.close()
+            except BaseException:
+                logging.debug(
+                    'GET. unable to close file. device_path:%s',
+                    device_path)
+                return None
+
+            return int(content)
+
+        return 0
+
+    def get_num_thermals(self):
+        return self.THERMAL_NUM_MAX
+
+    def get_size_path_map(self):
+        return len(self.thermal_sysfspath)
+
+    def get_thermal_path(self, thermal_num):
+        return self.thermal_sysfspath[thermal_num][0]
+
+
+def main():
+    ThermalUtil()
+
+
+if __name__ == '__main__':
+    main()

platform/broadcom/sonic-platform-modules-accton/as4630-54te/modules/Makefile

@@ -0,0 +1,19 @@
+ifneq ($(KERNELRELEASE),)
+obj-m:= x86-64-accton-as4630-54te-cpld.o x86-64-accton-as4630-54te-psu.o  \
+	    x86-64-accton-as4630-54te-leds.o ym2651y.o
+	    
+else
+ifeq (,$(KERNEL_SRC))
+#$(error KERNEL_SRC is not defined)
+KVERSION=3.16.0-8-amd64
+KERNEL_DIR   = /usr/src/linux-headers-$(KVERSION)/
+KERNELDIR:=$(KERNEL_DIR)
+else
+KERNELDIR:=$(KERNEL_SRC)
+endif
+PWD:=$(shell pwd)
+default:
+	$(MAKE) -C $(KERNELDIR)  M=$(PWD) modules
+clean:
+	rm -rf *.o *.mod.o *.mod.o *.mod.c *.ko .*cmd .tmp_versions Module.markers Module.symvers modules.order
+endif

platform/broadcom/sonic-platform-modules-accton/as4630-54te/modules/x86-64-accton-as4630-54te-leds.c

@@ -0,0 +1,579 @@
+/*
+ * A LED driver for the accton_as4630_54te_led
+ *
+ * Copyright (C) 2014 Accton Technology Corporation.
+ * Brandon Chuang <brandon_chuang@accton.com.tw>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*#define DEBUG*/
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/leds.h>
+#include <linux/slab.h>
+#include <linux/dmi.h>
+
+extern int as4630_54te_cpld_read (unsigned short cpld_addr, u8 reg);
+extern int as4630_54te_cpld_write(unsigned short cpld_addr, u8 reg, u8 value);
+
+#define DRVNAME "accton_as4630_54te_led"
+
+struct accton_as4630_54te_led_data {
+    struct platform_device *pdev;
+    struct mutex	 update_lock;
+    char			 valid;		   /* != 0 if registers are valid */
+    unsigned long	last_updated;	/* In jiffies */
+    u8			   reg_val[2];	  /* only 1 register*/
+};
+
+static struct accton_as4630_54te_led_data  *ledctl = NULL;
+
+/* LED related data
+ */
+
+#define LED_CNTRLER_I2C_ADDRESS	(0x60)
+
+#define LED_TYPE_DIAG_REG_MASK	        (0x20|0x40|0x80)
+#define LED_MODE_DIAG_GREEN_VALUE       (0x20)
+#define LED_MODE_DIAG_GREEN_BLINK_VALUE	(0x60)
+#define LED_MODE_DIAG_AMBER_VALUE       (0x80)  /*It's yellow actually. Green+Red=Yellow*/
+#define LED_MODE_DIAG_OFF_VALUE	        (0x0)
+
+#define LED_TYPE_PRI_REG_MASK	        (0x8|0x4)
+#define LED_MODE_PRI_GREEN_VALUE        0x4
+#define LED_MODE_PRI_AMBER_VALUE        0x8
+#define LED_MODE_PRI_OFF_VALUE	        0x0
+
+#define LED_TYPE_POE_REG_MASK	        (0x2|0x1)
+#define LED_MODE_POE_GREEN_VALUE        0x1
+#define LED_MODE_POE_AMBER_VALUE        0x2
+#define LED_MODE_POE_OFF_VALUE	        0x0
+
+#define LED_TYPE_STK1_REG_MASK	        0x20
+#define LED_MODE_STK1_GREEN_VALUE       0x0
+#define LED_MODE_STK1_OFF_VALUE	        0x20
+
+#define LED_TYPE_STK2_REG_MASK	        0x10
+#define LED_MODE_STK2_GREEN_VALUE       0x0
+#define LED_MODE_STK2_OFF_VALUE	        0x10
+
+#define LED_TYPE_FAN_REG_MASK           (0x20|0x10)
+#define LED_MODE_FAN_AMBER_VALUE        0x20
+#define LED_MODE_FAN_GREEN_VALUE        0x10
+#define LED_MODE_FAN_OFF_VALUE	        (0x0)
+
+#define LED_TYPE_PSU2_REG_MASK          (0x8|0x4)
+#define LED_MODE_PSU2_AMBER_VALUE        0x8
+#define LED_MODE_PSU2_GREEN_VALUE        0x4
+#define LED_MODE_PSU2_OFF_VALUE	        (0x0)
+
+#define LED_TYPE_PSU1_REG_MASK          (0x2|0x1)
+#define LED_MODE_PSU1_AMBER_VALUE        0x2
+#define LED_MODE_PSU1_GREEN_VALUE        0x1
+#define LED_MODE_PSU1_OFF_VALUE	        (0x0)
+
+enum led_type {
+    LED_TYPE_DIAG,
+    LED_TYPE_PRI,
+    LED_TYPE_POE,
+    LED_TYPE_STK1,
+    LED_TYPE_STK2,
+    LED_TYPE_FAN,
+    LED_TYPE_PSU1,
+    LED_TYPE_PSU2
+};
+
+struct led_reg {
+    u32  types;
+    u8   reg_addr;
+};
+
+static const struct led_reg led_reg_map[] = {    
+    {(1<<LED_TYPE_DIAG)| (1<<LED_TYPE_PRI) | (1<<LED_TYPE_PSU2) , 0x30},
+    {(1<<LED_TYPE_PSU1) | (1<<LED_TYPE_FAN) | (1<<LED_TYPE_POE) |(1<<LED_TYPE_STK1) | (1<<LED_TYPE_STK2) , 0x31},
+};
+
+
+enum led_light_mode {
+    LED_MODE_OFF = 0,
+    LED_MODE_GREEN,
+    LED_MODE_AMBER,
+    LED_MODE_RED,
+    LED_MODE_BLUE,
+    LED_MODE_GREEN_BLINK,
+    LED_MODE_AMBER_BLINK,
+    LED_MODE_RED_BLINK,
+    LED_MODE_BLUE_BLINK,
+    LED_MODE_AUTO,
+    LED_MODE_UNKNOWN
+};
+
+struct led_type_mode {
+    enum led_type type;
+    enum led_light_mode mode;
+    int  reg_bit_mask;
+    int  mode_value;
+};
+
+static struct led_type_mode led_type_mode_data[] = {
+  {LED_TYPE_PRI, LED_MODE_OFF,   LED_TYPE_PRI_REG_MASK,  LED_MODE_PRI_OFF_VALUE},
+  {LED_TYPE_PRI, LED_MODE_GREEN, LED_TYPE_PRI_REG_MASK,  LED_MODE_PRI_GREEN_VALUE},
+  {LED_TYPE_PRI, LED_MODE_AMBER, LED_TYPE_PRI_REG_MASK,  LED_MODE_PRI_AMBER_VALUE},
+    
+  {LED_TYPE_DIAG,LED_MODE_OFF,   LED_TYPE_DIAG_REG_MASK, LED_MODE_DIAG_OFF_VALUE},
+  {LED_TYPE_DIAG,LED_MODE_GREEN, LED_TYPE_DIAG_REG_MASK, LED_MODE_DIAG_GREEN_VALUE},
+  {LED_TYPE_DIAG,LED_MODE_GREEN_BLINK, LED_TYPE_DIAG_REG_MASK,  LED_MODE_DIAG_GREEN_BLINK_VALUE},
+  {LED_TYPE_DIAG,LED_MODE_AMBER, LED_TYPE_DIAG_REG_MASK, LED_MODE_DIAG_AMBER_VALUE}, 
+  
+  {LED_TYPE_POE,LED_MODE_OFF,    LED_TYPE_POE_REG_MASK,  LED_MODE_POE_OFF_VALUE},
+  {LED_TYPE_POE,LED_MODE_GREEN,  LED_TYPE_POE_REG_MASK,  LED_MODE_POE_GREEN_VALUE},
+  {LED_TYPE_POE,LED_MODE_AMBER,  LED_TYPE_POE_REG_MASK,  LED_MODE_POE_AMBER_VALUE},
+  
+  {LED_TYPE_STK1,LED_MODE_OFF,   LED_TYPE_STK1_REG_MASK, LED_MODE_STK1_OFF_VALUE},
+  {LED_TYPE_STK1,LED_MODE_GREEN, LED_TYPE_STK1_REG_MASK, LED_MODE_STK1_GREEN_VALUE},
+  
+  {LED_TYPE_STK2,LED_MODE_OFF,   LED_TYPE_STK2_REG_MASK, LED_MODE_STK2_OFF_VALUE},
+  {LED_TYPE_STK2,LED_MODE_GREEN, LED_TYPE_STK2_REG_MASK, LED_MODE_STK2_GREEN_VALUE},
+  
+  {LED_TYPE_FAN,LED_MODE_OFF,    LED_TYPE_FAN_REG_MASK,  LED_MODE_FAN_OFF_VALUE},
+  {LED_TYPE_FAN,LED_MODE_GREEN,  LED_TYPE_FAN_REG_MASK,  LED_MODE_FAN_GREEN_VALUE},  
+  {LED_TYPE_FAN,LED_MODE_AMBER,  LED_TYPE_FAN_REG_MASK,  LED_MODE_FAN_AMBER_VALUE},
+  
+  {LED_TYPE_PSU1,LED_MODE_OFF,   LED_TYPE_PSU1_REG_MASK, LED_MODE_PSU1_OFF_VALUE},
+  {LED_TYPE_PSU1,LED_MODE_GREEN, LED_TYPE_PSU1_REG_MASK, LED_MODE_PSU1_GREEN_VALUE},  
+  {LED_TYPE_PSU1,LED_MODE_AMBER, LED_TYPE_PSU1_REG_MASK, LED_MODE_PSU1_AMBER_VALUE},
+  
+  {LED_TYPE_PSU2,LED_MODE_OFF,   LED_TYPE_PSU2_REG_MASK, LED_MODE_PSU2_OFF_VALUE},
+  {LED_TYPE_PSU2,LED_MODE_GREEN, LED_TYPE_PSU2_REG_MASK, LED_MODE_PSU2_GREEN_VALUE},  
+  {LED_TYPE_PSU2,LED_MODE_AMBER, LED_TYPE_PSU2_REG_MASK, LED_MODE_PSU2_AMBER_VALUE},
+  
+};
+
+
+
+static void accton_as4630_54te_led_set(struct led_classdev *led_cdev,
+                                      enum led_brightness led_light_mode, enum led_type type);
+
+
+
+
+
+static int accton_getLedReg(enum led_type type, u8 *reg)
+{
+    int i;
+    
+    for (i = 0; i < ARRAY_SIZE(led_reg_map); i++) {        
+        if(led_reg_map[i].types & (1<<type)) {            
+            *reg = led_reg_map[i].reg_addr;
+            return 0;
+        }
+    }
+    
+    return 1;
+}
+
+
+static int led_reg_val_to_light_mode(enum led_type type, u8 reg_val) {
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(led_type_mode_data); i++) {
+
+        if (type != led_type_mode_data[i].type)
+            continue;
+
+        if ((led_type_mode_data[i].reg_bit_mask & reg_val) ==
+                led_type_mode_data[i].mode_value)
+        {
+            return led_type_mode_data[i].mode;
+        }
+    }
+
+    return 0;
+}
+
+static u8 led_light_mode_to_reg_val(enum led_type type,
+                                    enum led_light_mode mode, u8 reg_val) {
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(led_type_mode_data); i++) {
+        if (type != led_type_mode_data[i].type)
+            continue;
+
+        if (mode != led_type_mode_data[i].mode)
+            continue;
+        reg_val = led_type_mode_data[i].mode_value |
+                  (reg_val & (~led_type_mode_data[i].reg_bit_mask));
+        break;
+    }
+
+    return reg_val;
+}
+
+static int accton_as4630_54te_led_read_value(u8 reg)
+{
+    return as4630_54te_cpld_read(LED_CNTRLER_I2C_ADDRESS, reg);
+}
+
+static int accton_as4630_54te_led_write_value(u8 reg, u8 value)
+{
+    return as4630_54te_cpld_write(LED_CNTRLER_I2C_ADDRESS, reg, value);
+}
+
+static void accton_as4630_54te_led_update(void)
+{
+    mutex_lock(&ledctl->update_lock);
+
+    if (time_after(jiffies, ledctl->last_updated + HZ + HZ / 2)
+            || !ledctl->valid) {
+        int i;
+
+        dev_dbg(&ledctl->pdev->dev, "Starting accton_as4630_54te_led update\n");
+
+        /* Update LED data
+         */
+        for (i = 0; i < ARRAY_SIZE(ledctl->reg_val); i++) {
+            int status = accton_as4630_54te_led_read_value(led_reg_map[i].reg_addr);
+
+            if (status < 0) {
+                ledctl->valid = 0;
+                dev_dbg(&ledctl->pdev->dev, "reg %d, err %d\n", led_reg_map[i].reg_addr, status);
+                goto exit;
+            }
+            else
+            {
+                ledctl->reg_val[i] = status;
+            }
+        }
+
+        ledctl->last_updated = jiffies;
+        ledctl->valid = 1;
+    }
+
+exit:
+    mutex_unlock(&ledctl->update_lock);
+}
+
+static void accton_as4630_54te_led_set(struct led_classdev *led_cdev,
+                                      enum led_brightness led_light_mode,
+                                      enum led_type type)
+{
+    int reg_val;
+    u8 reg	;
+    mutex_lock(&ledctl->update_lock);
+
+    if( !accton_getLedReg(type, &reg))
+    {
+        dev_dbg(&ledctl->pdev->dev, "Not match item for %d.\n", type);
+    }
+    
+    
+    reg_val = accton_as4630_54te_led_read_value(reg);
+    if (reg_val < 0) {
+        dev_dbg(&ledctl->pdev->dev, "reg %d, err %d\n", reg, reg_val);
+        goto exit;
+    }
+    reg_val = led_light_mode_to_reg_val(type, led_light_mode, reg_val);
+    
+    accton_as4630_54te_led_write_value(reg, reg_val);
+
+    /* to prevent the slow-update issue */
+    ledctl->valid = 0;
+
+exit:
+    mutex_unlock(&ledctl->update_lock);
+}
+
+
+static void accton_as4630_54te_led_diag_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode,  LED_TYPE_DIAG);
+}
+
+static enum led_brightness accton_as4630_54te_led_diag_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_DIAG, ledctl->reg_val[0]);
+}
+
+static void accton_as4630_54te_led_pri_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode, LED_TYPE_PRI);
+}
+
+static enum led_brightness accton_as4630_54te_led_pri_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_PRI, ledctl->reg_val[0]);
+}
+
+static void accton_as4630_54te_led_poe_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode, LED_TYPE_POE);
+}
+
+static enum led_brightness accton_as4630_54te_led_poe_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_POE, ledctl->reg_val[1]);
+}
+
+
+static void accton_as4630_54te_led_stk1_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode, LED_TYPE_STK1);
+}
+
+static enum led_brightness accton_as4630_54te_led_stk1_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_STK1, ledctl->reg_val[1]);
+}
+
+static void accton_as4630_54te_led_stk2_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode, LED_TYPE_STK2);
+}
+
+static enum led_brightness accton_as4630_54te_led_stk2_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_STK2, ledctl->reg_val[1]);
+}
+
+static void accton_as4630_54te_led_fan_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode, LED_TYPE_FAN);
+}
+
+static enum led_brightness accton_as4630_54te_led_fan_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_FAN, ledctl->reg_val[0]);
+}
+
+static void accton_as4630_54te_led_psu1_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode, LED_TYPE_PSU1);
+}
+
+static enum led_brightness accton_as4630_54te_led_psu1_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_PSU1, ledctl->reg_val[0]);
+}
+
+static void accton_as4630_54te_led_psu2_set(struct led_classdev *led_cdev,
+        enum led_brightness led_light_mode)
+{
+    accton_as4630_54te_led_set(led_cdev, led_light_mode, LED_TYPE_PSU2);
+}
+
+static enum led_brightness accton_as4630_54te_led_psu2_get(struct led_classdev *cdev)
+{
+    accton_as4630_54te_led_update();
+    return led_reg_val_to_light_mode(LED_TYPE_PSU2, ledctl->reg_val[0]);
+}
+
+static struct led_classdev accton_as4630_54te_leds[] = {
+    [LED_TYPE_DIAG] = {
+        .name			 = "diag",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_diag_set,
+        .brightness_get	 = accton_as4630_54te_led_diag_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness	 = LED_MODE_GREEN,
+    },
+    [LED_TYPE_PRI] = {
+        .name			 = "pri",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_pri_set,
+        .brightness_get	 = accton_as4630_54te_led_pri_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness	 = LED_MODE_AMBER,
+    },
+    [LED_TYPE_POE] = {
+        .name			 = "poe",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_poe_set,
+        .brightness_get	 = accton_as4630_54te_led_poe_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness	 = LED_MODE_AMBER,
+    },
+    [LED_TYPE_STK1] = {
+        .name			 = "stk1",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_stk1_set,
+        .brightness_get	 = accton_as4630_54te_led_stk1_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness	 = LED_MODE_GREEN,
+    },
+    [LED_TYPE_STK2] = {
+        .name			 = "stk2",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_stk2_set,
+        .brightness_get	 = accton_as4630_54te_led_stk2_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness	 = LED_MODE_GREEN,
+    },
+    [LED_TYPE_FAN] = {
+        .name			 = "fan",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_fan_set,
+        .brightness_get  = accton_as4630_54te_led_fan_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness  = LED_MODE_AUTO,
+    },
+    [LED_TYPE_PSU1] = {
+        .name			 = "psu1",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_psu1_set,
+        .brightness_get  = accton_as4630_54te_led_psu1_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness  = LED_MODE_AUTO,
+    },
+    [LED_TYPE_PSU2] = {
+        .name			 = "psu2",
+        .default_trigger = "unused",
+        .brightness_set	 = accton_as4630_54te_led_psu2_set,
+        .brightness_get  = accton_as4630_54te_led_psu2_get,
+        .flags			 = LED_CORE_SUSPENDRESUME,
+        .max_brightness  = LED_MODE_AUTO,
+    },
+};
+
+static int accton_as4630_54te_led_suspend(struct platform_device *dev,
+        pm_message_t state)
+{
+    int i = 0;
+
+    for (i = 0; i < ARRAY_SIZE(accton_as4630_54te_leds); i++) {
+        led_classdev_suspend(&accton_as4630_54te_leds[i]);
+    }
+
+    return 0;
+}
+
+static int accton_as4630_54te_led_resume(struct platform_device *dev)
+{
+    int i = 0;
+
+    for (i = 0; i < ARRAY_SIZE(accton_as4630_54te_leds); i++) {
+        led_classdev_resume(&accton_as4630_54te_leds[i]);
+    }
+
+    return 0;
+}
+
+static int accton_as4630_54te_led_probe(struct platform_device *pdev)
+{
+    int ret, i;
+
+    for (i = 0; i < ARRAY_SIZE(accton_as4630_54te_leds); i++) {
+        ret = led_classdev_register(&pdev->dev, &accton_as4630_54te_leds[i]);
+
+        if (ret < 0)
+            break;
+    }
+
+    /* Check if all LEDs were successfully registered */
+    if (i != ARRAY_SIZE(accton_as4630_54te_leds)) {
+        int j;
+
+        /* only unregister the LEDs that were successfully registered */
+        for (j = 0; j < i; j++) {
+            led_classdev_unregister(&accton_as4630_54te_leds[i]);
+        }
+    }
+
+    return ret;
+}
+
+static int accton_as4630_54te_led_remove(struct platform_device *pdev)
+{
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(accton_as4630_54te_leds); i++) {
+        led_classdev_unregister(&accton_as4630_54te_leds[i]);
+    }
+
+    return 0;
+}
+
+static struct platform_driver accton_as4630_54te_led_driver = {
+    .probe	  = accton_as4630_54te_led_probe,
+    .remove	 = accton_as4630_54te_led_remove,
+    .suspend	= accton_as4630_54te_led_suspend,
+    .resume	 = accton_as4630_54te_led_resume,
+    .driver	 = {
+        .name   = DRVNAME,
+        .owner  = THIS_MODULE,
+    },
+};
+
+static int __init accton_as4630_54te_led_init(void)
+{
+    int ret;
+
+    ret = platform_driver_register(&accton_as4630_54te_led_driver);
+    if (ret < 0) {
+        goto exit;
+    }
+
+    ledctl = kzalloc(sizeof(struct accton_as4630_54te_led_data), GFP_KERNEL);
+    if (!ledctl) {
+        ret = -ENOMEM;
+        platform_driver_unregister(&accton_as4630_54te_led_driver);
+        goto exit;
+    }
+
+    mutex_init(&ledctl->update_lock);
+
+    ledctl->pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0);
+    if (IS_ERR(ledctl->pdev)) {
+        ret = PTR_ERR(ledctl->pdev);
+        platform_driver_unregister(&accton_as4630_54te_led_driver);
+        kfree(ledctl);
+        goto exit;
+    }
+
+exit:
+    return ret;
+}
+
+static void __exit accton_as4630_54te_led_exit(void)
+{
+    platform_device_unregister(ledctl->pdev);
+    platform_driver_unregister(&accton_as4630_54te_led_driver);
+    kfree(ledctl);
+}
+
+module_init(accton_as4630_54te_led_init);
+module_exit(accton_as4630_54te_led_exit);
+
+MODULE_AUTHOR("Brandon Chuang <brandon_chuang@accton.com.tw>");
+MODULE_DESCRIPTION("accton_as4630_54te_led driver");
+MODULE_LICENSE("GPL");

platform/broadcom/sonic-platform-modules-accton/as4630-54te/modules/x86-64-accton-as4630-54te-psu.c

@@ -0,0 +1,320 @@
+/*
+ * An hwmon driver for accton as4630_54te Power Module
+ *
+ * Copyright (C) 2014 Accton Technology Corporation.
+ * Brandon Chuang <brandon_chuang@accton.com.tw>
+ *
+ * Based on ad7414.c
+ * Copyright 2006 Stefan Roese <sr at denx.de>, DENX Software Engineering
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <linux/sysfs.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/dmi.h>
+
+#define MAX_MODEL_NAME          20
+#define MAX_SERIAL_NUMBER       18
+
+static ssize_t show_status(struct device *dev, struct device_attribute *da, char *buf);
+static ssize_t show_string(struct device *dev, struct device_attribute *da, char *buf);
+static int as4630_54te_psu_read_block(struct i2c_client *client, u8 command, u8 *data,int data_len);
+extern int as4630_54te_cpld_read(unsigned short cpld_addr, u8 reg);
+
+/* Addresses scanned
+ */
+static const unsigned short normal_i2c[] = { 0x50, 0x51, I2C_CLIENT_END };
+
+/* Each client has this additional data
+ */
+struct as4630_54te_psu_data {
+    struct device      *hwmon_dev;
+    struct mutex        update_lock;
+    char                valid;           /* !=0 if registers are valid */
+    unsigned long       last_updated;    /* In jiffies */
+    u8  index;           /* PSU index */
+    u8  status;          /* Status(present/power_good) register read from CPLD */
+    char model_name[MAX_MODEL_NAME]; /* Model name, read from eeprom */
+    char serial_number[MAX_SERIAL_NUMBER];
+};
+
+static struct as4630_54te_psu_data *as4630_54te_psu_update_device(struct device *dev);
+
+enum as4630_54te_psu_sysfs_attributes {
+    PSU_PRESENT,
+    PSU_MODEL_NAME,
+    PSU_POWER_GOOD,
+    PSU_SERIAL_NUMBER
+};
+
+/* sysfs attributes for hwmon
+ */
+static SENSOR_DEVICE_ATTR(psu_present,    S_IRUGO, show_status,    NULL, PSU_PRESENT);
+static SENSOR_DEVICE_ATTR(psu_model_name, S_IRUGO, show_string,    NULL, PSU_MODEL_NAME);
+static SENSOR_DEVICE_ATTR(psu_power_good, S_IRUGO, show_status,    NULL, PSU_POWER_GOOD);
+static SENSOR_DEVICE_ATTR(psu_serial_number, S_IRUGO, show_string, NULL, PSU_SERIAL_NUMBER);
+
+
+static struct attribute *as4630_54te_psu_attributes[] = {
+    &sensor_dev_attr_psu_present.dev_attr.attr,
+    &sensor_dev_attr_psu_model_name.dev_attr.attr,
+    &sensor_dev_attr_psu_power_good.dev_attr.attr,
+    &sensor_dev_attr_psu_serial_number.dev_attr.attr,
+    NULL
+};
+
+static ssize_t show_status(struct device *dev, struct device_attribute *da,
+                           char *buf)
+{
+    struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+    struct as4630_54te_psu_data *data = as4630_54te_psu_update_device(dev);
+    u8 status = 0;
+
+    //printk("data->status=0x%x, attr->index=%d,data->index=%d \n", data->status, attr->index, data->index);
+    if (attr->index == PSU_PRESENT) {
+        if(data->index==0)
+            status = !( (data->status >> 5) & 0x1);
+        else
+            status = !( (data->status >> 1) & 0x1);
+    }
+    else { /* PSU_POWER_GOOD */
+        if(data->index==0)
+           status = ( (data->status >> 6) & 0x1);
+        else
+           status = ( (data->status >> 2) & 0x1); 
+    }
+
+    return sprintf(buf, "%d\n", status);
+}
+
+static ssize_t show_string(struct device *dev, struct device_attribute *da,
+                               char *buf)
+{
+   struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+    struct as4630_54te_psu_data *data = as4630_54te_psu_update_device(dev);
+    char *ptr = NULL;
+
+    if (!data->valid) {
+        return -EIO;
+    }
+
+	switch (attr->index) {
+	case PSU_MODEL_NAME:
+		ptr = data->model_name;
+		break;
+	case PSU_SERIAL_NUMBER:
+		ptr = data->serial_number;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+    return sprintf(buf, "%s\n", ptr);
+}
+
+static const struct attribute_group as4630_54te_psu_group = {
+    .attrs = as4630_54te_psu_attributes,
+};
+
+static int as4630_54te_psu_probe(struct i2c_client *client,
+                                const struct i2c_device_id *dev_id)
+{
+    struct as4630_54te_psu_data *data;
+    int status;
+
+    if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
+        status = -EIO;
+        goto exit;
+    }
+
+    data = kzalloc(sizeof(struct as4630_54te_psu_data), GFP_KERNEL);
+    if (!data) {
+        status = -ENOMEM;
+        goto exit;
+    }
+
+    i2c_set_clientdata(client, data);
+    data->valid = 0;
+    data->index = dev_id->driver_data;
+    mutex_init(&data->update_lock);
+
+    dev_info(&client->dev, "chip found\n");
+
+    /* Register sysfs hooks */
+    status = sysfs_create_group(&client->dev.kobj, &as4630_54te_psu_group);
+    if (status) {
+        goto exit_free;
+    }
+
+    data->hwmon_dev = hwmon_device_register(&client->dev);
+    if (IS_ERR(data->hwmon_dev)) {
+        status = PTR_ERR(data->hwmon_dev);
+        goto exit_remove;
+    }
+
+    dev_info(&client->dev, "%s: psu '%s'\n",
+             dev_name(data->hwmon_dev), client->name);
+
+    return 0;
+
+exit_remove:
+    sysfs_remove_group(&client->dev.kobj, &as4630_54te_psu_group);
+exit_free:
+    kfree(data);
+exit:
+
+    return status;
+}
+
+static int as4630_54te_psu_remove(struct i2c_client *client)
+{
+    struct as4630_54te_psu_data *data = i2c_get_clientdata(client);
+
+    hwmon_device_unregister(data->hwmon_dev);
+    sysfs_remove_group(&client->dev.kobj, &as4630_54te_psu_group);
+    kfree(data);
+
+    return 0;
+}
+
+enum psu_index
+{
+    as4630_54te_psu1,
+    as4630_54te_psu2
+};
+
+static const struct i2c_device_id as4630_54te_psu_id[] = {
+    { "as4630_54te_psu1", as4630_54te_psu1 },
+    { "as4630_54te_psu2", as4630_54te_psu2 },
+    {}
+};
+MODULE_DEVICE_TABLE(i2c, as4630_54te_psu_id);
+
+static struct i2c_driver as4630_54te_psu_driver = {
+    .class        = I2C_CLASS_HWMON,
+    .driver = {
+        .name     = "as4630_54te_psu",
+    },
+    .probe        = as4630_54te_psu_probe,
+    .remove       = as4630_54te_psu_remove,
+    .id_table     = as4630_54te_psu_id,
+    .address_list = normal_i2c,
+};
+
+static int as4630_54te_psu_read_block(struct i2c_client *client, u8 command, u8 *data,
+                                     int data_len)
+{
+    int result = 0;
+    int retry_count = 5;
+
+    while (retry_count) {
+        retry_count--;
+
+        result = i2c_smbus_read_i2c_block_data(client, command, data_len, data);
+
+        if (unlikely(result < 0)) {
+            msleep(10);
+            continue;
+        }
+
+        if (unlikely(result != data_len)) {
+            result = -EIO;
+            msleep(10);
+            continue;
+        }
+
+        result = 0;
+        break;
+    }
+
+    return result;
+}
+
+static struct as4630_54te_psu_data *as4630_54te_psu_update_device(struct device *dev)
+{
+    struct i2c_client *client = to_i2c_client(dev);
+    struct as4630_54te_psu_data *data = i2c_get_clientdata(client);
+
+    mutex_lock(&data->update_lock);
+
+    if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
+            || !data->valid) {
+        int status;
+        int power_good = 0;
+
+        dev_dbg(&client->dev, "Starting as4630_54te update\n");
+
+        /* Read psu status */
+        status = as4630_54te_cpld_read(0x60, 0x22);
+        //printk("status=0x%x in %s\n", status, __FUNCTION__);
+        if (status < 0) {
+            dev_dbg(&client->dev, "cpld reg 0x60 err %d\n", status);
+        }
+        else {
+            data->status = status;
+        }
+
+        /* Read model name */
+        memset(data->model_name, 0, sizeof(data->model_name));
+        memset(data->serial_number, 0, sizeof(data->serial_number));
+        power_good = (data->status >> (3-data->index) & 0x1);
+       
+        if (power_good) {
+            status = as4630_54te_psu_read_block(client, 0x20, data->model_name,
+                                               ARRAY_SIZE(data->model_name)-1);                                               
+            if (status < 0) {
+                data->model_name[0] = '\0';
+                dev_dbg(&client->dev, "unable to read model name from (0x%x)\n", client->addr);
+                printk("unable to read model name from (0x%x)\n", client->addr);
+            }
+            else {
+                data->model_name[ARRAY_SIZE(data->model_name)-1] = '\0';
+                
+            }
+             /* Read from offset 0x2e ~ 0x3d (16 bytes) */
+            status = as4630_54te_psu_read_block(client, 0x35,data->serial_number, MAX_SERIAL_NUMBER);
+            if (status < 0)
+            {
+                data->serial_number[0] = '\0';
+                dev_dbg(&client->dev, "unable to read model name from (0x%x) offset(0x2e)\n", client->addr);
+                printk("unable to read model name from (0x%x) offset(0x2e)\n", client->addr);
+            }
+            data->serial_number[MAX_SERIAL_NUMBER-1]='\0';
+        }
+
+        data->last_updated = jiffies;
+        data->valid = 1;
+    }
+
+    mutex_unlock(&data->update_lock);
+
+    return data;
+}
+
+module_i2c_driver(as4630_54te_psu_driver);
+
+MODULE_AUTHOR("Brandon Chuang <brandon_chuang@accton.com.tw>");
+MODULE_DESCRIPTION("as4630_54te_psu driver");
+MODULE_LICENSE("GPL");
+

platform/broadcom/sonic-platform-modules-accton/as4630-54te/modules/ym2651y.c

@@ -0,0 +1 @@
+../../common/modules/ym2651y.c

platform/broadcom/sonic-platform-modules-accton/as4630-54te/service/as4630-54te-platform-handle-mgmt-interface.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Accton AS4630-54TE Platform handle management interface service
+After=sysinit.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/usr/local/bin/handle_mgmt_interface.sh
+
+[Install]
+WantedBy=multi-user.target

platform/broadcom/sonic-platform-modules-accton/as4630-54te/service/as4630-54te-platform-monitor-fan.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=Accton AS4630-54TE Platform Monitoring FAN service
+Before=pmon.service
+After=as4630-54te-platform-monitor.service
+DefaultDependencies=no
+
+[Service]
+ExecStart=/usr/local/bin/accton_as4630_54te_monitor_fan.py
+KillSignal=SIGKILL
+SuccessExitStatus=SIGKILL
+
+# Resource Limitations
+LimitCORE=infinity
+
+[Install]
+WantedBy=multi-user.target

platform/broadcom/sonic-platform-modules-accton/as4630-54te/service/as4630-54te-platform-monitor-psu.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=Accton AS4630-54TE Platform Monitoring PSU service
+Before=pmon.service
+After=as4630-54te-platform-monitor.service
+DefaultDependencies=no
+
+[Service]
+ExecStart=/usr/local/bin/accton_as4630_54te_monitor_psu.py
+KillSignal=SIGKILL
+SuccessExitStatus=SIGKILL
+
+# Resource Limitations
+LimitCORE=infinity
+
+[Install]
+WantedBy=multi-user.target

platform/broadcom/sonic-platform-modules-accton/as4630-54te/service/as4630-54te-platform-monitor.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=Accton AS4630-54TE Platform Monitoring service
+Before=pmon.service
+After=sysinit.target
+DefaultDependencies=no
+
+[Service]
+ExecStartPre=/usr/local/bin/accton_as4630_54te_util.py install
+ExecStart=/usr/local/bin/accton_as4630_54te_monitor.py
+KillSignal=SIGKILL
+SuccessExitStatus=SIGKILL
+
+# Resource Limitations
+LimitCORE=infinity
+
+[Install]
+WantedBy=multi-user.target

platform/broadcom/sonic-platform-modules-accton/as4630-54te/setup.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+
+import os
+from setuptools import setup
+os.listdir
+
+setup(
+    name='as4630_54te',
+    version='1.0',
+    description='Module to initialize Accton AS4630-54TE platforms',
+
+    packages=['as4630_54te'],
+    package_dir={'as4630_54te': 'as4630-54te/classes'},
+)

platform/broadcom/sonic-platform-modules-accton/as4630-54te/sonic_platform_setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup
+
+DEVICE_NAME = 'accton'
+HW_SKU = 'x86_64-accton_as4630_54te-r0'  
+
+setup(
+    name='sonic-platform',
+    version='1.0',
+    description='SONiC platform API implementation on Accton Platforms',
+    license='Apache 2.0',
+    author='SONiC Team',
+    author_email='linuxnetdev@microsoft.com',
+    url='https://github.com/Azure/sonic-buildimage',
+    maintainer='Michael Shih',
+    maintainer_email='michael_shih@edge-core.com',
+    packages=[
+        'sonic_platform',
+    ],
+    package_dir={
+        'sonic_platform': '../../../../device/{}/{}/sonic_platform'.format(DEVICE_NAME, HW_SKU)},
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Environment :: Plugins',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Information Technology',
+        'Intended Audience :: System Administrators',
+        'License :: OSI Approved :: Apache Software License',
+        'Natural Language :: English',
+        'Operating System :: POSIX :: Linux',
+        'Programming Language :: Python :: 3.7',
+        'Topic :: Utilities',
+    ],
+    keywords='sonic SONiC platform PLATFORM',
+)

platform/broadcom/sonic-platform-modules-accton/as4630-54te/utils/README

@@ -0,0 +1,67 @@
+Copyright (C) 2019 Accton Networks, Inc.
+
+This program is free software: you can redistribute it and/or modify
+It under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+All Linux kernel code is licensed under the GPLv1. All other code is
+licensed under the GPLv3. Please see the LICENSE file for copies of
+both licenses.
+
+The code for integacting with Accton AS4630-54te has 2 parts, 
+kernel drivers and operational script. 
+The kernel drivers of peripherals are under module/ directory.
+1.  These drivers are at module dir.
+2.  A operational script, accton_as4630_util.py, for device initializatian and 
+    peripheral accessing should be installed at /usr/bin. 
+    Run "accton_as4630_util.py install" to install drivers.
+
+To initialize the system, run "accton_as4630_util.py install".
+To clean up the drivers & devices, run "accton_as4630_util.py clean".
+To dump information of sensors, run "accton_as4630_util.py show".
+To dump SFP EEPROM, run "accton_as4630_util.py sff".
+To set fan speed, run "accton_as4630_util.py set fan".
+To enable/disable SFP emission, run "accton_as4630_util.py set sfp".
+To set system LEDs' color, run "accton_as4630_util.py set led"
+For more information, run "accton_as4630_util.py --help".
+
+====================================================================
+Besides applying accton_as4630_util.py to access peripherals, you can 
+access peripherals by sysfs nodes directly after the installation is run.
+
+System LED:
+    There are 5 system LEDs at the lower-left corner of front panel.
+    They are  loc, diag, fan, ps1, and ps2. 
+    The sysfs interface color mappings are as follows:
+    Brightness:
+        0 => off
+        1 => green
+        2 => amber
+        3 => red
+        4 => blue
+    But not all colors are available for each LED.
+
+Fan Control:
+    There are 10 fans inside 5 fan modules.
+    All fans share 1 duty setting, ranged from 0~100.
+
+Thermal sensers:
+    3 temperature sensors are controlled by the lm75 kernel modules. 
+
+PSUs:
+    There 2 power supplies slot at the left/right side of the back.
+    Once if a PSU is not plugged, the status of it is shown failed.
+
+There are 48 SFP+ and 6 QSFP modules are equipped. 
+Before operating on PSU and QSFP+, please make sure it is well plugged. 
+Otherwise, operation is going to fail.
+

platform/broadcom/sonic-platform-modules-accton/as4630-54te/utils/accton_as4630_54te_monitor.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*
+# Copyright (c) 2019 Edgecore Networks Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
+# LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS
+# FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
+#
+# See the Apache Version 2.0 License for specific language governing
+# permissions and limitations under the License.
+#
+# HISTORY:
+#    mm/dd/yyyy (A.D.)#
+#    10/24/2019:Jostar create for as4630_54te thermal plan
+# ------------------------------------------------------------------
+
+try:
+    import os
+    import sys
+    import getopt
+    import logging
+    import logging.config
+    import logging.handlers
+    import time
+    from as4630_54te.fanutil import FanUtil
+    from as4630_54te.thermalutil import ThermalUtil
+except ImportError as e:
+    raise ImportError('%s - required module not found' % str(e))
+
+# Deafults
+VERSION = '1.0'
+FUNCTION_NAME = '/usr/local/bin/accton_as4630_54te_monitor'
+
+# Temperature Policy
+# If any fan fail , please set fan speed register to 16
+# The max value of fan speed register is 14
+#  LM77(48)+LM75(4B)+LM75(4A)  >  140, Set 10
+#  LM77(48)+LM75(4B)+LM75(4A)  >  150, Set 12
+#  LM77(48)+LM75(4B)+LM75(4A)  >  160, Set 14
+#  LM77(48)+LM75(4B)+LM75(4A)  <  140, Set 8
+#  LM77(48)+LM75(4B)+LM75(4A)  <  150, Set 10
+#  LM77(48)+LM75(4B)+LM75(4A)  <  160, Set 12
+#  Reset DUT:LM77(48)>=70C
+#
+class switch(object):
+    def __init__(self, value):
+        self.value = value
+        self.fall = False
+
+    def __iter__(self):
+        """Return the match method once, then stop"""
+        yield self.match
+        raise StopIteration
+
+    def match(self, *args):
+        """Indicate whether or not to enter a case suite"""
+        if self.fall or not args:
+            return True
+        elif self.value in args:  # changed for v1.5, see below
+            self.fall = True
+            return True
+        else:
+            return False
+
+
+fan_policy_state = 0
+fan_fail = 0
+alarm_state = 0  # 0->default or clear, 1-->alarm detect
+test_temp = 0
+test_temp_list = [0, 0, 0]
+temp_test_data = 0
+test_temp_revert = 0
+# Make a class we can use to capture stdout and sterr in the log
+
+
+class device_monitor(object):
+    # static temp var
+    temp = 0
+    new_pwm = 0
+    pwm = 0
+    ori_pwm = 0
+    default_pwm = 0x4
+
+    def __init__(self, log_file, log_level):
+        """Needs a logger and a logger level."""
+        # set up logging to file
+        logging.basicConfig(
+            filename=log_file,
+            filemode='w',
+            level=log_level,
+            format='[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
+            datefmt='%H:%M:%S')
+        # set up logging to console
+        if log_level == logging.DEBUG:
+            console = logging.StreamHandler()
+            console.setLevel(log_level)
+            formatter = logging.Formatter(
+                '%(name)-12s: %(levelname)-8s %(message)s')
+            console.setFormatter(formatter)
+            logging.getLogger('').addHandler(console)
+
+        sys_handler = logging.handlers.SysLogHandler(
+            address='/dev/log')
+        sys_handler.setLevel(logging.WARNING)
+        logging.getLogger('').addHandler(sys_handler)
+
+    def get_state_from_fan_policy(self, temp, policy):
+        state = 0
+        for i in range(0, len(policy)):
+            if (temp > policy[i][2]):  # temp_down
+                if temp <= policy[i][3]:  # temp_up
+                    state = i
+
+        return state
+
+    def manage_fans(self):
+        global fan_policy_state
+        global fan_fail
+        global test_temp
+        global test_temp_list
+        global alarm_state
+        global temp_test_data
+        global test_temp_revert
+        LEVEL_FAN_MIN = 0
+        LEVEL_FAN_NORMAL = 1
+        LEVEL_FAN_MID = 2
+        LEVEL_FAN_HIGH = 3
+        LEVEL_TEMP_CRITICAL = 4
+        fan_policy = {
+            LEVEL_FAN_MIN: [50, 8, 0, 140000],
+            LEVEL_FAN_NORMAL: [62, 10, 140000, 150000],
+            LEVEL_FAN_MID: [75, 12, 150000, 160000],
+            LEVEL_FAN_HIGH: [88, 14, 160000, 240000],
+            LEVEL_TEMP_CRITICAL: [100, 16, 240000, 300000],
+        }
+        temp = [0, 0, 0]
+        thermal = ThermalUtil()
+        fan = FanUtil()
+        ori_duty_cycle = fan.get_fan_duty_cycle()
+        new_duty_cycle = 0
+
+        if test_temp == 0:
+            for i in range(0, 3):
+                temp[i] = thermal._get_thermal_val(i + 1)
+                if temp[i] == 0 or temp[i] is None:
+                    logging.warning("Get temp-%d fail", i)
+                    return False
+        else:
+            if test_temp_revert == 0:
+                temp_test_data = temp_test_data + 2000
+            else:
+                temp_test_data = temp_test_data - 2000
+
+            for i in range(0, 3):
+                temp[i] = test_temp_list[i] + temp_test_data
+            fan_fail = 0
+
+        temp_val = 0
+        for i in range(0, 3):
+            if temp[i] is None:
+                break
+            temp_val += temp[i]
+
+        # Check Fan status
+        for i in range(fan.FAN_NUM_1_IDX, fan.FAN_NUM_ON_MAIN_BROAD + 1):
+            if fan.get_fan_status(i) == 0:
+                new_pwm = 100
+                logging.warning('Fan_%d fail, set pwm to 100', i)
+                if test_temp == 0:
+                    fan_fail = 1
+                    fan.set_fan_duty_cycle(new_pwm)
+                    break
+            else:
+                fan_fail = 0
+
+        ori_state = fan_policy_state
+        fan_policy_state = self.get_state_from_fan_policy(temp_val, fan_policy)
+
+        if fan_policy_state > LEVEL_TEMP_CRITICAL or fan_policy_state < LEVEL_FAN_MIN:
+            logging.error("Get error fan current_state\n")
+            return 0
+
+        # Decision : Decide new fan pwm percent.
+        if fan_fail == 0 and ori_duty_cycle != fan_policy[fan_policy_state][0]:
+            new_duty_cycle = fan_policy[fan_policy_state][0]
+            fan.set_fan_duty_cycle(new_duty_cycle)
+
+        if temp[0] >= 70000:  # LM75-48
+            # critical case*/
+            logging.critical(
+                'Alarm-Critical for temperature critical is detected, reset DUT')
+            cmd_str = "i2cset -y -f 3 0x60 0x4 0xE4"
+            time.sleep(2)
+            return_value = os.system(cmd_str)
+            logging.warning('Fan set: i2cset -y -f 3 0x60 0x4 0xE4, status is %d', return_value)
+
+        #logging.debug('ori_state=%d, current_state=%d, temp_val=%d\n\n',ori_state, fan_policy_state, temp_val)
+
+        if ori_state < LEVEL_FAN_HIGH:
+            if fan_policy_state >= LEVEL_FAN_HIGH:
+                if alarm_state == 0:
+                    logging.warning('Alarm for temperature high is detected')
+                    alarm_state = 1
+
+        if fan_policy_state < LEVEL_FAN_MID:
+            if alarm_state == 1:
+                logging.info('Alarm for temperature high is cleared')
+                alarm_state = 0
+
+        return True
+
+
+def main(argv):
+    log_file = '%s.log' % FUNCTION_NAME
+    log_level = logging.INFO
+    global test_temp
+    if len(sys.argv) != 1:
+        try:
+            opts, args = getopt.getopt(argv, 'hdlt:', ['lfile='])
+        except getopt.GetoptError:
+            print 'Usage: %s [-d] [-l <log_file>]' % sys.argv[0]
+            return 0
+        for opt, arg in opts:
+            if opt == '-h':
+                print 'Usage: %s [-d] [-l <log_file>]' % sys.argv[0]
+                return 0
+            elif opt in ('-d', '--debug'):
+                log_level = logging.DEBUG
+            elif opt in ('-l', '--lfile'):
+                log_file = arg
+
+        if sys.argv[1] == '-t':
+            if len(sys.argv) != 5:
+                print "temp test, need input three temp"
+                return 0
+
+            i = 0
+            for x in range(2, 5):
+                test_temp_list[i] = int(sys.argv[x]) * 1000
+                i = i + 1
+            test_temp = 1
+            log_level = logging.DEBUG
+            print test_temp_list
+
+    fan = FanUtil()
+    fan.set_fan_duty_cycle(50)
+    print "set default fan speed to 50%"
+    monitor = device_monitor(log_file, log_level)
+    # Loop forever, doing something useful hopefully:
+    while True:
+        monitor.manage_fans()
+        time.sleep(10)  # 10sec
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])

platform/broadcom/sonic-platform-modules-accton/as4630-54te/utils/accton_as4630_54te_monitor_fan.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2018 Accton Technology Corporation
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# ------------------------------------------------------------------
+# HISTORY:
+#    mm/dd/yyyy (A.D.)
+#    5/15/2019:  Jostar create for as4630-54te
+# ------------------------------------------------------------------
+
+try:
+    import sys
+    import getopt
+    import logging
+    import logging.config
+    import logging.handlers
+    import time  # this is only being used as part of the example
+
+except ImportError as e:
+    raise ImportError('%s - required module not found' % str(e))
+
+# Deafults
+VERSION = '1.0'
+FUNCTION_NAME = '/usr/local/bin/accton_as4630_54te_monitor_fan'
+
+
+class switch(object):
+    def __init__(self, value):
+        self.value = value
+        self.fall = False
+
+    def __iter__(self):
+        """Return the match method once, then stop"""
+        yield self.match
+        raise StopIteration
+
+    def match(self, *args):
+        """Indicate whether or not to enter a case suite"""
+        if self.fall or not args:
+            return True
+        elif self.value in args:  # changed for v1.5, see below
+            self.fall = True
+            return True
+        else:
+            return False
+
+
+fan_state = [2, 2, 2, 2]  # init state=2, insert=1, remove=0
+fan_status_state = [2, 2, 2, 2]  # init state=2, fault=1, normal=0
+# Make a class we can use to capture stdout and sterr in the log
+
+
+class device_monitor(object):
+
+    def __init__(self, log_file, log_level):
+
+        self.fan_num = 3
+        self.fan_path = "/sys/bus/i2c/devices/3-0060/"
+        self.present = {
+            0: "fan_present_1",
+            1: "fan_present_2",
+            2: "fan_present_3",
+        }
+
+        self.fault = {
+            0: "fan_fault_1",
+            1: "fan_fault_2",
+            2: "fan_fault_3",
+        }
+
+        """Needs a logger and a logger level."""
+        # set up logging to file
+        logging.basicConfig(
+            filename=log_file,
+            filemode='w',
+            level=log_level,
+            format='[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
+            datefmt='%H:%M:%S')
+
+        # set up logging to console
+        if log_level == logging.DEBUG:
+            console = logging.StreamHandler()
+            console.setLevel(logging.DEBUG)
+            formatter = logging.Formatter(
+                '%(name)-12s: %(levelname)-8s %(message)s')
+            console.setFormatter(formatter)
+            logging.getLogger('').addHandler(console)
+
+        sys_handler = logging.handlers.SysLogHandler(address='/dev/log')
+        # sys_handler.setLevel(logging.WARNING)
+        sys_handler.setLevel(logging.INFO)
+        logging.getLogger('').addHandler(sys_handler)
+
+        #logging.debug('SET. logfile:%s / loglevel:%d', log_file, log_level)
+
+    def manage_fan(self):
+
+        FAN_STATE_REMOVE = 0
+        FAN_STATE_INSERT = 1
+
+        FAN_STATUS_FAULT = 1
+        FAN_STATUS_NORMAL = 0
+
+        global fan_state
+        global fan_status_state
+
+        for idx in range(0, self.fan_num):
+            node = self.fan_path + self.present[idx]
+            try:
+                val_file = open(node)
+            except IOError as e:
+                print "Error: unable to open file: %s" % str(e)
+                return False
+            content = val_file.readline().rstrip()
+            val_file.close()
+            # content is a string, either "0" or "1"
+            if content == "1":
+                if fan_state[idx] != 1:
+                    fan_state[idx] = FAN_STATE_INSERT
+                    logging.info("FAN-%d present is detected", idx + 1)
+            else:
+                if fan_state[idx] != 0:
+                    fan_state[idx] = FAN_STATE_REMOVE
+                    logging.warning(
+                        "Alarm for FAN-%d absent is detected", idx + 1)
+
+        for idx in range(0, self.fan_num):
+            node = self.fan_path + self.fault[idx]
+            try:
+                val_file = open(node)
+            except IOError as e:
+                print "Error: unable to open file: %s" % str(e)
+                return False
+            content = val_file.readline().rstrip()
+            val_file.close()
+            # content is a string, either "0" or "1"
+            if content == "1":
+                if fan_status_state[idx] != FAN_STATUS_FAULT:
+                    if fan_state[idx] == FAN_STATE_INSERT:
+                        logging.warning(
+                            "Alarm for FAN-%d failed is detected", idx + 1)
+                        fan_status_state[idx] = FAN_STATUS_FAULT
+            else:
+                fan_status_state[idx] = FAN_STATUS_NORMAL
+
+        return True
+
+
+def main(argv):
+    log_file = '%s.log' % FUNCTION_NAME
+    log_level = logging.INFO
+    if len(sys.argv) != 1:
+        try:
+            opts, args = getopt.getopt(argv, 'hdl:', ['lfile='])
+        except getopt.GetoptError:
+            print 'Usage: %s [-d] [-l <log_file>]' % sys.argv[0]
+            return 0
+        for opt, arg in opts:
+            if opt == '-h':
+                print 'Usage: %s [-d] [-l <log_file>]' % sys.argv[0]
+                return 0
+            elif opt in ('-d', '--debug'):
+                log_level = logging.DEBUG
+            elif opt in ('-l', '--lfile'):
+                log_file = arg
+    monitor = device_monitor(log_file, log_level)
+    while True:
+        monitor.manage_fan()
+        time.sleep(3)
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])

platform/broadcom/sonic-platform-modules-accton/as4630-54te/utils/accton_as4630_54te_monitor_psu.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2018 Accton Technology Corporation
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# ------------------------------------------------------------------
+# HISTORY:
+#    mm/dd/yyyy (A.D.)
+#    5/15/2019:  Jostar create for as4630-54te
+# ------------------------------------------------------------------
+
+try:
+    import sys
+    import getopt
+    import logging
+    import logging.config
+    import logging.handlers
+    import time  # this is only being used as part of the example
+
+except ImportError as e:
+    raise ImportError('%s - required module not found' % str(e))
+
+# Deafults
+VERSION = '1.0'
+FUNCTION_NAME = '/usr/local/bin/accton_as4630_54te_monitor_psu'
+
+
+psu_state = [2, 2]
+psu_status_state = [2, 2]
+# Make a class we can use to capture stdout and sterr in the log
+
+
+class device_monitor(object):
+
+    def __init__(self, log_file, log_level):
+
+        self.psu_num = 2
+        self.psu_path = "/sys/bus/i2c/devices/"
+        self.presence = "/psu_present"
+        self.oper_status = "/psu_power_good"
+        self.mapping = {
+            0: "10-0050",
+            1: "11-0051",
+        }
+
+        """Needs a logger and a logger level."""
+        # set up logging to file
+        logging.basicConfig(
+            filename=log_file,
+            filemode='w',
+            level=log_level,
+            format='[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
+            datefmt='%H:%M:%S')
+        # set up logging to console
+
+        if log_level == logging.DEBUG:
+            console = logging.StreamHandler()
+            console.setLevel(log_level)
+            formatter = logging.Formatter(
+                '%(name)-12s: %(levelname)-8s %(message)s')
+            console.setFormatter(formatter)
+            logging.getLogger('').addHandler(console)
+
+        sys_handler = logging.handlers.SysLogHandler(address='/dev/log')
+        # sys_handler.setLevel(logging.WARNING)
+        sys_handler.setLevel(logging.INFO)
+        logging.getLogger('').addHandler(sys_handler)
+
+        #logging.debug('SET. logfile:%s / loglevel:%d', log_file, log_level)
+
+    def manage_psu(self):
+
+        PSU_STATE_REMOVE = 0
+        PSU_STATE_INSERT = 1
+
+        PSU_STATUS_NO_POWER = 0
+        PSU_STATUS_POWER_GOOD = 1
+        PSU_STATUS_IDLE = 2
+
+        global psu_state
+
+        for idx in range(0, self.psu_num):
+            node = self.psu_path + self.mapping[idx] + self.presence
+            try:
+                val_file = open(node)
+            except IOError as e:
+                print "Error: unable to open file: %s" % str(e)
+                return False
+            content = val_file.readline().rstrip()
+            val_file.close()
+            # content is a string, either "0" or "1"
+            if content == "1":
+                if psu_state[idx] != 1:
+                    psu_state[idx] = PSU_STATE_INSERT
+                    logging.info("PSU-%d present is detected", idx + 1)
+                    # psu_status_state[idx]=PSU_STATUS_POWER_GOOD #when insert,
+                    # assume power is good. If no_power, next code will find
+                    # it.
+            else:
+                if psu_state[idx] != 0:
+                    psu_state[idx] = PSU_STATE_REMOVE
+                    logging.warning(
+                        "Alarm for PSU-%d absent is detected", idx + 1)
+                    psu_status_state[idx] = PSU_STATUS_IDLE
+
+        for idx in range(0, self.psu_num):
+            node = self.psu_path + self.mapping[idx] + self.oper_status
+            try:
+                val_file = open(node)
+            except IOError as e:
+                print "Error: unable to open file: %s" % str(e)
+                return False
+            content = val_file.readline().rstrip()
+            val_file.close()
+            # content is a string, either "0" or "1"
+            if content == "0":
+                if psu_status_state[idx] != PSU_STATUS_NO_POWER:
+                    if psu_state[idx] == PSU_STATE_INSERT:
+                        logging.warning(
+                            "Alarm for PSU-%d failed is detected", idx + 1)
+                        psu_status_state[idx] = PSU_STATUS_NO_POWER
+            else:
+                if psu_state[idx] == PSU_STATE_INSERT:
+                    if psu_status_state[idx] != PSU_STATUS_POWER_GOOD:
+                        logging.info("PSU-%d power_good is detected", idx + 1)
+                        psu_status_state[idx] = PSU_STATUS_POWER_GOOD
+
+        return True
+
+
+def main(argv):
+    log_file = '%s.log' % FUNCTION_NAME
+    log_level = logging.INFO
+    if len(sys.argv) != 1:
+        try:
+            opts, args = getopt.getopt(argv, 'hdl:', ['lfile='])
+        except getopt.GetoptError:
+            print 'Usage: %s [-d] [-l <log_file>]' % sys.argv[0]
+            return 0
+        for opt, arg in opts:
+            if opt == '-h':
+                print 'Usage: %s [-d] [-l <log_file>]' % sys.argv[0]
+                return 0
+            elif opt in ('-d', '--debug'):
+                log_level = logging.DEBUG
+            elif opt in ('-l', '--lfile'):
+                log_file = arg
+    monitor = device_monitor(log_file, log_level)
+    # Loop forever, doing something useful hopefully:
+    while True:
+        monitor.manage_psu()
+        time.sleep(3)
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])

platform/broadcom/sonic-platform-modules-accton/as4630-54te/utils/accton_as4630_54te_util.py

@@ -0,0 +1,681 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2016 Accton Networks, Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Usage: %(scriptName)s [options] command object
+options:
+    -h | --help     : this help message
+    -d | --debug    : run with debug mode
+    -f | --force    : ignore error during installation or clean
+command:
+    install     : install drivers and generate related sysfs nodes
+    clean       : uninstall drivers and remove related sysfs nodes
+    show        : show all systen status
+    sff         : dump SFP eeprom
+    set         : change board setting with fan|led|sfp
+"""
+
+import commands
+import getopt
+import sys
+import logging
+import re
+import time
+import os
+
+PROJECT_NAME = 'as4630_54te'
+version = '0.0.1'
+verbose = False
+DEBUG = False
+args = []
+ALL_DEVICE = {}
+DEVICE_NO = {
+    'led': 5,
+    'fan1': 1,
+    'fan2': 1,
+    'fan3': 1,
+    'fan4': 1,
+    'fan5': 1,
+    'thermal': 3,
+    'psu': 2,
+    'sfp': 54}
+
+
+led_prefix = '/sys/devices/platform/as4630_54te_led/leds/accton_' + \
+    PROJECT_NAME + '_led::'
+fan_prefix = '/sys/devices/platform/as4630_54te_'
+hwmon_types = {'led': ['diag', 'fan', 'loc', 'psu1', 'psu2'],
+               'fan1': ['fan'],
+               'fan2': ['fan'],
+               'fan3': ['fan'],
+               'fan4': ['fan'],
+               'fan5': ['fan'],
+               }
+hwmon_nodes = {
+    'led': ['brightness'],
+    'fan1': [
+        'fan_duty_cycle_percentage',
+        'fan1_fault',
+        'fan1_speed_rpm',
+        'fan1_direction',
+        'fanr1_fault',
+        'fanr1_speed_rpm'],
+    'fan2': [
+        'fan_duty_cycle_percentage',
+        'fan2_fault',
+        'fan2_speed_rpm',
+        'fan2_direction',
+        'fanr2_fault',
+        'fanr2_speed_rpm'],
+    'fan3': [
+        'fan_duty_cycle_percentage',
+        'fan3_fault',
+        'fan3_speed_rpm',
+        'fan3_direction',
+        'fanr3_fault',
+        'fanr3_speed_rpm'],
+    'fan4': [
+        'fan4_duty_cycle_percentage',
+        'fan4_fault',
+        'fan4_speed_rpm',
+        'fan4_direction',
+        'fanr4_fault',
+        'fanr4_speed_rpm'],
+    'fan5': [
+        'fan_duty_cycle_percentage',
+        'fan5_fault',
+        'fan5_speed_rpm',
+        'fan5_direction',
+        'fanr5_fault',
+        'fanr5_speed_rpm'],
+}
+hwmon_prefix = {'led': led_prefix,
+                'fan1': fan_prefix,
+                'fan2': fan_prefix,
+                'fan3': fan_prefix,
+                'fan4': fan_prefix,
+                'fan5': fan_prefix,
+                }
+
+i2c_prefix = '/sys/bus/i2c/devices/'
+i2c_bus = {'fan': ['54-0066'],
+           'thermal': ['54-004c', '55-0048', '55-0049', '55-004a', '55-004b'],
+           'psu': ['49-0050', '50-0053'],
+           'sfp': ['-0050']}
+i2c_nodes = {'fan': ['present', 'front_speed_rpm', 'rear_speed_rpm'],
+             'thermal': ['hwmon/hwmon*/temp1_input'],
+             'psu': ['psu_present ', 'psu_power_good'],
+             'sfp': ['module_present_ ', 'module_tx_disable_']}
+
+sfp_map = [18, 19, 20, 21, 22, 23]
+
+mknod = [
+    'echo pca9548 0x77 > /sys/bus/i2c/devices/i2c-1/new_device',
+    'echo pca9548 0x71 > /sys/bus/i2c/devices/i2c-2/new_device',
+    'echo pca9548 0x70 > /sys/bus/i2c/devices/i2c-3/new_device',
+
+    'echo as4630_54te_cpld 0x60 > /sys/bus/i2c/devices/i2c-3/new_device',
+
+    'echo lm77 0x48 > /sys/bus/i2c/devices/i2c-14/new_device',
+    'echo lm75 0x4a > /sys/bus/i2c/devices/i2c-25/new_device',
+    'echo lm75 0x4b > /sys/bus/i2c/devices/i2c-24/new_device',
+
+
+    # PSU-1
+    'echo as4630_54te_psu1 0x50 > /sys/bus/i2c/devices/i2c-10/new_device',
+    'echo ype1200am 0x58 > /sys/bus/i2c/devices/i2c-10/new_device',
+
+    # PSU-2
+    'echo as4630_54te_psu2 0x51> /sys/bus/i2c/devices/i2c-11/new_device',
+    'echo ype1200am 0x59 > /sys/bus/i2c/devices/i2c-11/new_device',
+
+    # EERPOM
+    'echo 24c02 0x57 > /sys/bus/i2c/devices/i2c-1/new_device',
+]
+
+# Disable CPLD debug mode
+cpld_set = [
+    'i2cset -y -f 3 0x60 0x2a 0xff',
+    'i2cset -y -f 3 0x60 0x2b 0xff',
+    'i2cset -y -f 3 0x60 0x86 0x89'
+]
+
+FORCE = 0
+#logging.basicConfig(filename= PROJECT_NAME+'.log', filemode='w',level=logging.DEBUG)
+# logging.basicConfig(level=logging.INFO)
+
+
+def main():
+    global DEBUG
+    global args
+    global FORCE
+
+    if DEBUG:
+        print(sys.argv[0])
+        print('ARGV      : %s' % sys.argv[1:])
+
+    if len(sys.argv) < 2:
+        show_help()
+
+    options, args = getopt.getopt(sys.argv[1:], 'hdf', ['help',
+                                                        'debug',
+                                                        'force',
+                                                        ])
+    if DEBUG:
+        print options
+        print args
+        print len(sys.argv)
+
+    for opt, arg in options:
+        if opt in ('-h', '--help'):
+            show_help()
+        elif opt in ('-d', '--debug'):
+            DEBUG = True
+            logging.basicConfig(level=logging.INFO)
+        elif opt in ('-f', '--force'):
+            FORCE = 1
+        else:
+            print "TEST"
+            logging.info('no option')
+    for arg in args:
+        if arg == 'install':
+            do_install()
+        elif arg == 'clean':
+            do_uninstall()
+        elif arg == 'api':
+            do_sonic_platform_install()
+        elif arg == 'api_clean':
+           do_sonic_platform_clean()
+        elif arg == 'show':
+            device_traversal()
+        elif arg == 'sff':
+            if len(args) != 2:
+                show_eeprom_help()
+            elif int(args[1]) == 0 or int(args[1]) > DEVICE_NO['sfp']:
+                show_eeprom_help()
+            else:
+                show_eeprom(args[1])
+            return
+        elif arg == 'set':
+            if len(args) < 3:
+                show_set_help()
+            else:
+                set_device(args[1:])
+            return
+        else:
+            show_help()
+
+    return 0
+
+
+def show_help():
+    print __doc__ % {'scriptName': sys.argv[0].split("/")[-1]}
+    sys.exit(0)
+
+
+def show_set_help():
+    cmd = sys.argv[0].split("/")[-1] + " " + args[0]
+    print cmd + " [led|sfp|fan]"
+    print "    use \"" + cmd + " led 0-4 \"  to set led color"
+    print "    use \"" + cmd + " fan 0-100\" to set fan duty percetage"
+    print "    use \"" + cmd + " sfp 1-32 {0|1}\" to set sfp# tx_disable"
+    sys.exit(0)
+
+
+def show_eeprom_help():
+    cmd = sys.argv[0].split("/")[-1] + " " + args[0]
+    print "    use \"" + cmd + " 1-32 \" to dump sfp# eeprom"
+    sys.exit(0)
+
+
+def my_log(txt):
+    if DEBUG:
+        print "[ACCTON DBG]: " + txt
+    return
+
+
+def log_os_system(cmd, show):
+    logging.info('Run :' + cmd)
+    output = ""
+    status, output = commands.getstatusoutput(cmd)
+    my_log(cmd + "with result:" + str(status))
+    my_log("cmd:" + cmd)
+    my_log("      output:" + output)
+    if status:
+        logging.info('Failed :' + cmd)
+        if show:
+            print('Failed :' + cmd)
+    return status, output
+
+
+def driver_inserted():
+    ret, lsmod = log_os_system("ls /sys/module/*accton*", 0)
+    logging.info('mods:' + lsmod)
+    if ret:
+        return False
+
+#'modprobe cpr_4011_4mxx',
+
+
+kos = [
+    'depmod -ae',
+    'modprobe i2c_dev',
+    'modprobe i2c_mux_pca954x force_deselect_on_exit=1',
+    'modprobe ym2651y',
+    'modprobe x86_64_accton_as4630_54te_cpld',
+    'modprobe x86_64_accton_as4630_54te_leds',
+    'modprobe x86_64_accton_as4630_54te_psu',
+    'modprobe optoe']
+
+
+def driver_install():
+    global FORCE
+
+    my_log("rmmond i2cismt")
+    log_os_system("rmmod i2c_ismt", 1)
+    log_os_system("rmmod i2c_i801", 1)
+    log_os_system("modprobe i2c-i801", 1)
+    time.sleep(1)
+    log_os_system("modprobe i2c-ismt", 1)
+
+    for i in range(0, len(kos)):
+        status, output = log_os_system(kos[i], 1)
+        if status:
+            if FORCE == 0:
+                return status
+
+    return 0
+
+
+def driver_uninstall():
+    global FORCE
+    for i in range(0, len(kos)):
+        rm = kos[-(i + 1)].replace("modprobe", "modprobe -rq")
+        lst = rm.split(" ")
+        print "lst=%s" % lst
+        if len(lst) > 3:
+            del(lst[3])
+        rm = " ".join(lst)
+        status, output = log_os_system(rm, 1)
+        if status:
+            if FORCE == 0:
+                return status
+    return 0
+
+
+def device_install():
+    global FORCE
+
+    for i in range(0, len(mknod)):
+        # for pca954x need times to built new i2c buses
+        if mknod[i].find('pca954') != -1:
+            time.sleep(2)
+
+        status, output = log_os_system(mknod[i], 1)
+        if status:
+            print output
+            if FORCE == 0:
+                return status
+    print("Check SFP")
+    for i in range(0, len(sfp_map)):
+        if(i < 4):
+            opt = 'optoe2'
+        else:
+            opt = 'optoe1'
+        status, output = log_os_system("echo " +
+                                       str(opt) +
+                                       " 0x50 > /sys/bus/i2c/devices/i2c-" +
+                                       str(sfp_map[i]) +
+                                       "/new_device", 1)
+        if status:
+            print output
+            if FORCE == 0:
+                return status
+
+        status, output = log_os_system("echo port" +
+                                       str(i +
+                                           49) +
+                                       " > /sys/bus/i2c/devices/" +
+                                       str(sfp_map[i]) +
+                                       "-0050/port_name", 1)
+        if status:
+            print output
+            if FORCE == 0:
+                return status
+
+    return
+
+
+def device_uninstall():
+    global FORCE
+
+    for i in range(0, len(sfp_map)):
+        target = "/sys/bus/i2c/devices/i2c-" + \
+            str(sfp_map[i]) + "/delete_device"
+        status, output = log_os_system("echo 0x50 > " + target, 1)
+        if status:
+            print output
+            if FORCE == 0:
+                return status
+
+    nodelist = mknod
+
+    for i in range(len(nodelist)):
+        target = nodelist[-(i + 1)]
+        temp = target.split()
+        del temp[1]
+        temp[-1] = temp[-1].replace('new_device', 'delete_device')
+        status, output = log_os_system(" ".join(temp), 1)
+        if status:
+            print output
+            if FORCE == 0:
+                return status
+
+    return
+
+
+def system_ready():
+    if driver_inserted() == False:
+        return False
+    if not device_exist():
+        print "not device_exist()"
+        return False
+    return True
+
+PLATFORM_ROOT_PATH = '/usr/share/sonic/device'
+PLATFORM_API2_WHL_FILE_PY3 ='sonic_platform-1.0-py3-none-any.whl'
+def do_sonic_platform_install():
+    device_path = "{}{}{}{}".format(PLATFORM_ROOT_PATH, '/x86_64-accton_', PROJECT_NAME, '-r0')
+    SONIC_PLATFORM_BSP_WHL_PKG_PY3 = "/".join([device_path, PLATFORM_API2_WHL_FILE_PY3])
+
+    #Check API2.0 on py whl file
+    status, output = log_os_system("pip3 show sonic-platform > /dev/null 2>&1", 0)
+    if status:
+        if os.path.exists(SONIC_PLATFORM_BSP_WHL_PKG_PY3):
+            status, output = log_os_system("pip3 install "+ SONIC_PLATFORM_BSP_WHL_PKG_PY3, 1)
+            if status:
+                print "Error: Failed to install {}".format(PLATFORM_API2_WHL_FILE_PY3)
+                return status
+            else:
+                print "Successfully installed {} package".format(PLATFORM_API2_WHL_FILE_PY3)
+        else:
+            print('{} is not found'.format(PLATFORM_API2_WHL_FILE_PY3))
+    else:
+        print('{} has installed'.format(PLATFORM_API2_WHL_FILE_PY3))
+
+    return
+
+def do_sonic_platform_clean():
+    status, output = log_os_system("pip3 show sonic-platform > /dev/null 2>&1", 0)
+    if status:
+        print('{} does not install, not need to uninstall'.format(PLATFORM_API2_WHL_FILE_PY3))
+
+    else:
+        status, output = log_os_system("pip3 uninstall sonic-platform -y", 0)
+        if status:
+            print('Error: Failed to uninstall {}'.format(PLATFORM_API2_WHL_FILE_PY3))
+            return status
+        else:
+            print('{} is uninstalled'.format(PLATFORM_API2_WHL_FILE_PY3))
+
+    return
+
+
+def do_install():
+    if driver_inserted() == False:
+        status = driver_install()
+        if status:
+            if FORCE == 0:
+                return status
+    else:
+        print PROJECT_NAME.upper() + " drivers detected...."
+    if not device_exist():
+        status = device_install()
+        if status:
+            if FORCE == 0:
+                return status
+    else:
+        print PROJECT_NAME.upper() + " devices detected...."
+
+    for i in range(len(cpld_set)):
+        status, output = log_os_system(cpld_set[i], 1)
+        if status:
+            if FORCE == 0:
+                return status
+
+    do_sonic_platform_install()
+
+    return
+
+
+def do_uninstall():
+    if not device_exist():
+        print PROJECT_NAME.upper() + " has no device installed...."
+    else:
+        print "Removing device...."
+        status = device_uninstall()
+        if status:
+            if FORCE == 0:
+                return status
+
+    if driver_inserted() == False:
+        print PROJECT_NAME.upper() + " has no driver installed...."
+    else:
+        print "Removing installed driver...."
+        status = driver_uninstall()
+        if status:
+            if FORCE == 0:
+                return status
+
+    do_sonic_platform_clean()
+
+    return
+
+
+def devices_info():
+    global DEVICE_NO
+    global ALL_DEVICE
+    global i2c_bus, hwmon_types
+    for key in DEVICE_NO:
+        ALL_DEVICE[key] = {}
+        for i in range(0, DEVICE_NO[key]):
+            ALL_DEVICE[key][key + str(i + 1)] = []
+
+    for key in i2c_bus:
+        buses = i2c_bus[key]
+        nodes = i2c_nodes[key]
+        for i in range(0, len(buses)):
+            for j in range(0, len(nodes)):
+                if 'fan' == key:
+                    for k in range(0, DEVICE_NO[key]):
+                        node = key + str(k + 1)
+                        path = i2c_prefix + \
+                            buses[i] + "/fan" + str(k + 1) + "_" + nodes[j]
+                        my_log(node + ": " + path)
+                        ALL_DEVICE[key][node].append(path)
+                elif 'sfp' == key:
+                    for k in range(0, DEVICE_NO[key]):
+                        node = key + str(k + 1)
+                        path = i2c_prefix + \
+                            str(sfp_map[k]) + buses[i] + "/" + nodes[j]
+                        my_log(node + ": " + path)
+                        ALL_DEVICE[key][node].append(path)
+                else:
+                    node = key + str(i + 1)
+                    path = i2c_prefix + buses[i] + "/" + nodes[j]
+                    my_log(node + ": " + path)
+                    ALL_DEVICE[key][node].append(path)
+
+    for key in hwmon_types:
+        itypes = hwmon_types[key]
+        nodes = hwmon_nodes[key]
+        for i in range(0, len(itypes)):
+            for j in range(0, len(nodes)):
+                node = key + "_" + itypes[i]
+                path = hwmon_prefix[key] + itypes[i] + "/" + nodes[j]
+                my_log(node + ": " + path)
+                ALL_DEVICE[key][key + str(i + 1)].append(path)
+
+    # show dict all in the order
+    if DEBUG:
+        for i in sorted(ALL_DEVICE.keys()):
+            print(i + ": ")
+            for j in sorted(ALL_DEVICE[i].keys()):
+                print("   " + j)
+                for k in (ALL_DEVICE[i][j]):
+                    print("   " + "   " + k)
+    return
+
+
+def show_eeprom(index):
+    if system_ready() == False:
+        print("System's not ready.")
+        print("Please install first!")
+        return
+
+    if len(ALL_DEVICE) == 0:
+        devices_info()
+    node = ALL_DEVICE['sfp']['sfp' + str(index)][0]
+    node = node.replace(node.split("/")[-1], 'eeprom')
+    # check if got hexdump command in current environment
+    ret, log = log_os_system("which hexdump", 0)
+    ret, log2 = log_os_system("which busybox hexdump", 0)
+    if len(log):
+        hex_cmd = 'hexdump'
+    elif len(log2):
+        hex_cmd = ' busybox hexdump'
+    else:
+        log = 'Failed : no hexdump cmd!!'
+        logging.info(log)
+        print log
+        return 1
+    print "node=%s" % node
+    print node + ":"
+    ret, log = log_os_system("cat " + node + "| " + hex_cmd + " -C", 1)
+    if ret == 0:
+        print log
+    else:
+        print "**********device no found**********"
+    return
+
+
+def set_device(args):
+    global DEVICE_NO
+    global ALL_DEVICE
+    if system_ready() == False:
+        print("System's not ready.")
+        print("Please install first!")
+        return
+
+    if len(ALL_DEVICE) == 0:
+        devices_info()
+
+    if args[0] == 'led':
+        if int(args[1]) > 4:
+            show_set_help()
+            return
+        #print  ALL_DEVICE['led']
+        for i in range(0, len(ALL_DEVICE['led'])):
+            for k in (ALL_DEVICE['led']['led' + str(i + 1)]):
+                ret, log = log_os_system("echo " + args[1] + " >" + k, 1)
+                if ret:
+                    return ret
+    elif args[0] == 'fan':
+        if int(args[1]) > 100:
+            show_set_help()
+            return
+        #print  ALL_DEVICE['fan']
+        # fan1~6 is all fine, all fan share same setting
+        node = ALL_DEVICE['fan1']['fan11'][0]
+        node = node.replace(node.split("/")[-1], 'fan1_duty_cycle_percentage')
+        ret, log = log_os_system("cat " + node, 1)
+        if ret == 0:
+            print ("Previous fan duty: " + log.strip() + "%")
+        ret, log = log_os_system("echo " + args[1] + " >" + node, 1)
+        if ret == 0:
+            print ("Current fan duty: " + args[1] + "%")
+        return ret
+    elif args[0] == 'sfp':
+        if int(args[1]) > DEVICE_NO[args[0]] or int(args[1]) == 0:
+            show_set_help()
+            return
+        if len(args) < 2:
+            show_set_help()
+            return
+
+        if int(args[2]) > 1:
+            show_set_help()
+            return
+
+        #print  ALL_DEVICE[args[0]]
+        for i in range(0, len(ALL_DEVICE[args[0]])):
+            for j in ALL_DEVICE[args[0]][args[0] + str(args[1])]:
+                if j.find('tx_disable') != -1:
+                    ret, log = log_os_system("echo " + args[2] + " >" + j, 1)
+                    if ret:
+                        return ret
+
+    return
+
+# get digits inside a string.
+# Ex: 31 for "sfp31"
+
+
+def get_value(input):
+    digit = re.findall(r'\d+', input)
+    return int(digit[0])
+
+
+def device_traversal():
+    if system_ready() == False:
+        print("System's not ready.")
+        print("Please install first!")
+        return
+
+    if len(ALL_DEVICE) == 0:
+        devices_info()
+    for i in sorted(ALL_DEVICE.keys()):
+        print("============================================")
+        print(i.upper() + ": ")
+        print("============================================")
+
+        for j in sorted(ALL_DEVICE[i].keys(), key=get_value):
+            print "   " + j + ":",
+            for k in (ALL_DEVICE[i][j]):
+                ret, log = log_os_system("cat " + k, 0)
+                func = k.split("/")[-1].strip()
+                func = re.sub(j + '_', '', func, 1)
+                func = re.sub(i.lower() + '_', '', func, 1)
+                if ret == 0:
+                    print func + "=" + log + " ",
+                else:
+                    print func + "=" + "X" + " ",
+            print
+            print("----------------------------------------------------------------")
+
+        print
+    return
+
+
+def device_exist():
+    ret1, log = log_os_system("ls " + i2c_prefix + "*0077", 0)
+    ret2, log = log_os_system("ls " + i2c_prefix + "i2c-2", 0)
+    return not(ret1 or ret2)
+
+
+if __name__ == "__main__":
+    main()

platform/broadcom/sonic-platform-modules-accton/as4630-54te/utils/handle_mgmt_interface.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+#Due to the hardware design, as4630-54te use "eth2" instead of "eth0" as management interface.
+#Rename netdev "eth0" and "eth2" to swap original "eth2" to "eth0".
+ifconfig eth0 down
+ip link set eth0 name eth3
+ip link set eth2 name eth0
+ifconfig eth0 up

platform/broadcom/sonic-platform-modules-accton/debian/control

@@ -45,6 +45,10 @@ Package: sonic-platform-accton-as4630-54pe
 Architecture: amd64
 Description: kernel modules for platform devices such as fan, led, sfp
 
+Package: sonic-platform-accton-as4630-54te
+Architecture: amd64
+Description: kernel modules for platform devices such as fan, led, sfp
+
 Package: sonic-platform-accton-minipack
 Architecture: amd64
 Description: kernel modules for platform devices such as fan, led, sfp

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

@@ -21,7 +21,7 @@ KVERSION   ?= $(shell uname -r)
 KERNEL_SRC :=  /lib/modules/$(KVERSION)
 MOD_SRC_DIR:= $(shell pwd)
 MODULE_DIRS := as7712-32x as5712-54x as7816-64x as7716-32x as7716-32xb as7312-54x
-MODULE_DIRS += as7326-56x as6712-32x as7726-32x as4630-54pe minipack as5812-54x 
+MODULE_DIRS += as7326-56x as6712-32x as7726-32x as4630-54pe as4630-54te minipack as5812-54x
 MODULE_DIRS += as5835-54x as9716-32d as5835-54t as7312-54xs as7315-27xb as5812-54t
 MODULE_DIR := modules
 UTILS_DIR := utils

platform/broadcom/sonic-platform-modules-accton/debian/sonic-platform-accton-as4630-54te.install

@@ -0,0 +1,2 @@
+as4630-54te/sonic_platform-1.0-py3-none-any.whl usr/share/sonic/device/x86_64-accton_as4630_54te-r0
+