Support SAI_PORT_SERDES_ATTR_CUSTOM_COLLECTION (#3764)

longhuan-cisco · web-flow · commit a2decc5a692e · 2025-11-26T15:09:39.000-08:00
sonic-platform-daemon side change: sonic-net/sonic-platform-daemons#643 What I did Support SAI_PORT_SERDES_ATTR_CUSTOM_COLLECTION (i.e. custom serdes attributes represented in JSON based string format) Use boost::variant￼ for the serdes_attr map value to support both std::vector<uint32_t> and std::string in a type-safe way, with easy extensibility to add more types later.
diff --git a/orchagent/port.h b/orchagent/port.h
@@ -14,6 +14,7 @@ extern "C" {
 #include <unordered_set>
 #include <iomanip>
 #include <sstream>
+#include <boost/variant.hpp>
 #include <macaddress.h>
 #include <sairedis.h>
 
@@ -33,6 +34,28 @@ extern "C" {
 
 #define VNID_NONE               0xFFFFFFFF
 
+// SerdesValue using boost::variant to support both vector<uint32_t> and string values
+using SerdesValue = boost::variant<std::vector<uint32_t>, std::string>;
+
+// Visitor class for processing SerdesValue in SAI attribute setting
+class SerdesValueVisitor : public boost::static_visitor<void> {
+public:
+    explicit SerdesValueVisitor(sai_attribute_t& attr) : attr_(attr) {}
+
+    void operator()(const std::vector<uint32_t>& values) const {
+        attr_.value.u32list.count = static_cast<uint32_t>(values.size());
+        attr_.value.u32list.list = const_cast<uint32_t*>(values.data());
+    }
+
+    void operator()(const std::string& str_value) const {
+        attr_.value.json.json.count = static_cast<uint32_t>(str_value.size());
+        attr_.value.json.json.list = reinterpret_cast<int8_t*>(const_cast<char*>(str_value.data()));
+    }
+
+private:
+    sai_attribute_t& attr_;
+};
+
 namespace swss {
 
 struct VlanMemberEntry
@@ -240,8 +263,8 @@ class Port
     /* Port oper error status to event map*/
     std::unordered_map<sai_port_error_status_t, PortOperErrorEvent> m_portOperErrorToEvent;
 
-    /* pre-emphasis */
-    std::map<sai_port_serdes_attr_t, std::vector<uint32_t>> m_preemphasis;
+    /* serdes attributes */
+    std::map<sai_port_serdes_attr_t, SerdesValue> m_serdes_attrs;
 
     /* Force initial parameter configuration flags */
     bool m_an_cfg = false;        // Auto-negotiation (AN)
diff --git a/orchagent/port/portcnt.h b/orchagent/port/portcnt.h
@@ -190,6 +190,11 @@ class PortConfig final
             bool is_set = false;
         } unreliable_los; // Port unreliable_los
 
+        struct {
+            std::string value;
+            bool is_set = false;
+        } custom_collection; // Port serdes custom_collection
+
     } serdes; // Port serdes
 
     struct {
diff --git a/orchagent/port/porthlpr.cpp b/orchagent/port/porthlpr.cpp
@@ -708,6 +708,25 @@ bool PortHelper::parsePortSerdes(T &serdes, const std::string &field, const std:
         return false;
     }
 
+    // Use SFINAE with enable_if for extensible type handling for serdes.value
+    return parseSerdesValueImpl(serdes, field, value);
+}
+
+// Helper function for JSON string-based serdes (custom_collection)
+template<typename T>
+typename std::enable_if<std::is_same<decltype(T::value), std::string>::value, bool>::type
+PortHelper::parseSerdesValueImpl(T &serdes, const std::string &field, const std::string &value) const
+{
+    serdes.value = value;
+    serdes.is_set = true;
+    return true;
+}
+
+// Helper function for vector<uint32_t>-based serdes (most serdes attributes)
+template<typename T>
+typename std::enable_if<std::is_same<decltype(T::value), std::vector<std::uint32_t>>::value, bool>::type
+PortHelper::parseSerdesValueImpl(T &serdes, const std::string &field, const std::string &value) const
+{
     const auto &serdesList = tokenize(value, ',');
 
     try
@@ -745,6 +764,7 @@ template bool PortHelper::parsePortSerdes(decltype(PortSerdes_t::obplev) &serdes
 template bool PortHelper::parsePortSerdes(decltype(PortSerdes_t::obnlev) &serdes, const std::string &field, const std::string &value) const;
 template bool PortHelper::parsePortSerdes(decltype(PortSerdes_t::regn_bfm1p) &serdes, const std::string &field, const std::string &value) const;
 template bool PortHelper::parsePortSerdes(decltype(PortSerdes_t::regn_bfm1n) &serdes, const std::string &field, const std::string &value) const;
+template bool PortHelper::parsePortSerdes(decltype(PortSerdes_t::custom_collection) &serdes, const std::string &field, const std::string &value) const;
 
 
 
@@ -1182,6 +1202,13 @@ bool PortHelper::parsePortConfig(PortConfig &port) const
                 return false;
             }
         }
+        else if (field == PORT_CUSTOM_SERDES_ATTRS)
+        {
+            if (!this->parsePortSerdes(port.serdes.custom_collection, field, value))
+            {
+                return false;
+            }
+        }
         else if (field == PORT_ROLE)
         {
             if (!this->parsePortRole(port, field, value))
diff --git a/orchagent/port/porthlpr.h b/orchagent/port/porthlpr.h
@@ -39,6 +39,14 @@ class PortHelper final
     template<typename T>
     bool parsePortSerdes(T &serdes, const std::string &field, const std::string &value) const;
 
+    template<typename T>
+    typename std::enable_if<std::is_same<decltype(T::value), std::string>::value, bool>::type
+    parseSerdesValueImpl(T &serdes, const std::string &field, const std::string &value) const;
+
+    template<typename T>
+    typename std::enable_if<std::is_same<decltype(T::value), std::vector<std::uint32_t>>::value, bool>::type
+    parseSerdesValueImpl(T &serdes, const std::string &field, const std::string &value) const;
+
     bool parsePortLinkEventDampingAlgorithm(PortConfig &port, const std::string &field, const std::string &value) const;
     template<typename T>
     bool parsePortLinkEventDampingConfig(T &damping_config_attr, const std::string &field, const std::string &value) const;
diff --git a/orchagent/port/portschema.h b/orchagent/port/portschema.h
@@ -89,6 +89,7 @@
 #define PORT_OBNLEV                "obnlev"
 #define PORT_REGN_BFM1P            "regn_bfm1p"
 #define PORT_REGN_BFM1N            "regn_bfm1n"
+#define PORT_CUSTOM_SERDES_ATTRS   "custom_serdes_attrs"
 #define PORT_ROLE                  "role"
 #define PORT_ADMIN_STATUS          "admin_status"
 #define PORT_DESCRIPTION           "description"
diff --git a/orchagent/portsorch.cpp b/orchagent/portsorch.cpp
@@ -97,7 +97,7 @@ struct PortAttrValue
 };
 
 typedef PortAttrValue PortAttrValue_t;
-typedef std::map<sai_port_serdes_attr_t, std::vector<std::uint32_t>> PortSerdesAttrMap_t;
+typedef std::map<sai_port_serdes_attr_t, SerdesValue> PortSerdesAttrMap_t;
 
 struct PortBulker
 {
@@ -436,90 +436,93 @@ static void getPortSerdesAttr(PortSerdesAttrMap_t &map, const PortConfig &port)
 {
     if (port.serdes.preemphasis.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_PREEMPHASIS] = port.serdes.preemphasis.value;
+        map[SAI_PORT_SERDES_ATTR_PREEMPHASIS] = SerdesValue(port.serdes.preemphasis.value);
     }
 
     if (port.serdes.idriver.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_IDRIVER] = port.serdes.idriver.value;
+        map[SAI_PORT_SERDES_ATTR_IDRIVER] = SerdesValue(port.serdes.idriver.value);
     }
 
     if (port.serdes.ipredriver.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_IPREDRIVER] = port.serdes.ipredriver.value;
+        map[SAI_PORT_SERDES_ATTR_IPREDRIVER] = SerdesValue(port.serdes.ipredriver.value);
     }
 
     if (port.serdes.pre1.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE1] = port.serdes.pre1.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE1] = SerdesValue(port.serdes.pre1.value);
     }
 
     if (port.serdes.pre2.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE2] = port.serdes.pre2.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE2] = SerdesValue(port.serdes.pre2.value);
     }
 
     if (port.serdes.pre3.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE3] = port.serdes.pre3.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE3] = SerdesValue(port.serdes.pre3.value);
     }
 
     if (port.serdes.main.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_MAIN] = port.serdes.main.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_MAIN] = SerdesValue(port.serdes.main.value);
     }
 
     if (port.serdes.post1.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_POST1] = port.serdes.post1.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_POST1] = SerdesValue(port.serdes.post1.value);
     }
 
     if (port.serdes.post2.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_POST2] = port.serdes.post2.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_POST2] = SerdesValue(port.serdes.post2.value);
     }
 
     if (port.serdes.post3.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_POST3] = port.serdes.post3.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_POST3] = SerdesValue(port.serdes.post3.value);
     }
 
     if (port.serdes.attn.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_FIR_ATTN] = port.serdes.attn.value;
+        map[SAI_PORT_SERDES_ATTR_TX_FIR_ATTN] = SerdesValue(port.serdes.attn.value);
     }
 
     if (port.serdes.ob_m2lp.is_set)
     {
-
-        map[SAI_PORT_SERDES_ATTR_TX_PAM4_RATIO] = port.serdes.ob_m2lp.value;
+        map[SAI_PORT_SERDES_ATTR_TX_PAM4_RATIO] = SerdesValue(port.serdes.ob_m2lp.value);
     }
 
     if (port.serdes.ob_alev_out.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_OUT_COMMON_MODE] = port.serdes.ob_alev_out.value;
+        map[SAI_PORT_SERDES_ATTR_TX_OUT_COMMON_MODE] = SerdesValue(port.serdes.ob_alev_out.value);
     }
 
     if (port.serdes.obplev.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_PMOS_COMMON_MODE] = port.serdes.obplev.value;
+        map[SAI_PORT_SERDES_ATTR_TX_PMOS_COMMON_MODE] = SerdesValue(port.serdes.obplev.value);
     }
 
     if (port.serdes.obnlev.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_NMOS_COMMON_MODE] = port.serdes.obnlev.value;
+        map[SAI_PORT_SERDES_ATTR_TX_NMOS_COMMON_MODE] = SerdesValue(port.serdes.obnlev.value);
     }
 
     if (port.serdes.regn_bfm1p.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_PMOS_VLTG_REG] = port.serdes.regn_bfm1p.value;
+        map[SAI_PORT_SERDES_ATTR_TX_PMOS_VLTG_REG] = SerdesValue(port.serdes.regn_bfm1p.value);
     }
 
     if (port.serdes.regn_bfm1n.is_set)
     {
-        map[SAI_PORT_SERDES_ATTR_TX_NMOS_VLTG_REG] = port.serdes.regn_bfm1n.value;
+        map[SAI_PORT_SERDES_ATTR_TX_NMOS_VLTG_REG] = SerdesValue(port.serdes.regn_bfm1n.value);
     }
 
+    if (port.serdes.custom_collection.is_set)
+    {
+        map[SAI_PORT_SERDES_ATTR_CUSTOM_COLLECTION] = SerdesValue(port.serdes.custom_collection.value);
+    }
 
 }
 
@@ -4600,10 +4603,10 @@ void PortsOrch::doPortTask(Consumer &consumer)
                         m_portList[p.m_alias] = p;
                         updatePortStatePoll(p, PORT_STATE_POLL_LT, pCfg.link_training.value);
 
-                        // Restore pre-emphasis when LT is transitioned from ON to OFF
+                        // Restore serdes attributes when LT is transitioned from ON to OFF
                         if (!p.m_link_training && serdes_attr.empty())
                         {
-                            serdes_attr = p.m_preemphasis;
+                            serdes_attr = p.m_serdes_attrs;
                         }
 
                         SWSS_LOG_NOTICE(
@@ -5120,8 +5123,8 @@ void PortsOrch::doPortTask(Consumer &consumer)
                 {
                     if (p.m_link_training)
                     {
-                        SWSS_LOG_NOTICE("Save port %s preemphasis for LT", p.m_alias.c_str());
-                        p.m_preemphasis = serdes_attr;
+                        SWSS_LOG_NOTICE("Save port %s serdes attributes for LT", p.m_alias.c_str());
+                        p.m_serdes_attrs = serdes_attr;
                         m_portList[p.m_alias] = p;
                     }
                     else
@@ -5143,7 +5146,7 @@ void PortsOrch::doPortTask(Consumer &consumer)
                         if (setPortSerdesAttribute(p.m_port_id, gSwitchId, serdes_attr))
                         {
                             SWSS_LOG_NOTICE("Set port %s SI settings is successful", p.m_alias.c_str());
-                            p.m_preemphasis = serdes_attr;
+                            p.m_serdes_attrs = serdes_attr;
                             m_portList[p.m_alias] = p;
                         }
                         else
@@ -9424,7 +9427,7 @@ bool PortsOrch::removeAclTableGroup(const Port &p)
 }
 
 bool PortsOrch::setPortSerdesAttribute(sai_object_id_t port_id, sai_object_id_t switch_id,
-                                       map<sai_port_serdes_attr_t, vector<uint32_t>> &serdes_attr)
+                                       map<sai_port_serdes_attr_t, SerdesValue> &serdes_attr)
 {
     SWSS_LOG_ENTER();
 
@@ -9471,12 +9474,15 @@ bool PortsOrch::setPortSerdesAttribute(sai_object_id_t port_id, sai_object_id_t
     for (auto it = serdes_attr.begin(); it != serdes_attr.end(); it++)
     {
         port_serdes_attr.id = it->first;
-        port_serdes_attr.value.u32list.count = (uint32_t)it->second.size();
-        port_serdes_attr.value.u32list.list = it->second.data();
+
+        // Use boost::variant visitor to handle both vector and string types
+        boost::apply_visitor(SerdesValueVisitor(port_serdes_attr), it->second);
+
         attr_list.emplace_back(port_serdes_attr);
     }
+    assert(serdes_attr.size() + 1 == attr_list.size());
     status = sai_port_api->create_port_serdes(&port_serdes_id, switch_id,
-                                              static_cast<uint32_t>(serdes_attr.size()+1),
+                                              static_cast<uint32_t>(attr_list.size()),
                                               attr_list.data());
 
     if (status != SAI_STATUS_SUCCESS)
@@ -9876,8 +9882,8 @@ bool PortsOrch::initGearboxPort(Port &port)
             m_gbcounterTable->set("", fields);
 
             /* Set serdes tx taps on system and line side */
-            map<sai_port_serdes_attr_t, vector<uint32_t>> serdes_attr;
-            typedef pair<sai_port_serdes_attr_t, vector<uint32_t>> serdes_attr_pair;
+            map<sai_port_serdes_attr_t, SerdesValue> serdes_attr;
+            typedef pair<sai_port_serdes_attr_t, SerdesValue> serdes_attr_pair;
             vector<uint32_t> attr_val;
             for (auto pair: tx_fir_strings_system_side) {
                 if (m_gearboxInterfaceMap[port.m_index].tx_firs.find(pair.first) != m_gearboxInterfaceMap[port.m_index].tx_firs.end() ) {
@@ -9890,11 +9896,11 @@ bool PortsOrch::initGearboxPort(Port &port)
             {
                 if (setPortSerdesAttribute(systemPort, phyOid, serdes_attr))
                 {
-                    SWSS_LOG_NOTICE("Set port %s system side preemphasis is success", port.m_alias.c_str());
+                    SWSS_LOG_NOTICE("Set port %s system side serdes attributes is success", port.m_alias.c_str());
                 }
                 else
                 {
-                    SWSS_LOG_ERROR("Failed to set port %s system side pre-emphasis", port.m_alias.c_str());
+                    SWSS_LOG_ERROR("Failed to set port %s system side serdes attributes", port.m_alias.c_str());
                     return false;
                 }
             }
@@ -9910,11 +9916,11 @@ bool PortsOrch::initGearboxPort(Port &port)
             {
                 if (setPortSerdesAttribute(linePort, phyOid, serdes_attr))
                 {
-                    SWSS_LOG_NOTICE("Set port %s line side preemphasis is success", port.m_alias.c_str());
+                    SWSS_LOG_NOTICE("Set port %s line side serdes attributes is success", port.m_alias.c_str());
                 }
                 else
                 {
-                    SWSS_LOG_ERROR("Failed to set port %s line side pre-emphasis", port.m_alias.c_str());
+                    SWSS_LOG_ERROR("Failed to set port %s line side serdes attributes", port.m_alias.c_str());
                     return false;
                 }
             }
diff --git a/orchagent/portsorch.h b/orchagent/portsorch.h
@@ -525,8 +525,7 @@ class PortsOrch : public Orch, public Subject
 
     void getPortSerdesVal(const std::string& s, std::vector<uint32_t> &lane_values, int base = 16);
     bool setPortSerdesAttribute(sai_object_id_t port_id, sai_object_id_t switch_id,
-                                std::map<sai_port_serdes_attr_t, std::vector<uint32_t>> &serdes_attr);
-
+                                std::map<sai_port_serdes_attr_t, SerdesValue> &serdes_attr);
 
     void removePortSerdesAttribute(sai_object_id_t port_id);
 
diff --git a/tests/mock_tests/portsorch_ut.cpp b/tests/mock_tests/portsorch_ut.cpp

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ struct PortAttrValue`
`97`	`97`	`};`
`98`	`98`
`99`	`99`	`typedef PortAttrValue PortAttrValue_t;`
`100`		`-typedef std::map<sai_port_serdes_attr_t, std::vector<std::uint32_t>> PortSerdesAttrMap_t;`
	`100`	`+typedef std::map<sai_port_serdes_attr_t, SerdesValue> PortSerdesAttrMap_t;`
`101`	`101`
`102`	`102`	`struct PortBulker`
`103`	`103`	`{`
`@@ -436,90 +436,93 @@ static void getPortSerdesAttr(PortSerdesAttrMap_t &map, const PortConfig &port)`
`436`	`436`	`{`
`437`	`437`	`if (port.serdes.preemphasis.is_set)`
`438`	`438`	`{`
`439`		`- map[SAI_PORT_SERDES_ATTR_PREEMPHASIS] = port.serdes.preemphasis.value;`
	`439`	`+ map[SAI_PORT_SERDES_ATTR_PREEMPHASIS] = SerdesValue(port.serdes.preemphasis.value);`
`440`	`440`	`}`
`441`	`441`
`442`	`442`	`if (port.serdes.idriver.is_set)`
`443`	`443`	`{`
`444`		`- map[SAI_PORT_SERDES_ATTR_IDRIVER] = port.serdes.idriver.value;`
	`444`	`+ map[SAI_PORT_SERDES_ATTR_IDRIVER] = SerdesValue(port.serdes.idriver.value);`
`445`	`445`	`}`
`446`	`446`
`447`	`447`	`if (port.serdes.ipredriver.is_set)`
`448`	`448`	`{`
`449`		`- map[SAI_PORT_SERDES_ATTR_IPREDRIVER] = port.serdes.ipredriver.value;`
	`449`	`+ map[SAI_PORT_SERDES_ATTR_IPREDRIVER] = SerdesValue(port.serdes.ipredriver.value);`
`450`	`450`	`}`
`451`	`451`
`452`	`452`	`if (port.serdes.pre1.is_set)`
`453`	`453`	`{`
`454`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE1] = port.serdes.pre1.value;`
	`454`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE1] = SerdesValue(port.serdes.pre1.value);`
`455`	`455`	`}`
`456`	`456`
`457`	`457`	`if (port.serdes.pre2.is_set)`
`458`	`458`	`{`
`459`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE2] = port.serdes.pre2.value;`
	`459`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE2] = SerdesValue(port.serdes.pre2.value);`
`460`	`460`	`}`
`461`	`461`
`462`	`462`	`if (port.serdes.pre3.is_set)`
`463`	`463`	`{`
`464`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE3] = port.serdes.pre3.value;`
	`464`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_PRE3] = SerdesValue(port.serdes.pre3.value);`
`465`	`465`	`}`
`466`	`466`
`467`	`467`	`if (port.serdes.main.is_set)`
`468`	`468`	`{`
`469`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_MAIN] = port.serdes.main.value;`
	`469`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_MAIN] = SerdesValue(port.serdes.main.value);`
`470`	`470`	`}`
`471`	`471`
`472`	`472`	`if (port.serdes.post1.is_set)`
`473`	`473`	`{`
`474`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_POST1] = port.serdes.post1.value;`
	`474`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_POST1] = SerdesValue(port.serdes.post1.value);`
`475`	`475`	`}`
`476`	`476`
`477`	`477`	`if (port.serdes.post2.is_set)`
`478`	`478`	`{`
`479`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_POST2] = port.serdes.post2.value;`
	`479`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_POST2] = SerdesValue(port.serdes.post2.value);`
`480`	`480`	`}`
`481`	`481`
`482`	`482`	`if (port.serdes.post3.is_set)`
`483`	`483`	`{`
`484`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_POST3] = port.serdes.post3.value;`
	`484`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_POST3] = SerdesValue(port.serdes.post3.value);`
`485`	`485`	`}`
`486`	`486`
`487`	`487`	`if (port.serdes.attn.is_set)`
`488`	`488`	`{`
`489`		`- map[SAI_PORT_SERDES_ATTR_TX_FIR_ATTN] = port.serdes.attn.value;`
	`489`	`+ map[SAI_PORT_SERDES_ATTR_TX_FIR_ATTN] = SerdesValue(port.serdes.attn.value);`
`490`	`490`	`}`
`491`	`491`
`492`	`492`	`if (port.serdes.ob_m2lp.is_set)`
`493`	`493`	`{`
`494`		`-`
`495`		`- map[SAI_PORT_SERDES_ATTR_TX_PAM4_RATIO] = port.serdes.ob_m2lp.value;`
	`494`	`+ map[SAI_PORT_SERDES_ATTR_TX_PAM4_RATIO] = SerdesValue(port.serdes.ob_m2lp.value);`
`496`	`495`	`}`
`497`	`496`
`498`	`497`	`if (port.serdes.ob_alev_out.is_set)`
`499`	`498`	`{`
`500`		`- map[SAI_PORT_SERDES_ATTR_TX_OUT_COMMON_MODE] = port.serdes.ob_alev_out.value;`
	`499`	`+ map[SAI_PORT_SERDES_ATTR_TX_OUT_COMMON_MODE] = SerdesValue(port.serdes.ob_alev_out.value);`
`501`	`500`	`}`
`502`	`501`
`503`	`502`	`if (port.serdes.obplev.is_set)`
`504`	`503`	`{`
`505`		`- map[SAI_PORT_SERDES_ATTR_TX_PMOS_COMMON_MODE] = port.serdes.obplev.value;`
	`504`	`+ map[SAI_PORT_SERDES_ATTR_TX_PMOS_COMMON_MODE] = SerdesValue(port.serdes.obplev.value);`
`506`	`505`	`}`
`507`	`506`
`508`	`507`	`if (port.serdes.obnlev.is_set)`
`509`	`508`	`{`
`510`		`- map[SAI_PORT_SERDES_ATTR_TX_NMOS_COMMON_MODE] = port.serdes.obnlev.value;`
	`509`	`+ map[SAI_PORT_SERDES_ATTR_TX_NMOS_COMMON_MODE] = SerdesValue(port.serdes.obnlev.value);`
`511`	`510`	`}`
`512`	`511`
`513`	`512`	`if (port.serdes.regn_bfm1p.is_set)`
`514`	`513`	`{`
`515`		`- map[SAI_PORT_SERDES_ATTR_TX_PMOS_VLTG_REG] = port.serdes.regn_bfm1p.value;`
	`514`	`+ map[SAI_PORT_SERDES_ATTR_TX_PMOS_VLTG_REG] = SerdesValue(port.serdes.regn_bfm1p.value);`
`516`	`515`	`}`
`517`	`516`
`518`	`517`	`if (port.serdes.regn_bfm1n.is_set)`
`519`	`518`	`{`
`520`		`- map[SAI_PORT_SERDES_ATTR_TX_NMOS_VLTG_REG] = port.serdes.regn_bfm1n.value;`
	`519`	`+ map[SAI_PORT_SERDES_ATTR_TX_NMOS_VLTG_REG] = SerdesValue(port.serdes.regn_bfm1n.value);`
`521`	`520`	`}`
`522`	`521`
	`522`	`+ if (port.serdes.custom_collection.is_set)`
	`523`	`+ {`
	`524`	`+ map[SAI_PORT_SERDES_ATTR_CUSTOM_COLLECTION] = SerdesValue(port.serdes.custom_collection.value);`
	`525`	`+ }`
`523`	`526`
`524`	`527`	`}`
`525`	`528`
`@@ -4600,10 +4603,10 @@ void PortsOrch::doPortTask(Consumer &consumer)`
`4600`	`4603`	`m_portList[p.m_alias] = p;`
`4601`	`4604`	`updatePortStatePoll(p, PORT_STATE_POLL_LT, pCfg.link_training.value);`
`4602`	`4605`
`4603`		`- // Restore pre-emphasis when LT is transitioned from ON to OFF`
	`4606`	`+ // Restore serdes attributes when LT is transitioned from ON to OFF`
`4604`	`4607`	`if (!p.m_link_training && serdes_attr.empty())`
`4605`	`4608`	`{`
`4606`		`- serdes_attr = p.m_preemphasis;`
	`4609`	`+ serdes_attr = p.m_serdes_attrs;`
`4607`	`4610`	`}`
`4608`	`4611`
`4609`	`4612`	`SWSS_LOG_NOTICE(`
`@@ -5120,8 +5123,8 @@ void PortsOrch::doPortTask(Consumer &consumer)`
`5120`	`5123`	`{`
`5121`	`5124`	`if (p.m_link_training)`
`5122`	`5125`	`{`
`5123`		`- SWSS_LOG_NOTICE("Save port %s preemphasis for LT", p.m_alias.c_str());`
`5124`		`- p.m_preemphasis = serdes_attr;`
	`5126`	`+ SWSS_LOG_NOTICE("Save port %s serdes attributes for LT", p.m_alias.c_str());`
	`5127`	`+ p.m_serdes_attrs = serdes_attr;`
`5125`	`5128`	`m_portList[p.m_alias] = p;`
`5126`	`5129`	`}`
`5127`	`5130`	`else`
`@@ -5143,7 +5146,7 @@ void PortsOrch::doPortTask(Consumer &consumer)`
`5143`	`5146`	`if (setPortSerdesAttribute(p.m_port_id, gSwitchId, serdes_attr))`
`5144`	`5147`	`{`
`5145`	`5148`	`SWSS_LOG_NOTICE("Set port %s SI settings is successful", p.m_alias.c_str());`
`5146`		`- p.m_preemphasis = serdes_attr;`
	`5149`	`+ p.m_serdes_attrs = serdes_attr;`
`5147`	`5150`	`m_portList[p.m_alias] = p;`
`5148`	`5151`	`}`
`5149`	`5152`	`else`
`@@ -9424,7 +9427,7 @@ bool PortsOrch::removeAclTableGroup(const Port &p)`
`9424`	`9427`	`}`
`9425`	`9428`
`9426`	`9429`	`bool PortsOrch::setPortSerdesAttribute(sai_object_id_t port_id, sai_object_id_t switch_id,`
`9427`		`- map<sai_port_serdes_attr_t, vector<uint32_t>> &serdes_attr)`
	`9430`	`+ map<sai_port_serdes_attr_t, SerdesValue> &serdes_attr)`
`9428`	`9431`	`{`
`9429`	`9432`	`SWSS_LOG_ENTER();`
`9430`	`9433`
`@@ -9471,12 +9474,15 @@ bool PortsOrch::setPortSerdesAttribute(sai_object_id_t port_id, sai_object_id_t`
`9471`	`9474`	`for (auto it = serdes_attr.begin(); it != serdes_attr.end(); it++)`
`9472`	`9475`	`{`
`9473`	`9476`	`port_serdes_attr.id = it->first;`
`9474`		`- port_serdes_attr.value.u32list.count = (uint32_t)it->second.size();`
`9475`		`- port_serdes_attr.value.u32list.list = it->second.data();`
	`9477`	`+`
	`9478`	`+ // Use boost::variant visitor to handle both vector and string types`
	`9479`	`+ boost::apply_visitor(SerdesValueVisitor(port_serdes_attr), it->second);`
	`9480`	`+`
`9476`	`9481`	`attr_list.emplace_back(port_serdes_attr);`
`9477`	`9482`	`}`
	`9483`	`+ assert(serdes_attr.size() + 1 == attr_list.size());`
`9478`	`9484`	`status = sai_port_api->create_port_serdes(&port_serdes_id, switch_id,`
`9479`		`- static_cast<uint32_t>(serdes_attr.size()+1),`
	`9485`	`+ static_cast<uint32_t>(attr_list.size()),`
`9480`	`9486`	`attr_list.data());`
`9481`	`9487`
`9482`	`9488`	`if (status != SAI_STATUS_SUCCESS)`
`@@ -9876,8 +9882,8 @@ bool PortsOrch::initGearboxPort(Port &port)`
`9876`	`9882`	`m_gbcounterTable->set("", fields);`
`9877`	`9883`
`9878`	`9884`	`/* Set serdes tx taps on system and line side */`
`9879`		`- map<sai_port_serdes_attr_t, vector<uint32_t>> serdes_attr;`
`9880`		`- typedef pair<sai_port_serdes_attr_t, vector<uint32_t>> serdes_attr_pair;`
	`9885`	`+ map<sai_port_serdes_attr_t, SerdesValue> serdes_attr;`
	`9886`	`+ typedef pair<sai_port_serdes_attr_t, SerdesValue> serdes_attr_pair;`
`9881`	`9887`	`vector<uint32_t> attr_val;`
`9882`	`9888`	`for (auto pair: tx_fir_strings_system_side) {`
`9883`	`9889`	`if (m_gearboxInterfaceMap[port.m_index].tx_firs.find(pair.first) != m_gearboxInterfaceMap[port.m_index].tx_firs.end() ) {`
`@@ -9890,11 +9896,11 @@ bool PortsOrch::initGearboxPort(Port &port)`
`9890`	`9896`	`{`
`9891`	`9897`	`if (setPortSerdesAttribute(systemPort, phyOid, serdes_attr))`
`9892`	`9898`	`{`
`9893`		`- SWSS_LOG_NOTICE("Set port %s system side preemphasis is success", port.m_alias.c_str());`
	`9899`	`+ SWSS_LOG_NOTICE("Set port %s system side serdes attributes is success", port.m_alias.c_str());`
`9894`	`9900`	`}`
`9895`	`9901`	`else`
`9896`	`9902`	`{`
`9897`		`- SWSS_LOG_ERROR("Failed to set port %s system side pre-emphasis", port.m_alias.c_str());`
	`9903`	`+ SWSS_LOG_ERROR("Failed to set port %s system side serdes attributes", port.m_alias.c_str());`
`9898`	`9904`	`return false;`
`9899`	`9905`	`}`
`9900`	`9906`	`}`
`@@ -9910,11 +9916,11 @@ bool PortsOrch::initGearboxPort(Port &port)`
`9910`	`9916`	`{`
`9911`	`9917`	`if (setPortSerdesAttribute(linePort, phyOid, serdes_attr))`
`9912`	`9918`	`{`
`9913`		`- SWSS_LOG_NOTICE("Set port %s line side preemphasis is success", port.m_alias.c_str());`
	`9919`	`+ SWSS_LOG_NOTICE("Set port %s line side serdes attributes is success", port.m_alias.c_str());`
`9914`	`9920`	`}`
`9915`	`9921`	`else`
`9916`	`9922`	`{`
`9917`		`- SWSS_LOG_ERROR("Failed to set port %s line side pre-emphasis", port.m_alias.c_str());`
	`9923`	`+ SWSS_LOG_ERROR("Failed to set port %s line side serdes attributes", port.m_alias.c_str());`
`9918`	`9924`	`return false;`
`9919`	`9925`	`}`
`9920`	`9926`	`}`