[Mellanox] Refactor SFP related platform API and plugins with new SDK API (#5326)

Refactor SFP reset, low power get/set API, and plugins with new SDK SX APIs. Previously they were calling SDK SXD APIs which have glibc dependency because of shared memory usage.

Remove implementation "set_power_override", "tx_disable_channel", "tx_disable" which using SXD APIs, once related SDK SX API available, will add them back based on new SDK SX APIs.

device/mellanox/x86_64-mlnx_msn2700-r0/plugins/sfplpmget.py

@@ -1,43 +1,51 @@
 #!/usr/bin/env python
+"""
+This utility get the power mode of a given module.
+"""
 
-import sys, errno
+import sys
-import os
+import errno
-from python_sdk_api.sxd_api import *
 from python_sdk_api.sx_api import *
 
+def mgmt_phy_mod_pwr_attr_get(handle, module_id, power_attr_type):
+    sx_mgmt_phy_mod_pwr_attr_p = new_sx_mgmt_phy_mod_pwr_attr_t_p()
+    sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t()
+    sx_mgmt_phy_mod_pwr_attr.power_attr_type = power_attr_type
+    sx_mgmt_phy_mod_pwr_attr_t_p_assign(sx_mgmt_phy_mod_pwr_attr_p, sx_mgmt_phy_mod_pwr_attr)
+    try:
+        rc = sx_mgmt_phy_mod_pwr_attr_get(handle, module_id, sx_mgmt_phy_mod_pwr_attr_p)
+        assert SX_STATUS_SUCCESS == rc, "sx_mgmt_phy_mod_pwr_attr_get failed"
+        sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t_p_value(sx_mgmt_phy_mod_pwr_attr_p)
+        pwr_mode_attr = sx_mgmt_phy_mod_pwr_attr.pwr_mode_attr
+        return pwr_mode_attr.admin_pwr_mode_e, pwr_mode_attr.oper_pwr_mode_e
+    finally:
+        delete_sx_mgmt_phy_mod_pwr_attr_t_p(sx_mgmt_phy_mod_pwr_attr_p)
+
 # Check if SFP port number is provided
 if len(sys.argv) < 2:
-    print "SFP module number is missed."
+    print("SFP module number is missed.")
-    print "Usage: sfplpmget.py <SFP module>"
+    print("Usage: sfplpmget.py <SFP module>")
     sys.exit(errno.EINVAL)
 
 # Init SDK API
 rc, handle = sx_api_open(None)
 if (rc != SX_STATUS_SUCCESS):
-    print "Failed to open api handle.\nPlease check that SDK is running."
+    print("Failed to open api handle.\nPlease check that SDK is running.")
-    sys.exit(errno.EACCES)
-
-pid = os.getpid()
-rc = sxd_access_reg_init(pid, None, 0)
-if (rc != 0):
-    print "Failed to initializing register access.\nPlease check that SDK is running."
     sys.exit(errno.EACCES)
 
 # Get SFP module number
 sfp_module = int(sys.argv[1]) - 1
 
-# Get MCION
+admin_pwr_mode, oper_pwr_mode = mgmt_phy_mod_pwr_attr_get(handle, sfp_module, SX_MGMT_PHY_MOD_PWR_ATTR_PWR_MODE_E)
-mcion = ku_mcion_reg()
-mcion.module = sfp_module
-meta = sxd_reg_meta_t()
-meta.dev_id = 1
-meta.swid = 0
-meta.access_cmd = SXD_ACCESS_CMD_GET
 
-rc = sxd_access_reg_mcion(mcion, meta, 1, None, None)
+lpm_status = None
-assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_mcion failed, rc = %d" % rc
+if oper_pwr_mode == SX_MGMT_PHY_MOD_PWR_MODE_HIGH_E:
+    lpm_status = False
+elif oper_pwr_mode == SX_MGMT_PHY_MOD_PWR_MODE_LOW_E:
+    lpm_status = True
+else:
+    print("LPM UNKNOWN")
 
-# Get low power mode status
-lpm_mask = 1 << 8
-lpm_status = (lpm_mask & mcion.module_status_bits) != 0
 print "LPM ON" if lpm_status else "LPM OFF"
+
+sx_api_close(handle)

device/mellanox/x86_64-mlnx_msn2700-r0/plugins/sfplpmset.py

@@ -1,23 +1,17 @@
 #!/usr/bin/env python
+"""
+This utility set the power mode of a given module.
+"""
 
-import sys, errno
+import sys
-import os
+import errno
-from python_sdk_api.sxd_api import *
 from python_sdk_api.sx_api import *
 
-REGISTER_NUM = 1
+
-SXD_LOG_VERBOSITY_LEVEL = 0
 DEVICE_ID = 1
 SWITCH_ID = 0
 SX_PORT_ATTR_ARR_SIZE = 64
 
-PMAOS_ASE = 1
-PMAOS_EE = 1
-PMAOS_E = 2
-PMAOS_RST = 0
-PMAOS_ENABLE = 1
-PMAOS_DISABLE = 2
-
 PORT_TYPE_CPU = 4
 PORT_TYPE_NVE = 8
 PORT_TYPE_OFFSET = 28
@@ -36,7 +30,7 @@ def is_port_admin_status_up(log_port):
     admin_state_p = new_sx_port_admin_state_t_p()
     module_state_p = new_sx_port_module_state_t_p()
     rc = sx_api_port_state_get(handle, log_port, oper_state_p, admin_state_p, module_state_p)
-    assert rc == SXD_STATUS_SUCCESS, "sx_api_port_state_get failed, rc = %d" % rc
+    assert rc == SX_STATUS_SUCCESS, "sx_api_port_state_get failed, rc = %d" % rc
 
     admin_state = sx_port_admin_state_t_p_value(admin_state_p)
     if admin_state == SX_PORT_ADMIN_STATUS_UP:
@@ -54,116 +48,109 @@ def get_log_ports(handle, sfp_module):
     port_cnt_p = new_uint32_t_p()
     uint32_t_p_assign(port_cnt_p, SX_PORT_ATTR_ARR_SIZE)
 
-    rc = sx_api_port_device_get(handle, DEVICE_ID , SWITCH_ID, port_attributes_list,  port_cnt_p)
+    rc = sx_api_port_device_get(handle, DEVICE_ID, SWITCH_ID, port_attributes_list,  port_cnt_p)
     assert rc == SX_STATUS_SUCCESS, "sx_api_port_device_get failed, rc = %d" % rc
 
     port_cnt = uint32_t_p_value(port_cnt_p)
     log_port_list = []
     for i in range(0, port_cnt):
         port_attributes = sx_port_attributes_t_arr_getitem(port_attributes_list, i)
-        if is_nve(int(port_attributes.log_port)) == False \
+        if not is_nve(int(port_attributes.log_port)) \
-           and is_cpu(int(port_attributes.log_port)) == False \
+           and not is_cpu(int(port_attributes.log_port)) \
            and port_attributes.port_mapping.module_port == sfp_module \
            and is_port_admin_status_up(port_attributes.log_port):
             log_port_list.append(port_attributes.log_port)
 
     return log_port_list
 
-def init_sx_meta_data():
+def mgmt_phy_mod_pwr_attr_set(handle, module_id, power_attr_type, admin_pwr_mode):
-    meta = sxd_reg_meta_t()
+    sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t()
-    meta.dev_id = DEVICE_ID
+    sx_mgmt_phy_mod_pwr_mode_attr = sx_mgmt_phy_mod_pwr_mode_attr_t()
-    meta.swid = SWITCH_ID
+    sx_mgmt_phy_mod_pwr_attr.power_attr_type = power_attr_type
-    return meta
+    sx_mgmt_phy_mod_pwr_mode_attr.admin_pwr_mode_e = admin_pwr_mode
+    sx_mgmt_phy_mod_pwr_attr.pwr_mode_attr = sx_mgmt_phy_mod_pwr_mode_attr
+    sx_mgmt_phy_mod_pwr_attr_p = new_sx_mgmt_phy_mod_pwr_attr_t_p()
+    sx_mgmt_phy_mod_pwr_attr_t_p_assign(sx_mgmt_phy_mod_pwr_attr_p, sx_mgmt_phy_mod_pwr_attr)
+    try:
+        rc = sx_mgmt_phy_mod_pwr_attr_set(handle, SX_ACCESS_CMD_SET, module_id, sx_mgmt_phy_mod_pwr_attr_p)
+        assert SX_STATUS_SUCCESS == rc, "sx_mgmt_phy_mod_pwr_attr_set failed"
+    finally:
+        delete_sx_mgmt_phy_mod_pwr_attr_t_p(sx_mgmt_phy_mod_pwr_attr_p)
 
-def set_sfp_admin_status(sfp_module, admin_status):
+def mgmt_phy_mod_pwr_attr_get(handle, module_id, power_attr_type):
-    # Get PMAOS
+    sx_mgmt_phy_mod_pwr_attr_p = new_sx_mgmt_phy_mod_pwr_attr_t_p()
-    pmaos = ku_pmaos_reg()
+    sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t()
-    pmaos.module = sfp_module
+    sx_mgmt_phy_mod_pwr_attr.power_attr_type = power_attr_type
-    meta = init_sx_meta_data()
+    sx_mgmt_phy_mod_pwr_attr_t_p_assign(sx_mgmt_phy_mod_pwr_attr_p, sx_mgmt_phy_mod_pwr_attr)
-    meta.access_cmd = SXD_ACCESS_CMD_GET
+    try:
-    rc = sxd_access_reg_pmaos(pmaos, meta, REGISTER_NUM, None, None)
+        rc = sx_mgmt_phy_mod_pwr_attr_get(handle, module_id, sx_mgmt_phy_mod_pwr_attr_p)
-    assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmaos failed, rc = %d" % rc
+        assert SX_STATUS_SUCCESS == rc, "sx_mgmt_phy_mod_pwr_attr_get failed"
+        sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t_p_value(sx_mgmt_phy_mod_pwr_attr_p)
+        pwr_mode_attr = sx_mgmt_phy_mod_pwr_attr.pwr_mode_attr
+        return pwr_mode_attr.admin_pwr_mode_e, pwr_mode_attr.oper_pwr_mode_e
+    finally:
+        delete_sx_mgmt_phy_mod_pwr_attr_t_p(sx_mgmt_phy_mod_pwr_attr_p)
 
-    # Set admin status to PMAOS
+
-    pmaos.ase = PMAOS_ASE
+def pwr_attr_set(handle, module_id, ports, attr_type, power_mode):
-    pmaos.ee = PMAOS_EE
+    # Check if the module already works in the same mode
-    pmaos.e = PMAOS_E
+    admin_pwr_mode, oper_pwr_mode = mgmt_phy_mod_pwr_attr_get(handle, module_id, attr_type)
-    pmaos.rst = PMAOS_RST
+    if (power_mode == SX_MGMT_PHY_MOD_PWR_MODE_LOW_E and oper_pwr_mode == SX_MGMT_PHY_MOD_PWR_MODE_LOW_E) \
-    if admin_status == SX_PORT_ADMIN_STATUS_DOWN:
+       or (power_mode == SX_MGMT_PHY_MOD_PWR_MODE_AUTO_E and admin_pwr_mode == SX_MGMT_PHY_MOD_PWR_MODE_AUTO_E):
-        pmaos.admin_status = PMAOS_DISABLE
+        return
+    try:
+        # Bring the port down
+        for port in ports:
+            set_port_admin_status_by_log_port(handle, port, SX_PORT_ADMIN_STATUS_DOWN)
+        # Set the desired power mode
+        mgmt_phy_mod_pwr_attr_set(handle, module_id, attr_type, power_mode)
+        # Bring the port up
+    finally:
+        for port in ports:
+            set_port_admin_status_by_log_port(handle, port, SX_PORT_ADMIN_STATUS_UP)
+
+def set_lpmode(handle, cmd, module_id):
+    # Construct the port module map.
+    log_port_list = get_log_ports(handle, module_id)
+
+    if cmd == "enable":
+        pwr_attr_set(handle, module_id, log_port_list, SX_MGMT_PHY_MOD_PWR_ATTR_PWR_MODE_E, SX_MGMT_PHY_MOD_PWR_MODE_LOW_E)
+        print("Enabled low power mode for module [%d]" % module_id)
+    elif cmd == "disable":
+        pwr_attr_set(handle, module_id, log_port_list, SX_MGMT_PHY_MOD_PWR_ATTR_PWR_MODE_E, SX_MGMT_PHY_MOD_PWR_MODE_AUTO_E)
+        print("Disabled low power mode for module [%d]" % module_id)
     else:
-        pmaos.admin_status = PMAOS_ENABLE
+        print("Error: Invalid command")
+        sys.exit(0)
 
-    meta.access_cmd = SXD_ACCESS_CMD_SET
-    rc = sxd_access_reg_pmaos(pmaos, meta, REGISTER_NUM, None, None)
-    assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmaos failed, rc = %d" % rc
-
-def set_sfp_lpmode(sfp_module, lpm_enable):
-    # Get PMMP
-    pmmp = ku_pmmp_reg()
-    pmmp.module = sfp_module
-    meta = init_sx_meta_data()
-    meta.access_cmd = SXD_ACCESS_CMD_GET
-    rc = sxd_access_reg_pmmp(pmmp, meta, REGISTER_NUM, None, None)
-    assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmmp failed, rc = %d" % rc
-
-    # Set low power mode status
-    lpm_mask = 1 << 8
-    if lpm_enable:
-        pmmp.eeprom_override = pmmp.eeprom_override | lpm_mask
-    else:
-        pmmp.eeprom_override = pmmp.eeprom_override & (~lpm_mask)
-
-    meta.access_cmd = SXD_ACCESS_CMD_SET
-    rc = sxd_access_reg_pmmp(pmmp, meta, REGISTER_NUM, None, None)
-    assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmmp failed, rc = %d" % rc
-
-# Check if SFP port number is provided
 if len(sys.argv) < 3:
-    print "SFP module number or LPM is missed."
+    print("SFP module number or LPM is missed.")
-    print "Usage: sfplpmset.py <SFP module> <on|off>"
+    print("Usage: sfplpmset.py <SFP module> <on|off>")
     sys.exit(errno.EINVAL)
 
+cmd = None
 lpm_enable = None
 if sys.argv[2] == 'on':
     lpm_enable = True
+    cmd = 'enable'
 elif sys.argv[2] == 'off':
     lpm_enable = False
+    cmd = 'disable'
 else:
-    print "Unrecognized LPM parameter. Please use <on> or <off> values"
+    print("Unrecognized LPM parameter. Please use <on> or <off> values")
     sys.exit(errno.EINVAL)
 
-# Init SDK API
-rc, handle = sx_api_open(None)
-if (rc != SX_STATUS_SUCCESS):
-    print "Failed to open api handle.\nPlease check that SDK is running."
-    sys.exit(errno.EACCES)
-
-pid = os.getpid()
-rc = sxd_access_reg_init(pid, None, SXD_LOG_VERBOSITY_LEVEL)
-if (rc != SXD_STATUS_SUCCESS):
-    print "Failed to initializing register access.\nPlease check that SDK is running."
-    sys.exit(errno.EACCES);
-
 # Get SFP module
 sfp_module = int(sys.argv[1]) - 1
 
-# Get all ports at admin up status that related to the SFP module
+print "[+] opening sdk"
-log_port_list = get_log_ports(handle, sfp_module)
+rc, handle = sx_api_open(None)
 
-# SET SFP related ports to admin down status
+if (rc != SX_STATUS_SUCCESS):
-for log_port in log_port_list:
+    print("Failed to open api handle.\nPlease check that SDK is running.")
-    set_port_admin_status_by_log_port(handle, log_port, SX_PORT_ADMIN_STATUS_DOWN)
+    sys.exit(errno.EACCES)
 
-# Disable admin status before LPM settings
+# Set low power mode
-set_sfp_admin_status(sfp_module, SX_PORT_ADMIN_STATUS_DOWN)
+set_lpmode(handle, cmd, sfp_module)
 
-# Set low power mode status
+sx_api_close(handle)
-set_sfp_lpmode(sfp_module, lpm_enable)
-
-# Enable admin status after LPM settings
-set_sfp_admin_status(sfp_module, SX_PORT_ADMIN_STATUS_UP)
-
-# SET SFP related ports to admin up status
-for log_port in log_port_list:
-    set_port_admin_status_by_log_port(handle, log_port, SX_PORT_ADMIN_STATUS_UP)

device/mellanox/x86_64-mlnx_msn2700-r0/plugins/sfpreset.py

@@ -1,45 +1,28 @@
 #!/usr/bin/env python
+"""
+This utility reset the given SFP module.
+"""
 
-import sys, errno
+import sys
-import os
+import errno
-from python_sdk_api.sxd_api import *
 from python_sdk_api.sx_api import *
 
 # Check if SFP port number is provided
 if len(sys.argv) < 2:
-    print "SFP module number or LPM is missed."
+    print("SFP module number or LPM is missed.")
-    print "Usage: sfpreset.py <SFP module>"
+    print("Usage: sfpreset.py <SFP module>")
     sys.exit(errno.EINVAL)
 
 # Init SDK API
 rc, handle = sx_api_open(None)
-if (rc != SX_STATUS_SUCCESS):
+if rc != SX_STATUS_SUCCESS:
-    print "Failed to open api handle.\nPlease check that SDK is running."
+    print("Failed to open api handle.\nPlease check that SDK is running.")
-    sys.exit(errno.EACCES)
-
-pid = os.getpid()
-rc = sxd_access_reg_init(pid, None, 0)
-if (rc != 0):
-    print "Failed to initializing register access.\nPlease check that SDK is running."
     sys.exit(errno.EACCES)
 
 # Get SFP module number
 sfp_module = int(sys.argv[1]) - 1
 
-# Get PMAOS
+rc = sx_mgmt_phy_mod_reset(handle, sfp_module)
-pmaos = ku_pmaos_reg()
+assert rc == SX_STATUS_SUCCESS, "sx_mgmt_phy_mod_reset failed, rc = %d" % rc
-pmaos.module = sfp_module
-meta = sxd_reg_meta_t()
-meta.dev_id = 1
-meta.swid = 0
-meta.access_cmd = SXD_ACCESS_CMD_GET
 
-rc = sxd_access_reg_pmaos(pmaos, meta, 1, None, None)
+sx_api_close(handle)
-assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmaos failed, rc = %d" % rc
-
-# Reset SFP
-pmaos.rst = 1
-meta.access_cmd = SXD_ACCESS_CMD_SET
-rc = sxd_access_reg_pmaos(pmaos, meta, 1, None, None)
-assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmaos failed, rc = %d" % rc
-print "Reset flag is set"

platform/mellanox/mlnx-platform-api/sonic_platform/sfp.py

@@ -274,9 +274,11 @@ MCIA_ADDR_TX_DISABLE = 110
 MCIA_ADDR_TX_DISABLE_BIT = 6
 
 PORT_TYPE_NVE = 8
+PORT_TYPE_CPU = 4
 PORT_TYPE_OFFSET = 28
 PORT_TYPE_MASK = 0xF0000000
 NVE_MASK = PORT_TYPE_MASK & (PORT_TYPE_NVE << PORT_TYPE_OFFSET)
+CPU_MASK = PORT_TYPE_MASK & (PORT_TYPE_CPU << PORT_TYPE_OFFSET)
 
 # Global logger class instance
 logger = Logger()
@@ -1457,6 +1459,21 @@ class SFP(SfpBase):
         return tx_disabled
 
 
+    def mgmt_phy_mod_pwr_attr_get(self, power_attr_type):
+        sx_mgmt_phy_mod_pwr_attr_p = new_sx_mgmt_phy_mod_pwr_attr_t_p()
+        sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t()
+        sx_mgmt_phy_mod_pwr_attr.power_attr_type = power_attr_type
+        sx_mgmt_phy_mod_pwr_attr_t_p_assign(sx_mgmt_phy_mod_pwr_attr_p, sx_mgmt_phy_mod_pwr_attr)
+        try:
+            rc = sx_mgmt_phy_mod_pwr_attr_get(self.sdk_handle, self.sdk_index, sx_mgmt_phy_mod_pwr_attr_p)
+            assert SX_STATUS_SUCCESS == rc, "sx_mgmt_phy_mod_pwr_attr_get failed"
+            sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t_p_value(sx_mgmt_phy_mod_pwr_attr_p)
+            pwr_mode_attr = sx_mgmt_phy_mod_pwr_attr.pwr_mode_attr
+            return pwr_mode_attr.admin_pwr_mode_e, pwr_mode_attr.oper_pwr_mode_e
+        finally:
+            delete_sx_mgmt_phy_mod_pwr_attr_t_p(sx_mgmt_phy_mod_pwr_attr_p)
+
+
     def get_lpmode(self):
         """
         Retrieves the lpmode (low power mode) status of this SFP
@@ -1464,28 +1481,15 @@ class SFP(SfpBase):
         Returns:
             A Boolean, True if lpmode is enabled, False if disabled
         """
-        if self.sfp_type == QSFP_TYPE:
+        handle = self._open_sdk()
-            if self._open_sdk():
+        if handle is None:
-                # Get MCION
+            logger.log_error("SDK handler is missing for sfp %d object" % self.index)
-                mcion = ku_mcion_reg()
+            return False
-                mcion.module = self.sdk_index
-                meta = self._init_sx_meta_data()
-                meta.access_cmd = SXD_ACCESS_CMD_GET
 
-                rc = sxd_access_reg_mcion(mcion, meta, REGISTER_NUM, None, None)
+        admin_pwr_mode, oper_pwr_mode = self.mgmt_phy_mod_pwr_attr_get(SX_MGMT_PHY_MOD_PWR_ATTR_PWR_MODE_E)
-                self._close_sdk()
 
-                if rc != SXD_STATUS_SUCCESS:
+        self._close_sdk()
-                    logger.log_warning("sxd_access_reg_mcion getting failed, rc = %d" % rc)
+        return oper_pwr_mode == SX_MGMT_PHY_MOD_PWR_MODE_LOW_E
-                    return None
-
-                # Get low power mode status
-                lpm_mask = 1 << 8
-                lpm_status = (lpm_mask & mcion.module_status_bits) != 0
-
-                return lpm_status
-        else:
-            return NotImplementedError
 
 
     def get_power_override(self):
@@ -1861,64 +1865,15 @@ class SFP(SfpBase):
         """
         handle = self._open_sdk()
         if handle is None:
+            logger.log_error("SDK handler is missing for sfp %d object" % self.index)
             return False
 
-        # Get PMAOS
+        rc = sx_mgmt_phy_mod_reset(self.sdk_handle, self.sdk_index)
-        pmaos = ku_pmaos_reg()
+        if rc != SX_STATUS_SUCCESS:
-        pmaos.module = self.sdk_index
+            logger.log_warning("sx_mgmt_phy_mod_reset failed, rc = %d" % rc)
-        meta = self._init_sx_meta_data()
-        meta.access_cmd = SXD_ACCESS_CMD_GET
-
-        rc = sxd_access_reg_pmaos(pmaos, meta, REGISTER_NUM, None, None)
-        if rc != SXD_STATUS_SUCCESS:
-            logger.log_warning("sxd_access_reg_pmaos getting failed, rc = %d" % rc)
-            self._close_sdk()
-            return None
-
-        # Reset SFP
-        pmaos.rst = 1
-        meta.access_cmd = SXD_ACCESS_CMD_SET
-        rc = sxd_access_reg_pmaos(pmaos, meta, REGISTER_NUM, None, None)
-        if rc != SXD_STATUS_SUCCESS:
-            logger.log_warning("sxd_access_reg_pmaos setting failed, rc = %d" % rc)
 
         self._close_sdk()
-        return rc == SXD_STATUS_SUCCESS
+        return rc == SX_STATUS_SUCCESS
-
-
-    def _write_i2c_via_mcia(self, page, i2caddr, address, data, mask):
-        handle = self._open_sdk()
-        if handle is None:
-            return False
-
-        mcia = ku_mcia_reg()
-
-        meta = self._init_sx_meta_data()
-        meta.access_cmd = SXD_ACCESS_CMD_GET
-
-        mcia.module = self.sdk_index
-        mcia.page_number = page
-        mcia.i2c_device_address = i2caddr
-        mcia.device_address = address
-        mcia.size = 1
-        rc = sxd_access_reg_mcia(mcia, meta, REGISTER_NUM, None, None)
-        if rc != SXD_STATUS_SUCCESS:
-            logger.log_warning("sxd_access_reg_mcia getting failed, rc = %d" % rc)
-            self._close_sdk()
-            return False
-
-        original_data = (mcia.dword_0 >> 24) & 0x000000FF
-        updated_data = original_data & (~mask)
-        updated_data |= (data & mask)
-
-        mcia.dword_0 = (updated_data << 24) & 0xFF000000
-        meta.access_cmd = SXD_ACCESS_CMD_SET
-        rc = sxd_access_reg_mcia(mcia, meta, REGISTER_NUM, None, None)
-        if rc != SXD_STATUS_SUCCESS:
-            logger.log_warning("sxd_access_reg_mcia setting failed, rc = %d" % rc)
-
-        self._close_sdk()
-        return rc == SXD_STATUS_SUCCESS
 
 
     def tx_disable(self, tx_disable):
@@ -1935,34 +1890,7 @@ class SFP(SfpBase):
         for SFP, make use of bit 6 of byte at (offset 110, a2h (i2c addr 0x51)) to disable/enable tx
         for QSFP, set all channels to disable/enable tx
         """
-        if self.sfp_type == SFP_TYPE:
+        return NotImplementedError
-            if self.dom_tx_disable_supported:
-                handle = self._open_sdk()
-                if handle is None:
-                    return False
-
-                tx_disable_mask = 1 << MCIA_ADDR_TX_DISABLE_BIT
-                if tx_disable:
-                    tx_disable_bit = tx_disable_mask
-                else:
-                    tx_disable_bit = 0
-
-                return self._write_i2c_via_mcia(2, 0x51, MCIA_ADDR_TX_DISABLE, tx_disable_bit, tx_disable_mask)
-            else:
-                return False
-        elif self.sfp_type == QSFP_TYPE:
-            if self.dom_tx_disable_supported:
-                channel_mask = 0x0f
-                if tx_disable:
-                    disable_flag = channel_mask
-                else:
-                    disable_flag = 0
-
-                return self._write_i2c_via_mcia(0, 0x50, MCIA_ADDR_TX_CHANNEL_DISABLE, disable_flag, channel_mask)
-            else:
-                return False
-        else:
-            return NotImplementedError
 
 
     def tx_disable_channel(self, channel, disable):
@@ -1980,25 +1908,17 @@ class SFP(SfpBase):
 
         QSFP: page a0, address 86, lower 4 bits
         """
-        if self.sfp_type == QSFP_TYPE:
+        return NotImplementedError
-            if self.dom_tx_disable_supported:
-                channel_mask = 1 << channel
-                if disable:
-                    disable_flag = channel_mask
-                else:
-                    disable_flag = 0
-
-                return self._write_i2c_via_mcia(0, 0x50, MCIA_ADDR_TX_CHANNEL_DISABLE, disable_flag, channel_mask)
-            else:
-                return False
-        else:
-            return NotImplementedError
 
 
     def is_nve(self, port):
         return (port & NVE_MASK) != 0
 
 
+    def is_cpu(self, port):
+        return (port & CPU_MASK) != 0
+
+
     def is_port_admin_status_up(self, log_port):
         oper_state_p = new_sx_port_oper_state_t_p()
         admin_state_p = new_sx_port_admin_state_t_p()
@@ -2015,11 +1935,14 @@ class SFP(SfpBase):
 
     def set_port_admin_status_by_log_port(self, log_port, admin_status):
         rc = sx_api_port_state_set(self.sdk_handle, log_port, admin_status)
-        assert rc == SX_STATUS_SUCCESS, "sx_api_port_state_set failed, rc = %d" % rc
+        if SX_STATUS_SUCCESS != rc:
+            logger.log_error("sx_api_port_state_set failed, rc = %d" % rc)
+
+        return SX_STATUS_SUCCESS == rc
 
 
-    # Get all the ports related to the sfp, if port admin status is up, put it to list
+    def get_logical_ports(self):
-    def get_log_ports(self):
+        # Get all the ports related to the sfp, if port admin status is up, put it to list
         port_attributes_list = new_sx_port_attributes_t_arr(SX_PORT_ATTR_ARR_SIZE)
         port_cnt_p = new_uint32_t_p()
         uint32_t_p_assign(port_cnt_p, SX_PORT_ATTR_ARR_SIZE)
@@ -2031,58 +1954,56 @@ class SFP(SfpBase):
         log_port_list = []
         for i in range(0, port_cnt):
             port_attributes = sx_port_attributes_t_arr_getitem(port_attributes_list, i)
-            if self.is_nve(int(port_attributes.log_port)) == False \
+            if not self.is_nve(int(port_attributes.log_port)) \
-            and port_attributes.port_mapping.module_port == self.sdk_index \
+               and not self.is_cpu(int(port_attributes.log_port)) \
-            and self.is_port_admin_status_up(port_attributes.log_port):
+               and port_attributes.port_mapping.module_port == self.sdk_index \
+               and self.is_port_admin_status_up(port_attributes.log_port):
                 log_port_list.append(port_attributes.log_port)
 
         return log_port_list
 
 
-    def _set_sfp_admin_status_raw(self, admin_status):
+    def mgmt_phy_mod_pwr_attr_set(self, power_attr_type, admin_pwr_mode):
-        # Get PMAOS
+        result = False
-        pmaos = ku_pmaos_reg()
+        sx_mgmt_phy_mod_pwr_attr = sx_mgmt_phy_mod_pwr_attr_t()
-        pmaos.module = self.sdk_index
+        sx_mgmt_phy_mod_pwr_mode_attr = sx_mgmt_phy_mod_pwr_mode_attr_t()
-        meta = self._init_sx_meta_data()
+        sx_mgmt_phy_mod_pwr_attr.power_attr_type = power_attr_type
-        meta.access_cmd = SXD_ACCESS_CMD_GET
+        sx_mgmt_phy_mod_pwr_mode_attr.admin_pwr_mode_e = admin_pwr_mode
-        rc = sxd_access_reg_pmaos(pmaos, meta, REGISTER_NUM, None, None)
+        sx_mgmt_phy_mod_pwr_attr.pwr_mode_attr = sx_mgmt_phy_mod_pwr_mode_attr
-        assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmaos failed, rc = %d" % rc
+        sx_mgmt_phy_mod_pwr_attr_p = new_sx_mgmt_phy_mod_pwr_attr_t_p()
+        sx_mgmt_phy_mod_pwr_attr_t_p_assign(sx_mgmt_phy_mod_pwr_attr_p, sx_mgmt_phy_mod_pwr_attr)
+        try:
+            rc = sx_mgmt_phy_mod_pwr_attr_set(self.sdk_handle, SX_ACCESS_CMD_SET, self.sdk_index, sx_mgmt_phy_mod_pwr_attr_p)
+            if SX_STATUS_SUCCESS != rc:
+                logger.log_error("sx_mgmt_phy_mod_pwr_attr_set failed, rc = %d" % rc)
+                result = False
+            else:
+                result = True
+        finally:
+            delete_sx_mgmt_phy_mod_pwr_attr_t_p(sx_mgmt_phy_mod_pwr_attr_p)
 
-        # Set admin status to PMAOS
+        return result
-        pmaos.ase = PMAOS_ASE
-        pmaos.ee = PMAOS_EE
-        pmaos.e = PMAOS_E
-        pmaos.rst = PMAOS_RST
-        if admin_status == SX_PORT_ADMIN_STATUS_DOWN:
-            pmaos.admin_status = PMAOS_DISABLE
-        else:
-            pmaos.admin_status = PMAOS_ENABLE
-
-        meta.access_cmd = SXD_ACCESS_CMD_SET
-        rc = sxd_access_reg_pmaos(pmaos, meta, REGISTER_NUM, None, None)
-        assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmaos failed, rc = %d" % rc
 
 
-    def _set_lpmode_raw(self, lpmode):
+    def _set_lpmode_raw(self, ports, attr_type, power_mode):
-        # Get PMMP
+        result = False
-        pmmp = ku_pmmp_reg()
+        # Check if the module already works in the same mode
-        pmmp.module = self.sdk_index
+        admin_pwr_mode, oper_pwr_mode = self.mgmt_phy_mod_pwr_attr_get(attr_type)
-        meta = self._init_sx_meta_data()
+        if (power_mode == SX_MGMT_PHY_MOD_PWR_MODE_LOW_E and oper_pwr_mode == SX_MGMT_PHY_MOD_PWR_MODE_LOW_E) \
-        meta.access_cmd = SXD_ACCESS_CMD_GET
+           or (power_mode == SX_MGMT_PHY_MOD_PWR_MODE_AUTO_E and admin_pwr_mode == SX_MGMT_PHY_MOD_PWR_MODE_AUTO_E):
-        rc = sxd_access_reg_pmmp(pmmp, meta, REGISTER_NUM, None, None)
+            return True
-        assert rc == SXD_STATUS_SUCCESS, "sxd_access_reg_pmmp failed, rc = %d" % rc
+        try:
+            # Bring the port down
+            for port in ports:
+                self.set_port_admin_status_by_log_port(port, SX_PORT_ADMIN_STATUS_DOWN)
+            # Set the desired power mode
+            result = self.mgmt_phy_mod_pwr_attr_set(attr_type, power_mode)
+        finally:
+            # Bring the port up
+            for port in ports:
+                self.set_port_admin_status_by_log_port(port, SX_PORT_ADMIN_STATUS_UP)
 
-        # Set low power mode status
+        return result
-        lpm_mask = 1 << PMMP_LPMODE_BIT
-        if lpmode:
-            pmmp.eeprom_override = pmmp.eeprom_override | lpm_mask
-        else:
-            pmmp.eeprom_override = pmmp.eeprom_override & (~lpm_mask)
-
-        meta.access_cmd = SXD_ACCESS_CMD_SET
-        rc = sxd_access_reg_pmmp(pmmp, meta, REGISTER_NUM, None, None)
-
-        return rc
 
 
     def set_lpmode(self, lpmode):
@@ -2098,24 +2019,18 @@ class SFP(SfpBase):
         """
         handle = self._open_sdk()
         if handle is None:
+            logger.log_error("SDK handler is missing for sfp %d object" % self.index)
             return False
-        try:
-            log_port_list = self.get_log_ports()
-            for log_port in log_port_list:
-                self.set_port_admin_status_by_log_port(log_port, SX_PORT_ADMIN_STATUS_DOWN)
-            self._set_sfp_admin_status_raw(SX_PORT_ADMIN_STATUS_DOWN)
 
-            result = self._set_lpmode_raw(lpmode)
+        log_port_list = self.get_logical_ports()
-
+        if lpmode:
-            self._set_sfp_admin_status_raw(SX_PORT_ADMIN_STATUS_UP)
+            self._set_lpmode_raw(log_port_list, SX_MGMT_PHY_MOD_PWR_ATTR_PWR_MODE_E, SX_MGMT_PHY_MOD_PWR_MODE_LOW_E)
-            for log_port in log_port_list:
+            logger.log_info("Enabled low power mode for module [%d]" % (self.sdk_index))
-                self.set_port_admin_status_by_log_port(log_port, SX_PORT_ADMIN_STATUS_DOWN)
+        else:
-
+            self._set_lpmode_raw(log_port_list, SX_MGMT_PHY_MOD_PWR_ATTR_PWR_MODE_E, SX_MGMT_PHY_MOD_PWR_MODE_AUTO_E)
-            return result == SXD_STATUS_SUCCESS
+            logger.log_info( "Disabled low power mode for module [%d]" % (self.sdk_index))
-        except:
+        self._close_sdk()
-            logger.log_warning("set_lpmode failed due to some SDK failure")
+        return True
-            self._close_sdk()
-            return False
 
 
     def set_power_override(self, power_override, power_set):
@@ -2137,15 +2052,4 @@ class SFP(SfpBase):
             A boolean, True if power-override and power_set are set successfully,
             False if not
         """
-        if self.sfp_type == QSFP_TYPE:
+        return NotImplementedError
-            power_override_bit = 0
-            if power_override:
-                power_override_bit |= 1 << MCIA_ADDR_POWER_OVERRIDE_POR_BIT
-            power_set_bit = 0
-            if power_set:
-                power_set_bit |= 1 << MCIA_ADDR_POWER_OVERRIDE_PS_BIT
-            power_override_mask = 1 << MCIA_ADDR_POWER_OVERRIDE_PS_BIT | 1 << MCIA_ADDR_POWER_OVERRIDE_POR_BIT
-
-            return self._write_i2c_via_mcia(0, 0x50, MCIA_ADDR_POWER_OVERRIDE, power_set_bit|power_override_bit, power_override_mask)
-        else:
-            return NotImplementedError