[PATCH 11/23] net: hpe: sl: add the core link state machines

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022,2023,2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+
+#include "sl_core_link.h"
+#include "sl_core_str.h"
+#include "sl_platform.h"
+#include "base/sl_core_timer_link.h"
+#include "base/sl_core_log.h"
+
+#include "hw/sl_core_hw_intr.h"
+
+#define LOG_NAME SL_CORE_TIMER_LINK_LOG_NAME
+
+void sl_core_timer_link_begin(struct sl_core_link *core_link, u32 timer_num)
+{
+	int  rtn;
+	enum sl_core_link_state link_state;
+	bool is_canceled_or_timed_out;
+
+	if (core_link->timers[timer_num].data.timeout_ms == 0) {
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "begin %s timeout is 0 (timer_num = %u)",
+				      core_link->timers[timer_num].data.log, timer_num);
+		return;
+	}
+
+	core_link->timers[timer_num].timer.expires =
+		jiffies + msecs_to_jiffies(core_link->timers[timer_num].data.timeout_ms);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"begin %s (core_link = 0x%p, timer_num = %u, timeout = %dms, jiffies = %ld)",
+			core_link->timers[timer_num].data.log, core_link, timer_num,
+			core_link->timers[timer_num].data.timeout_ms,
+			core_link->timers[timer_num].timer.expires);
+
+	rtn = sl_core_link_is_canceled_or_timed_out(core_link, &is_canceled_or_timed_out);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "begin %s is_canceled_or_timed_out failed (timer_num = %u) [%d]",
+				      core_link->timers[timer_num].data.log, timer_num, rtn);
+		return;
+	}
+
+	if (is_canceled_or_timed_out) {
+		sl_core_log_dbg(core_link, LOG_NAME,
+				"begin %s canceled (timer_num = %u)",
+				      core_link->timers[timer_num].data.log, timer_num);
+		return;
+	}
+
+	spin_lock(&core_link->link.data_lock);
+	link_state = core_link->link.state;
+	switch (link_state) {
+	case SL_CORE_LINK_STATE_UNCONFIGURED:
+	case SL_CORE_LINK_STATE_CONFIGURING:
+	case SL_CORE_LINK_STATE_CONFIGURED:
+	case SL_CORE_LINK_STATE_DOWN:
+	case SL_CORE_LINK_STATE_AN:
+	case SL_CORE_LINK_STATE_GOING_UP:
+	case SL_CORE_LINK_STATE_UP:
+		add_timer(&core_link->timers[timer_num].timer);
+		spin_unlock(&core_link->link.data_lock);
+		return;
+	default:
+		sl_core_log_err(core_link, LOG_NAME,
+				"begin %s invalid state (link_state = %u %s, timer_num = %u)",
+				core_link->timers[timer_num].data.log,
+				link_state, sl_core_link_state_str(link_state), timer_num);
+		spin_unlock(&core_link->link.data_lock);
+		return;
+	}
+}
+
+/**
+ * sl_core_timer_link_timeout - Timer callback function executed in interrupt context.
+ * @timer: Pointer to the timer_list structure associated with the timer.
+ *
+ * Context: Interrupt context.
+ */
+void sl_core_timer_link_timeout(struct timer_list *timer)
+{
+	struct sl_core_timer_link_info *info;
+	struct sl_core_link            *core_link;
+
+	info = timer_container_of(info, timer, timer);
+	core_link = info->data.link;
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"timeout %s (core_link = 0x%p, timer_num = %u, work_num = %u)",
+			info->data.log, core_link, info->data.timer_num,
+			info->data.work_num);
+
+	queue_work(core_link->core_lgrp->core_ldev->workqueue,
+		   &core_link->work[info->data.work_num]);
+}
+
+void sl_core_timer_link_end(struct sl_core_link *core_link, u32 timer_num)
+{
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"end %s (core_link = 0x%p, timer_num = %u)",
+			core_link->timers[timer_num].data.log, core_link, timer_num);
+
+	timer_delete_sync(&core_link->timers[timer_num].timer);
+}

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+
+#include "sl_core_str.h"
+#include "sl_core_llr.h"
+#include "sl_platform.h"
+#include "base/sl_core_timer_llr.h"
+#include "base/sl_core_log.h"
+
+#define LOG_NAME SL_CORE_TIMER_LLR_LOG_NAME
+
+void sl_core_timer_llr_begin(struct sl_core_llr *core_llr, u32 timer_num)
+{
+	enum sl_core_llr_state llr_state;
+
+	if (core_llr->timers[timer_num].data.timeout_ms == 0) {
+		sl_core_log_warn_trace(core_llr, LOG_NAME,
+				       "begin %s timeout is 0 (timer_num = %u)",
+				      core_llr->timers[timer_num].data.log, timer_num);
+		return;
+	}
+
+	core_llr->timers[timer_num].timer.expires =
+		jiffies + msecs_to_jiffies(core_llr->timers[timer_num].data.timeout_ms);
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"begin %s (core_llr = 0x%p, timer_num = %u, timeout = %dms, jiffies = %ld)",
+			core_llr->timers[timer_num].data.log, core_llr, timer_num,
+			core_llr->timers[timer_num].data.timeout_ms,
+			core_llr->timers[timer_num].timer.expires);
+
+	spin_lock(&core_llr->data_lock);
+	llr_state = core_llr->state;
+	switch (llr_state) {
+	case SL_CORE_LLR_STATE_SETTING_UP:
+	case SL_CORE_LLR_STATE_STARTING:
+		add_timer(&core_llr->timers[timer_num].timer);
+		spin_unlock(&core_llr->data_lock);
+		return;
+	default:
+		sl_core_log_err(core_llr, LOG_NAME,
+				"begin %s invalid state (llr_state = %u %s, timer_num = %u)",
+				core_llr->timers[timer_num].data.log,
+				llr_state, sl_core_llr_state_str(llr_state), timer_num);
+		spin_unlock(&core_llr->data_lock);
+		return;
+	}
+}
+
+/**
+ * sl_core_timer_llr_timeout - Timer callback function executed in interrupt context.
+ * @timer: Pointer to the timer_list structure associated with the timer.
+ *
+ * Context: Interrupt context.
+ */
+void sl_core_timer_llr_timeout(struct timer_list *timer)
+{
+	struct sl_core_timer_llr_info *info;
+	struct sl_core_llr            *core_llr;
+
+	info = timer_container_of(info, timer, timer);
+	core_llr = info->data.core_llr;
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"timeout %s (core_llr = 0x%p, timer_num = %u, work_num = %u)",
+			info->data.log, core_llr,
+			info->data.timer_num, info->data.work_num);
+
+	queue_work(core_llr->core_lgrp->core_ldev->workqueue,
+		   &core_llr->work[info->data.work_num]);
+}
+
+void sl_core_timer_llr_end(struct sl_core_llr *core_llr, u32 timer_num)
+{
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"end %s (core_llr = 0x%p, timer_num = %u)",
+			core_llr->timers[timer_num].data.log, core_llr, timer_num);
+
+	timer_delete_sync(&core_llr->timers[timer_num].timer);
+}

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+
+#include "data/sl_core_data_link.h"
+
+u16 sl_core_data_link_clock_period_get(void)
+{
+	return 0x38D;
+}

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+
+#include "data/sl_core_data_mac.h"
+
+u8 sl_core_data_mac_tx_cdt_init_get(void)
+{
+	return 64;
+}

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022,2023,2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+
+#include <linux/hpe/sl/sl_ldev.h>
+
+#include "sl_asic.h"
+#include "base/sl_core_log.h"
+#include "sl_core_ldev.h"
+#include "data/sl_core_data_ldev.h"
+#include "data/sl_core_data_lgrp.h"
+#include "hw/sl_core_hw_serdes_osprey.h"
+
+static struct sl_core_ldev *core_ldevs[SL_ASIC_MAX_LDEVS];
+static DEFINE_SPINLOCK(core_ldevs_lock);
+
+#define LOG_NAME SL_CORE_DATA_LDEV_LOG_NAME
+
+int sl_core_data_ldev_new(u8 ldev_num, struct sl_accessors *accessors,
+			  struct sl_ops *ops, struct workqueue_struct *workqueue)
+{
+	int                  rtn;
+	struct sl_core_ldev *core_ldev;
+	u16                  proto;
+
+	core_ldev = sl_core_ldev_get(ldev_num);
+	if (core_ldev) {
+		sl_core_log_err(NULL, LOG_NAME, "exists (ldev = 0x%p)", core_ldev);
+		return -EBADRQC;
+	}
+
+	core_ldev = kzalloc(sizeof(struct sl_core_ldev), GFP_KERNEL);
+	if (core_ldev == NULL)
+		return -ENOMEM;
+
+	core_ldev->magic           = SL_CORE_LDEV_MAGIC;
+	core_ldev->num             = ldev_num;
+	core_ldev->accessors       = *accessors;
+	core_ldev->ops             = *ops;
+	spin_lock_init(&(core_ldev->data_lock));
+
+	rtn = core_ldev->ops.mb_info_get(core_ldev->accessors.mb,
+		&(core_ldev->platform), &(core_ldev->revision), &proto);
+	if (rtn) {
+		sl_core_log_err(core_ldev, LOG_NAME, "mb_info_get failed [%d]", rtn);
+		kfree(core_ldev);
+		return -EIO;
+	}
+
+	core_ldev->workqueue = workqueue;
+
+	core_ldev->serdes.addrs = serdes_addrs_osprey;
+
+	sl_core_log_dbg(core_ldev, LOG_NAME, "new (ldev = 0x%p, platform = %u, revision = %u)",
+			core_ldev, core_ldev->platform, core_ldev->revision);
+
+	spin_lock(&core_ldevs_lock);
+	core_ldevs[ldev_num] = core_ldev;
+	spin_unlock(&core_ldevs_lock);
+
+	return 0;
+}
+
+int sl_core_data_ldev_del(u8 ldev_num)
+{
+	struct sl_core_ldev *core_ldev;
+	int                  lgrp_num;
+	int                  rtn;
+	int                  err = 0;
+
+	core_ldev = sl_core_ldev_get(ldev_num);
+	if (!core_ldev) {
+		sl_core_log_dbg(NULL, LOG_NAME, "not found (ldev_num = %u)", ldev_num);
+		return 0;
+	}
+
+	/*
+	 * The lgrps and links look this ldev up and point back at it, so they
+	 * must be deleted while it is still published and allocated. Try every
+	 * lgrp so as much as possible is deleted, and keep the first error.
+	 */
+	for (lgrp_num = 0; lgrp_num < SL_ASIC_MAX_LGRPS; ++lgrp_num) {
+		rtn = sl_core_data_lgrp_del(ldev_num, lgrp_num);
+		if (rtn && !err)
+			err = rtn;
+	}
+
+	/* An lgrp that could not be deleted still points at this ldev, so keep it. */
+	if (err) {
+		sl_core_log_err(core_ldev, LOG_NAME, "del - lgrp_del failed [%d]", err);
+		return err;
+	}
+
+	spin_lock(&core_ldevs_lock);
+	core_ldevs[ldev_num] = NULL;
+	spin_unlock(&core_ldevs_lock);
+
+	sl_core_log_dbg(core_ldev, LOG_NAME, "del (ldev = 0x%p)", core_ldev);
+
+	kfree(core_ldev);
+
+	return 0;
+}
+
+struct sl_core_ldev *sl_core_data_ldev_get(u8 ldev_num)
+{
+	struct sl_core_ldev *core_ldev;
+
+	spin_lock(&core_ldevs_lock);
+	core_ldev = core_ldevs[ldev_num];
+	spin_unlock(&core_ldevs_lock);
+
+	sl_core_log_dbg(NULL, LOG_NAME, "get (ldev_num = %u, ldev = 0x%p)",
+			ldev_num, core_ldev);
+
+	return core_ldev;
+}

@@ -0,0 +1,351 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022-2026 Hewlett Packard Enterprise Development LP */
+
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/bitops.h>
+
+#include "sl_asic.h"
+#include "sl_platform.h"
+#include "base/sl_core_log.h"
+#include "sl_core_lgrp.h"
+#include "sl_core_link.h"
+#include "sl_core_str.h"
+#include "data/sl_core_data_ldev.h"
+#include "data/sl_core_data_lgrp.h"
+#include "data/sl_core_data_link.h"
+#include "hw/sl_core_hw_reset.h"
+#include "hw/sl_core_hw_serdes.h"
+
+static struct sl_core_lgrp *core_lgrps[SL_ASIC_MAX_LDEVS][SL_ASIC_MAX_LGRPS];
+static DEFINE_SPINLOCK(core_lgrps_lock);
+
+#define LOG_NAME SL_CORE_DATA_LGRP_LOG_NAME
+
+int sl_core_data_lgrp_new(u8 ldev_num, u8 lgrp_num)
+{
+	int                  rtn;
+	struct sl_core_lgrp *core_lgrp;
+
+	spin_lock(&core_lgrps_lock);
+	core_lgrp = core_lgrps[ldev_num][lgrp_num];
+	spin_unlock(&core_lgrps_lock);
+	if (core_lgrp) {
+		sl_core_log_err(NULL, LOG_NAME, "new - lgrp exists");
+		return -EBADRQC;
+	}
+
+	core_lgrp = kzalloc(sizeof(struct sl_core_lgrp), GFP_KERNEL);
+	if (core_lgrp == NULL)
+		return -ENOMEM;
+
+	core_lgrp->magic     = SL_CORE_LGRP_MAGIC;
+	core_lgrp->core_ldev = sl_core_data_ldev_get(ldev_num);
+	core_lgrp->num       = lgrp_num;
+	kref_init(&core_lgrp->ref);
+	snprintf(core_lgrp->log_connect_id, sizeof(core_lgrp->log_connect_id), "core-lgrp%02u", lgrp_num);
+	spin_lock_init(&(core_lgrp->log_lock));
+	spin_lock_init(&(core_lgrp->data_lock));
+
+	if (SL_PLATFORM_IS_HARDWARE(core_lgrp->core_ldev)) {
+		rtn = core_lgrp->core_ldev->ops.dt_info_get(core_lgrp->core_ldev->accessors.dt,
+			ldev_num, lgrp_num, &(core_lgrp->serdes.dt));
+		if (rtn)
+			sl_core_log_dbg(core_lgrp, LOG_NAME, "new - dt_info_get failed [%d]", rtn);
+		sl_core_log_dbg(core_lgrp, LOG_NAME, "DT lane = 0 tx = %u tx_inv = %u rx = %u rx_inv = %u",
+				core_lgrp->serdes.dt.lane_info[0].tx_source, core_lgrp->serdes.dt.lane_info[0].tx_invert,
+			core_lgrp->serdes.dt.lane_info[0].rx_source, core_lgrp->serdes.dt.lane_info[0].rx_invert);
+		sl_core_log_dbg(core_lgrp, LOG_NAME, "DT lane = 1 tx = %u tx_inv = %u rx = %u rx_inv = %u",
+				core_lgrp->serdes.dt.lane_info[1].tx_source, core_lgrp->serdes.dt.lane_info[1].tx_invert,
+			core_lgrp->serdes.dt.lane_info[1].rx_source, core_lgrp->serdes.dt.lane_info[1].rx_invert);
+		sl_core_log_dbg(core_lgrp, LOG_NAME, "DT lane = 2 tx = %u tx_inv = %u rx = %u rx_inv = %u",
+				core_lgrp->serdes.dt.lane_info[2].tx_source, core_lgrp->serdes.dt.lane_info[2].tx_invert,
+			core_lgrp->serdes.dt.lane_info[2].rx_source, core_lgrp->serdes.dt.lane_info[2].rx_invert);
+		sl_core_log_dbg(core_lgrp, LOG_NAME, "DT lane = 3 tx = %u tx_inv = %u rx = %u rx_inv = %u",
+				core_lgrp->serdes.dt.lane_info[3].tx_source, core_lgrp->serdes.dt.lane_info[3].tx_invert,
+			core_lgrp->serdes.dt.lane_info[3].rx_source, core_lgrp->serdes.dt.lane_info[3].rx_invert);
+		sl_core_log_dbg(core_lgrp, LOG_NAME, "DT jack_type = %u %s", core_lgrp->serdes.dt.jack_type,
+				sl_core_lgrp_dt_jack_part_str(core_lgrp->serdes.dt.jack_type));
+	} else {
+		/* straight for emulator */
+		core_lgrp->serdes.dt.lane_info[0].tx_source = 0;
+		core_lgrp->serdes.dt.lane_info[1].tx_source = 1;
+		core_lgrp->serdes.dt.lane_info[2].tx_source = 2;
+		core_lgrp->serdes.dt.lane_info[3].tx_source = 3;
+		core_lgrp->serdes.dt.lane_info[0].rx_source = 0;
+		core_lgrp->serdes.dt.lane_info[1].rx_source = 1;
+		core_lgrp->serdes.dt.lane_info[2].rx_source = 2;
+		core_lgrp->serdes.dt.lane_info[3].rx_source = 3;
+
+		/* No swap for emulator */
+		core_lgrp->serdes.dt.jack_type = lgrp_num % 2 ? SL_DT_JACK_TYPE_DD : SL_DT_JACK_TYPE_LEGACY;
+	}
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "new - dt info (id = %u, addr = 0x%X)",
+			core_lgrp->serdes.dt.dev_id, core_lgrp->serdes.dt.dev_addr);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "new (lgrp = 0x%p)", core_lgrp);
+
+	spin_lock(&core_lgrps_lock);
+	if (core_lgrps[ldev_num][lgrp_num]) {
+		spin_unlock(&core_lgrps_lock);
+		sl_core_lgrp_put(core_lgrp);
+		return -EBADRQC;
+	}
+	core_lgrps[ldev_num][lgrp_num] = core_lgrp;
+	spin_unlock(&core_lgrps_lock);
+
+	return 0;
+}
+
+void sl_core_data_lgrp_connect_id_set(u8 ldev_num, u8 lgrp_num, const char *connect_id)
+{
+	struct sl_core_lgrp *core_lgrp __free(sl_core_lgrp_put) = NULL;
+	unsigned long        irq_flags;
+
+	core_lgrp = sl_core_lgrp_get(ldev_num, lgrp_num);
+	if (!core_lgrp)
+		return;
+
+	spin_lock_irqsave(&(core_lgrp->log_lock), irq_flags);
+	strscpy_pad(core_lgrp->log_connect_id, connect_id,
+		    sizeof(core_lgrp->log_connect_id));
+	spin_unlock_irqrestore(&(core_lgrp->log_lock), irq_flags);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "connect_id = %s", connect_id);
+}
+
+int sl_core_data_lgrp_del(u8 ldev_num, u8 lgrp_num)
+{
+	struct sl_core_lgrp *core_lgrp;
+	u8                   link_num;
+	bool                 is_configuring = false;
+	bool                 is_deleting = false;
+	int                  rtn;
+	int                  err = 0;
+
+	/*
+	 * Look the lgrp up, check it and claim it for deletion in one step.
+	 * core_lgrps_lock, with data_lock taken inside it, keeps another
+	 * deleter from finding the same lgrp and freeing it too. Only the
+	 * caller that sets is_deleting goes on to free it.
+	 */
+	spin_lock(&core_lgrps_lock);
+	core_lgrp = core_lgrps[ldev_num][lgrp_num];
+	if (core_lgrp) {
+		spin_lock(&core_lgrp->data_lock);
+		is_configuring = core_lgrp->is_configuring;
+		is_deleting = core_lgrp->is_deleting;
+		if (!is_configuring && !is_deleting)
+			core_lgrp->is_deleting = true;
+		spin_unlock(&core_lgrp->data_lock);
+	}
+	spin_unlock(&core_lgrps_lock);
+
+	if (!core_lgrp) {
+		sl_core_log_dbg(NULL, LOG_NAME, "del - not found (lgrp_num = %u)", lgrp_num);
+		return 0;
+	}
+
+	if (is_configuring) {
+		sl_core_log_err(NULL, LOG_NAME, "del - lgrp is configuring");
+		return -EBUSY;
+	}
+
+	if (is_deleting) {
+		sl_core_log_err(NULL, LOG_NAME, "del - lgrp is already being deleted");
+		return -EBUSY;
+	}
+
+	/*
+	 * A configuration that starts after the claim above is not stopped
+	 * here, as before, and a caller that looked the lgrp up earlier and
+	 * uses it after the free below is not covered either: the lookup does
+	 * not pin the lgrp.
+	 */
+
+	/* Try every link so as much as possible is deleted, and keep the first error. */
+	for (link_num = 0; link_num < SL_ASIC_MAX_LINKS; ++link_num) {
+		rtn = sl_core_data_link_del(ldev_num, lgrp_num, link_num);
+		if (rtn && !err)
+			err = rtn;
+	}
+
+	/*
+	 * A link that could not be deleted still points at this lgrp, so keep
+	 * it, and release the claim so that the delete can be retried.
+	 */
+	if (err)
+		goto out_retry;
+
+	spin_lock(&core_lgrps_lock);
+	if (refcount_read(&core_lgrp->ref.refcount) != 1) {
+		spin_unlock(&core_lgrps_lock);
+		err = -EBUSY;
+		goto out_retry;
+	}
+	core_lgrps[ldev_num][lgrp_num] = NULL;
+	spin_unlock(&core_lgrps_lock);
+
+	sl_core_lgrp_put(core_lgrp);
+	return 0;
+
+out_retry:
+	spin_lock(&core_lgrp->data_lock);
+	core_lgrp->is_deleting = false;
+	spin_unlock(&core_lgrp->data_lock);
+	sl_core_log_err(NULL, LOG_NAME, "del - busy or child failure [%d]", err);
+	return err;
+}
+
+struct sl_core_lgrp *sl_core_data_lgrp_get(u8 ldev_num, u8 lgrp_num)
+{
+	struct sl_core_lgrp *core_lgrp;
+
+	spin_lock(&core_lgrps_lock);
+	core_lgrp = core_lgrps[ldev_num][lgrp_num];
+	if (core_lgrp) {
+		spin_lock(&core_lgrp->data_lock);
+		if (core_lgrp->is_deleting) {
+			spin_unlock(&core_lgrp->data_lock);
+			core_lgrp = NULL;
+		} else {
+			kref_get(&core_lgrp->ref);
+			spin_unlock(&core_lgrp->data_lock);
+		}
+	}
+	spin_unlock(&core_lgrps_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "get (lgrp = 0x%p)", core_lgrp);
+
+	return core_lgrp;
+}
+
+static void sl_core_data_lgrp_release(struct kref *ref)
+{
+	kfree(container_of(ref, struct sl_core_lgrp, ref));
+}
+
+void sl_core_lgrp_put(struct sl_core_lgrp *core_lgrp)
+{
+	if (core_lgrp)
+		kref_put(&core_lgrp->ref, sl_core_data_lgrp_release);
+}
+
+int sl_core_data_lgrp_link_config_check(struct sl_core_lgrp *core_lgrp)
+{
+	int                  rtn;
+	int                  link_num;
+	struct sl_core_link *core_link __free(sl_core_link_put) = NULL;
+	enum sl_core_link_state link_state;
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "link config check");
+
+	for (link_num = 0; link_num < SL_ASIC_MAX_LINKS; ++link_num) {
+		core_link = sl_core_link_get(core_lgrp->core_ldev->num, core_lgrp->num, link_num);
+		if (!core_link)
+			continue;
+
+		rtn = sl_core_data_link_state_get(core_link, &link_state);
+		if (rtn) {
+			sl_core_log_err_trace(core_lgrp, LOG_NAME,
+					      "lgrp link config check - link_state_get failed [%d]", rtn);
+			return rtn;
+		}
+
+		switch (link_state) {
+		case SL_CORE_LINK_STATE_UNCONFIGURED:
+		case SL_CORE_LINK_STATE_CONFIGURING:
+		case SL_CORE_LINK_STATE_CONFIGURED:
+		case SL_CORE_LINK_STATE_DOWN:
+			continue;
+		default:
+			sl_core_log_err(core_lgrp, LOG_NAME,
+					"lgrp link config check wrong state (link_num = %u, state = %u %s)",
+					link_num, link_state, sl_core_link_state_str(link_state));
+			return -EBADRQC;
+		}
+	}
+
+	return 0;
+}
+
+void sl_core_data_lgrp_hw_attr_set(struct sl_core_lgrp *core_lgrp, struct sl_hw_attr *hw_attr)
+{
+	sl_core_log_dbg(core_lgrp, LOG_NAME,
+			"hw attr set (cxi = %u, nic = %u)", hw_attr->cxi_num, hw_attr->nic_num);
+
+	core_lgrp->hw_attr = *hw_attr;
+}
+
+void sl_core_data_lgrp_config_set(struct sl_core_lgrp *core_lgrp, struct sl_lgrp_config *lgrp_config)
+{
+	int  rtn;
+	bool need_swizzled;
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "config set");
+
+	/* if furcation changes, then we have to reset */
+	if (lgrp_config->furcation != core_lgrp->config.furcation)
+		sl_core_hw_reset_lgrp(core_lgrp);
+
+	/* if loopback enable changes, then we have to swizzle */
+	need_swizzled = false;
+	if ((lgrp_config->options & SL_LGRP_CONFIG_OPT_SERDES_LOOPBACK_ENABLE) !=
+		(core_lgrp->config.options & SL_LGRP_CONFIG_OPT_SERDES_LOOPBACK_ENABLE))
+		need_swizzled = true;
+
+	core_lgrp->config = *lgrp_config;
+
+	if (need_swizzled) {
+		rtn = sl_core_hw_serdes_swizzles(core_lgrp);
+		if (rtn)
+			sl_core_log_warn_trace(core_lgrp, LOG_NAME,
+					       "hw_serdes_swizzles failed [%d]", rtn);
+	}
+}
+
+u32 sl_core_data_lgrp_config_flags_get(struct sl_core_lgrp *core_lgrp)
+{
+	u32 flags;
+
+	spin_lock(&core_lgrp->data_lock);
+	flags = core_lgrp->config.options;
+	spin_unlock(&core_lgrp->data_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "config flags get (flags = 0x%X)", flags);
+
+	return flags;
+}
+
+int sl_core_data_lgrp_err_trace_enable_set(struct sl_core_lgrp *core_lgrp, bool err_trace_enable)
+{
+	spin_lock(&core_lgrp->data_lock);
+	core_lgrp->err_trace_enable = err_trace_enable;
+	spin_unlock(&core_lgrp->data_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "set (err_trace_enable = %s)", err_trace_enable ? "true" : "false");
+
+	return 0;
+}
+
+int sl_core_data_lgrp_warn_trace_enable_set(struct sl_core_lgrp *core_lgrp, bool warn_trace_enable)
+{
+	spin_lock(&core_lgrp->data_lock);
+	core_lgrp->warn_trace_enable = warn_trace_enable;
+	spin_unlock(&core_lgrp->data_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "set (warn_trace_enable = %s)", warn_trace_enable ? "true" : "false");
+
+	return 0;
+}
+
+int sl_core_data_lgrp_io_trace_set(struct sl_core_lgrp *core_lgrp, bool io_trace)
+{
+	spin_lock(&core_lgrp->data_lock);
+	core_lgrp->io_trace = io_trace;
+	spin_unlock(&core_lgrp->data_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME, "set (io_trace = %s)", io_trace ? "enabled" : "disabled");
+
+	return 0;
+}

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2025-2026 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+
+#include "data/sl_core_data_lgrp_trace.h"
+
+#define LOG_NAME SL_CORE_DATA_LGRP_LOG_NAME
+
+int sl_core_data_lgrp_is_err_trace_enabled(struct sl_core_lgrp *core_lgrp, bool *err_trace_enable)
+{
+	spin_lock(&core_lgrp->data_lock);
+	*err_trace_enable = core_lgrp->err_trace_enable;
+	spin_unlock(&core_lgrp->data_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME,
+			"is err trace enabled (err_trace_enable = %s)",
+			*err_trace_enable ? "true" : "false");
+
+	return 0;
+}
+
+int sl_core_data_lgrp_is_warn_trace_enabled(struct sl_core_lgrp *core_lgrp, bool *warn_trace_enable)
+{
+	spin_lock(&core_lgrp->data_lock);
+	*warn_trace_enable = core_lgrp->warn_trace_enable;
+	spin_unlock(&core_lgrp->data_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME,
+			"is warn trace enabled (warn_trace_enable = %s)",
+			*warn_trace_enable ? "true" : "false");
+
+	return 0;
+}
+
+bool sl_core_data_lgrp_is_io_trace_enabled(struct sl_core_lgrp *core_lgrp)
+{
+	bool io_trace;
+
+	spin_lock(&core_lgrp->data_lock);
+	io_trace = core_lgrp->io_trace;
+	spin_unlock(&core_lgrp->data_lock);
+
+	sl_core_log_dbg(core_lgrp, LOG_NAME,
+			"is io trace enabled (io_trace = %s)",
+			io_trace ? "enabled" : "disabled");
+
+	return io_trace;
+}

@@ -0,0 +1,1343 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022-2026 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/workqueue.h>
+#include <linux/ktime.h>
+
+#include "base/sl_core_log.h"
+#include "sl_core_ldev.h"
+#include "sl_core_lgrp.h"
+#include "sl_core_link.h"
+#include "sl_core_str.h"
+#include "sl_ctrl_link.h"
+#include "sl_ctrl_link_counters.h"
+#include "data/sl_core_data_link.h"
+#include "hw/sl_core_hw_intr.h"
+#include "hw/sl_core_hw_link.h"
+#include "hw/sl_core_hw_an.h"
+#include "hw/sl_core_hw_an_up.h"
+#include "hw/sl_core_hw_an_lp.h"
+#include "sl_core_hw_intr_flgs.h"
+#include "hw/sl_core_hw_settings.h"
+#include "hw/sl_core_hw_llr.h"
+#include "hw/sl_core_hw_io.h"
+
+/* 0x01002510 (hni_pcs_corrected_cw)
+ * 0x01002618 (hni_pcs_corrected_cw_bin_14)
+ * (0x01002618 + 0x8) - 0x01002510 = 0x110 = Size
+ */
+#define SL_CORE_HW_FEC_CNTRS_OFFSET 0x01002510
+#define SL_CORE_HW_FEC_CNTRS_SIZE   0x110
+
+#define SL_CORE_HW_FEC_UP_SETTLE_WAIT_MS 250
+#define SL_CORE_HW_FEC_UP_CHECK_WAIT_MS  500
+
+static struct sl_core_link *core_links[SL_ASIC_MAX_LDEVS][SL_ASIC_MAX_LGRPS][SL_ASIC_MAX_LINKS];
+static DEFINE_SPINLOCK(core_links_lock);
+
+#define LOG_NAME SL_CORE_DATA_LINK_LOG_NAME
+
+static void sl_core_data_link_free(struct sl_core_link *core_link);
+
+#define SL_CORE_TIMER_INIT(_link, _timer_num, _work_num, _log)           \
+	do {                                                             \
+		(_link)->timers[_timer_num].data.link      = _link;      \
+		(_link)->timers[_timer_num].data.timer_num = _timer_num; \
+		(_link)->timers[_timer_num].data.work_num  = _work_num;  \
+		strscpy_pad((_link)->timers[_timer_num].data.log, _log, \
+			sizeof((_link)->timers[_timer_num].data.log));   \
+	} while (0)
+#define SL_CORE_INTR_INIT(_link, _intr_num, _work_num, _log)           \
+	do {                                                           \
+		(_link)->intrs[_intr_num].flgs =                       \
+			sl_core_hw_intr_flgs[_intr_num][(_link)->num]; \
+		(_link)->intrs[_intr_num].data.link     = _link;       \
+		(_link)->intrs[_intr_num].data.intr_num = _intr_num;   \
+		(_link)->intrs[_intr_num].data.work_num = _work_num;   \
+		strscpy_pad((_link)->intrs[_intr_num].data.log, _log, \
+			sizeof((_link)->intrs[_intr_num].data.log));   \
+	} while (0)
+
+static int sl_core_data_link_init(struct sl_core_lgrp *core_lgrp, u8 link_num, struct sl_core_link *core_link)
+{
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"link init (link = 0x%p, lgrp = 0x%p)", core_link, core_lgrp);
+
+	/* ----- general ----- */
+
+	core_link->magic         = SL_CORE_LINK_MAGIC;
+	core_link->num           = link_num;
+	core_link->core_lgrp     = core_lgrp;
+	kref_get(&core_lgrp->ref);
+	core_link->an.fail_cause = SL_CORE_HW_AN_FAIL_CAUSE_NONE;
+	spin_lock_init(&(core_link->data_lock));
+	kref_init(&core_link->ref);
+	spin_lock_init(&(core_link->irq_data_lock));
+	spin_lock_init(&(core_link->serdes.data_lock));
+
+	/* ----- link ----- */
+
+	spin_lock_init(&(core_link->link.data_lock));
+
+	timer_setup(&(core_link->timers[SL_CORE_TIMER_LINK_UP].timer),
+		    sl_core_timer_link_timeout, 0);
+	SL_CORE_TIMER_INIT(core_link, SL_CORE_TIMER_LINK_UP,
+			   SL_CORE_WORK_LINK_UP_TIMEOUT, "link up");
+	timer_setup(&(core_link->timers[SL_CORE_TIMER_LINK_UP_CHECK].timer),
+		    sl_core_timer_link_timeout, 0);
+	SL_CORE_TIMER_INIT(core_link, SL_CORE_TIMER_LINK_UP_CHECK,
+			   SL_CORE_WORK_LINK_UP_CHECK, "link up check");
+	timer_setup(&(core_link->timers[SL_CORE_TIMER_LINK_UP_HIGH_POWER].timer),
+		    sl_core_timer_link_timeout, 0);
+	SL_CORE_TIMER_INIT(core_link, SL_CORE_TIMER_LINK_UP_HIGH_POWER,
+			   SL_CORE_WORK_LINK_UP, "link up high power");
+
+	SL_CORE_INTR_INIT(core_link, SL_CORE_HW_INTR_LINK_UP,
+			  SL_CORE_WORK_LINK_UP_INTR, "link up");
+	SL_CORE_INTR_INIT(core_link, SL_CORE_HW_INTR_LINK_HIGH_SER,
+			  SL_CORE_WORK_LINK_HIGH_SER_INTR, "link high SER");
+	SL_CORE_INTR_INIT(core_link, SL_CORE_HW_INTR_LINK_LLR_MAX_STARVATION,
+			  SL_CORE_WORK_LINK_LLR_MAX_STARVATION_INTR, "link llr max starvation");
+	SL_CORE_INTR_INIT(core_link, SL_CORE_HW_INTR_LINK_LLR_STARVED,
+			  SL_CORE_WORK_LINK_LLR_STARVED_INTR, "link llr starved");
+	SL_CORE_INTR_INIT(core_link, SL_CORE_HW_INTR_LINK_FAULT,
+			  SL_CORE_WORK_LINK_FAULT_INTR, "link fault");
+
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_AN_UP_START]),
+		  sl_core_hw_an_up_start_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_START]),
+		  sl_core_hw_link_up_start_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP]),
+		  sl_core_hw_link_up_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_INTR]),
+		  sl_core_hw_link_up_intr_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_TIMEOUT]),
+		  sl_core_hw_link_up_timeout_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_CHECK]),
+		  sl_core_hw_link_up_check_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_HIGH_SER_INTR]),
+		  sl_core_hw_link_high_ser_intr_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_LLR_MAX_STARVATION_INTR]),
+		  sl_core_hw_link_llr_max_starvation_intr_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_LLR_STARVED_INTR]),
+		  sl_core_hw_link_llr_starved_intr_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_FAULT_INTR]),
+		  sl_core_hw_link_fault_intr_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_CANCEL]),
+		  sl_core_hw_link_up_cancel_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_FAIL]),
+		  sl_core_hw_link_up_fail_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_DOWN]),
+		  sl_core_hw_link_down_work);
+
+	/* ----- pml recovery ----- */
+
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_PML_REC_POLL]),
+		  sl_core_hw_link_pml_rec_poll_work);
+
+	/* ----- an ----- */
+
+	spin_lock_init(&(core_link->an.data_lock));
+	core_link->an.lp_caps_state = SL_CORE_LINK_LP_CAPS_NOT_RUNNING;
+
+	timer_setup(&(core_link->timers[SL_CORE_TIMER_LINK_AN_LP_CAPS_GET].timer),
+		    sl_core_timer_link_timeout, 0);
+	SL_CORE_TIMER_INIT(core_link, SL_CORE_TIMER_LINK_AN_LP_CAPS_GET,
+			   SL_CORE_WORK_LINK_AN_LP_CAPS_GET_TIMEOUT, "an lp caps get");
+
+	SL_CORE_INTR_INIT(core_link, SL_CORE_HW_INTR_AN_PAGE_RECV, 0, "an page recv");
+
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET]),
+		  sl_core_hw_an_lp_caps_get_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET_TIMEOUT]),
+		  sl_core_hw_an_lp_caps_get_timeout_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET_DONE]),
+		  sl_core_hw_an_lp_caps_get_done_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_AN_UP]),
+		  sl_core_hw_an_up_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_AN_UP_DONE]),
+		  sl_core_hw_an_up_done_work);
+
+	/* ----- fec ----- */
+
+	timer_setup(&(core_link->timers[SL_CORE_TIMER_LINK_UP_FEC_SETTLE].timer),
+		    sl_core_timer_link_timeout, 0);
+	SL_CORE_TIMER_INIT(core_link, SL_CORE_TIMER_LINK_UP_FEC_SETTLE,
+			   SL_CORE_WORK_LINK_UP_FEC_SETTLE, "link up fec settle");
+	timer_setup(&(core_link->timers[SL_CORE_TIMER_LINK_UP_FEC_CHECK].timer),
+		    sl_core_timer_link_timeout, 0);
+	SL_CORE_TIMER_INIT(core_link, SL_CORE_TIMER_LINK_UP_FEC_CHECK,
+			   SL_CORE_WORK_LINK_UP_FEC_CHECK, "link up fec check");
+
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_FEC_SETTLE]),
+		  sl_core_hw_link_up_fec_settle_work);
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_UP_FEC_CHECK]),
+		  sl_core_hw_link_up_fec_check_work);
+
+	spin_lock_init(&core_link->fec.test_lock);
+
+	atomic_set(&core_link->an.retry_count, 0);
+
+	/* ----- ald ----- */
+
+	SL_CORE_INTR_INIT(core_link, SL_CORE_HW_INTR_LANE_DEGRADE,
+			  SL_CORE_WORK_LINK_LANE_DEGRADE_INTR, "lane degrade");
+
+	INIT_WORK(&(core_link->work[SL_CORE_WORK_LINK_LANE_DEGRADE_INTR]),
+		  sl_core_hw_link_lane_degrade_intr_work);
+
+	/* do very last thing */
+	core_link->link.state = SL_CORE_LINK_STATE_UNCONFIGURED;
+	sl_media_jack_led_set(core_link->core_lgrp->core_ldev->num, core_link->core_lgrp->num);
+
+	return 0;
+}
+
+int sl_core_data_link_new(u8 ldev_num, u8 lgrp_num, u8 link_num)
+{
+	int                  rtn;
+	struct sl_core_link *core_link;
+	struct sl_core_lgrp *core_lgrp __free(sl_core_lgrp_put) = NULL;
+	struct sl_core_ldev *core_ldev;
+	u8                   is_configuring;
+
+	core_ldev = sl_core_ldev_get(ldev_num);
+	core_lgrp = sl_core_lgrp_get(ldev_num, lgrp_num);
+	if (!core_lgrp)
+		return -ENODEV;
+	spin_lock(&core_lgrp->data_lock);
+	is_configuring = core_lgrp->is_configuring;
+	spin_unlock(&core_lgrp->data_lock);
+	if (is_configuring) {
+		sl_core_log_err(core_lgrp, LOG_NAME, "lgrp is configuring");
+		return -EBADRQC;
+	}
+
+	spin_lock(&core_links_lock);
+	core_link = core_links[ldev_num][lgrp_num][link_num];
+	spin_unlock(&core_links_lock);
+	if (core_link) {
+		sl_core_log_err(NULL, LOG_NAME, "link exists");
+		return -EBADRQC;
+	}
+
+	core_link = kzalloc(sizeof(struct sl_core_link), GFP_KERNEL);
+	if (core_link == NULL)
+		return -ENOMEM;
+
+	rtn = sl_core_data_link_init(core_lgrp, link_num, core_link);
+	if (rtn != 0) {
+		sl_core_log_err(core_link, LOG_NAME, "core_data_link_init failed [%d]", rtn);
+		kfree(core_link);
+		return rtn;
+	}
+
+	core_link->is_deleting = true;
+	spin_lock(&core_links_lock);
+	if (core_links[ldev_num][lgrp_num][link_num]) {
+		spin_unlock(&core_links_lock);
+		sl_core_data_link_put_pinned(core_link);
+		return -EBADRQC;
+	}
+	core_links[ldev_num][lgrp_num][link_num] = core_link;
+	spin_unlock(&core_links_lock);
+
+	rtn = sl_core_hw_intr_hdlr_register(core_link);
+	if (rtn != 0) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "core_hw_intr_hdlr_register failed [%d]", rtn);
+		goto out_unwind;
+	}
+
+	if (link_num == 0) {
+		rtn = sl_core_hw_intr_register(core_link, core_link->intrs[SL_CORE_HW_INTR_LANE_DEGRADE].flgs,
+					       sl_core_hw_intr_hdlr, &(core_link->intrs[SL_CORE_HW_INTR_LANE_DEGRADE].data));
+		if (rtn != 0) {
+			sl_core_log_err_trace(core_link, LOG_NAME, "intr register degrade failed [%d]", rtn);
+			goto out_unwind;
+		}
+	}
+
+	sl_core_hw_llr_link_init(core_link);
+
+	if (core_ldev->ops.dmac_alloc) {
+		rtn = core_ldev->ops.dmac_alloc(
+			core_ldev->accessors.dmac,
+			SL_CORE_HW_FEC_CNTRS_OFFSET,
+			SL_CORE_HW_FEC_CNTRS_SIZE);
+		if (rtn) {
+			sl_core_log_err(core_link, LOG_NAME, "dmac_alloc failed [%d]", rtn);
+			goto out_unwind;
+		}
+	}
+
+	sl_core_log_dbg(core_link, LOG_NAME, "new (link = 0x%p)", core_link);
+
+	spin_lock(&core_links_lock);
+	core_link->is_deleting = false;
+	spin_unlock(&core_links_lock);
+
+	return 0;
+
+out_unwind:
+	spin_lock(&core_links_lock);
+	core_links[ldev_num][lgrp_num][link_num] = NULL;
+	spin_unlock(&core_links_lock);
+	/* Registration may be partial; unregistering a never-registered handler only warns. */
+	sl_core_hw_intr_hdlr_unregister(core_link);
+	sl_core_data_link_free(core_link);
+	sl_core_data_link_put_pinned(core_link);
+	return rtn;
+}
+
+static void sl_core_data_link_free(struct sl_core_link *core_link)
+{
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"link free (link = 0x%p, lgrp = 0x%p)", core_link, core_link->core_lgrp);
+
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_AN_LP_CAPS_GET);
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_UP_FEC_SETTLE);
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_UP_FEC_CHECK);
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_UP);
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_UP_CHECK);
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_UP_HIGH_POWER);
+
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET_TIMEOUT]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET_DONE]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_AN_UP_START]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_AN_UP]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_AN_UP_DONE]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_START]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_TIMEOUT]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_CHECK]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_FEC_SETTLE]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_FEC_CHECK]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_FAIL]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_CANCEL]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_DOWN]));
+
+	sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_LINK_UP);
+	sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_LINK_HIGH_SER);
+	sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_LINK_LLR_MAX_STARVATION);
+	sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_LINK_LLR_STARVED);
+	sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_LINK_FAULT);
+
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_UP_INTR]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_HIGH_SER_INTR]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_LLR_MAX_STARVATION_INTR]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_LLR_STARVED_INTR]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_FAULT_INTR]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_LANE_DEGRADE_INTR]));
+	cancel_work_sync(&(core_link->work[SL_CORE_WORK_LINK_PML_REC_POLL]));
+}
+
+int sl_core_data_link_del(u8 ldev_num, u8 lgrp_num, u8 link_num)
+{
+	struct sl_core_link *core_link;
+	struct sl_core_lgrp *core_lgrp;
+	struct sl_core_ldev *core_ldev;
+
+	spin_lock(&core_links_lock);
+	core_link = core_links[ldev_num][lgrp_num][link_num];
+	if (!core_link) {
+		spin_unlock(&core_links_lock);
+		sl_core_log_dbg(NULL, LOG_NAME,
+				"not found (ldev_num = %u, lgrp_num = %u, link_num = %u)",
+			ldev_num, lgrp_num, link_num);
+		return 0;
+	}
+
+	/* A link is deleted before its lgrp and ldev, so both must still be published. */
+	core_lgrp = core_link->core_lgrp;
+	core_ldev = core_lgrp->core_ldev;
+
+	spin_lock(&core_lgrp->data_lock);
+	if (core_lgrp->is_configuring || core_link->is_deleting ||
+	    refcount_read(&core_link->ref.refcount) != 1) {
+		spin_unlock(&core_lgrp->data_lock);
+		spin_unlock(&core_links_lock);
+		return -EBUSY;
+	}
+	core_link->is_deleting = true;
+	spin_unlock(&core_lgrp->data_lock);
+	spin_unlock(&core_links_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "del (link = 0x%p)", core_link);
+
+	sl_core_hw_intr_hdlr_unregister(core_link);
+
+	sl_core_data_link_free(core_link);
+
+	if (core_ldev->ops.dmac_free)
+		core_ldev->ops.dmac_free(core_ldev->accessors.dmac);
+
+	spin_lock(&core_links_lock);
+	core_links[ldev_num][lgrp_num][link_num] = NULL;
+	spin_unlock(&core_links_lock);
+
+	/* Drop the table's reference; the memory stays until pinned users are done. */
+	sl_core_data_link_put_pinned(core_link);
+
+	return 0;
+}
+
+struct sl_core_link *sl_core_data_link_get(u8 ldev_num, u8 lgrp_num, u8 link_num)
+{
+	struct sl_core_link *core_link;
+
+	spin_lock(&core_links_lock);
+	core_link = core_links[ldev_num][lgrp_num][link_num];
+	if (core_link && !core_link->is_deleting)
+		kref_get(&core_link->ref);
+	else
+		core_link = NULL;
+	spin_unlock(&core_links_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (link = 0x%p)", core_link);
+
+	return core_link;
+}
+
+/*
+ * Both lookup variants retain the link, its resources and its parent until
+ * the matching put. Deletion returns -EBUSY while lookup references remain.
+ * Returns NULL if the link is absent, initializing or being deleted.
+ */
+struct sl_core_link *sl_core_data_link_get_pinned(u8 ldev_num, u8 lgrp_num, u8 link_num)
+{
+	return sl_core_data_link_get(ldev_num, lgrp_num, link_num);
+}
+
+static void sl_core_data_link_release(struct kref *ref)
+{
+	struct sl_core_link *core_link = container_of(ref, struct sl_core_link, ref);
+
+	sl_core_lgrp_put(core_link->core_lgrp);
+	kfree(core_link);
+}
+
+void sl_core_data_link_put_pinned(struct sl_core_link *core_link)
+{
+	kref_put(&core_link->ref, sl_core_data_link_release);
+}
+
+void sl_core_data_link_config_set(struct sl_core_link *core_link,
+				  struct sl_core_link_config *link_config)
+{
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"config set (flags = 0x%X, hpe_map = 0x%X, pause_map = 0x%X)",
+		link_config->flags, link_config->hpe_map, link_config->pause_map);
+
+	spin_lock(&core_link->data_lock);
+	core_link->config = *link_config;
+	if (!is_flag_set(core_link->config.flags, SL_LINK_CONFIG_OPT_AUTONEG_ENABLE))
+		memset(core_link->core_lgrp->link_caps, 0, sizeof(core_link->core_lgrp->link_caps));
+	spin_unlock(&core_link->data_lock);
+
+	sl_core_data_link_state_set(core_link, SL_CORE_LINK_STATE_CONFIGURED);
+}
+
+int sl_core_data_link_settings(struct sl_core_link *core_link)
+{
+	struct sl_ctrl_link *held_link_1 __free(sl_ctrl_link_put) = NULL;
+	struct sl_lgrp_config *lgrp_config;
+	struct sl_link_caps   *link_caps;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "settings");
+
+	lgrp_config = &(core_link->core_lgrp->config);
+	link_caps   = &(core_link->core_lgrp->link_caps[core_link->num]);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"settings - tech map  = 0x%08X", link_caps->tech_map);
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"settings - fec map   = 0x%08X", link_caps->fec_map);
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"settings - pause map = 0x%08X", link_caps->pause_map);
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"settings - hpe map   = 0x%08X", link_caps->hpe_map);
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"settings - furcation = %u", lgrp_config->furcation);
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"settings - options   = %u", lgrp_config->options);
+
+	/* abilities */
+	if (hweight_long(link_caps->tech_map) != 1) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "settings - tech map invalid (map = 0x%08X)",
+				      link_caps->tech_map);
+		return -EINVAL;
+	}
+	if (hweight_long(link_caps->fec_map) > 1) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "settings - fec map invalid (map = 0x%08X)",
+				      link_caps->fec_map);
+		return -EINVAL;
+	}
+
+	/* PCS */
+	core_link->pcs.settings.clock_period = sl_core_data_link_clock_period_get();
+	if (SL_LGRP_CONFIG_TECH_CK_400G & link_caps->tech_map) {
+		core_link->pcs.settings.speed                      = SL_LGRP_CONFIG_TECH_CK_400G;
+		core_link->pcs.settings.pcs_mode                   = SL_CORE_HW_PCS_MODE_CK_400G;
+		core_link->pcs.settings.rx_active_lanes            = SL_CORE_HW_ACTIVE_LANES_CK_400G;
+		core_link->pcs.settings.rx_am_lock_lanes           = SL_CORE_HW_AM_LOCK_LANES_CK_400G;
+		if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_FABRIC)) {
+			core_link->pcs.settings.tx_cdc_ready_level         = 8;
+			core_link->pcs.settings.tx_en_pk_bw_limiter        = 1;
+			core_link->pcs.settings.tx_gearbox_credits         = 12;
+			core_link->pcs.settings.cw_gap                     = 6;
+		} else {
+			core_link->pcs.settings.tx_cdc_ready_level         = 8;
+			core_link->pcs.settings.tx_en_pk_bw_limiter        = 1;
+			core_link->pcs.settings.tx_gearbox_credits         = 8;
+			core_link->pcs.settings.cw_gap                     = 6;
+		}
+		if (sl_core_link_config_is_enable_ald_set(core_link))
+			core_link->pcs.settings.tx_gearbox_credits = 12;
+	}
+	if (SL_LGRP_CONFIG_TECH_CK_200G & link_caps->tech_map) {
+		core_link->pcs.settings.speed                      = SL_LGRP_CONFIG_TECH_CK_200G;
+		core_link->pcs.settings.pcs_mode                   = SL_CORE_HW_PCS_MODE_CK_200G;
+		core_link->pcs.settings.rx_active_lanes            = SL_CORE_HW_ACTIVE_LANES_CK_200G(core_link->num);
+		core_link->pcs.settings.rx_am_lock_lanes           = SL_CORE_HW_AM_LOCK_LANES_CK_200G(core_link->num);
+		core_link->pcs.settings.tx_cdc_ready_level         = 8;
+		core_link->pcs.settings.tx_en_pk_bw_limiter        = 1;
+		core_link->pcs.settings.tx_gearbox_credits         = 8;
+		core_link->pcs.settings.cw_gap                     = 6;
+	}
+	if (SL_LGRP_CONFIG_TECH_CK_100G & link_caps->tech_map) {
+		core_link->pcs.settings.speed                      = SL_LGRP_CONFIG_TECH_CK_100G;
+		core_link->pcs.settings.pcs_mode                   = SL_CORE_HW_PCS_MODE_CK_100G;
+		core_link->pcs.settings.rx_active_lanes            = SL_CORE_HW_ACTIVE_LANES_CK_100G(core_link->num);
+		core_link->pcs.settings.rx_am_lock_lanes           = SL_CORE_HW_AM_LOCK_LANES_CK_100G(core_link->num);
+		core_link->pcs.settings.tx_cdc_ready_level         = 8;
+		core_link->pcs.settings.tx_en_pk_bw_limiter        = 1;
+		core_link->pcs.settings.tx_gearbox_credits         = 4;
+		core_link->pcs.settings.cw_gap                     = 16;
+	}
+	if (SL_LGRP_CONFIG_TECH_BS_200G & link_caps->tech_map) {
+		core_link->pcs.settings.speed                      = SL_LGRP_CONFIG_TECH_BS_200G;
+		core_link->pcs.settings.pcs_mode                   = SL_CORE_HW_PCS_MODE_BS_200G;
+		core_link->pcs.settings.rx_active_lanes            = SL_CORE_HW_ACTIVE_LANES_BS_200G;
+		core_link->pcs.settings.rx_am_lock_lanes           = SL_CORE_HW_AM_LOCK_LANES_BS_200G;
+		if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_FABRIC)) {
+			core_link->pcs.settings.tx_cdc_ready_level         = 8;
+			core_link->pcs.settings.tx_en_pk_bw_limiter        = 0;
+			core_link->pcs.settings.tx_gearbox_credits         = 12;
+			core_link->pcs.settings.cw_gap                     = 6;
+		} else {
+			core_link->pcs.settings.tx_cdc_ready_level         = 8;
+			core_link->pcs.settings.tx_en_pk_bw_limiter        = 0;
+			core_link->pcs.settings.tx_gearbox_credits         = 8;
+			if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_R1))
+				core_link->pcs.settings.cw_gap             = 24;
+			else
+				core_link->pcs.settings.cw_gap             = 6;
+		}
+		if (sl_core_link_config_is_enable_ald_set(core_link))
+			core_link->pcs.settings.tx_gearbox_credits = 12;
+	}
+	if (SL_LGRP_CONFIG_TECH_CD_100G & link_caps->tech_map) {
+		core_link->pcs.settings.speed                      = SL_LGRP_CONFIG_TECH_CD_100G;
+		core_link->pcs.settings.pcs_mode                   = SL_CORE_HW_PCS_MODE_CD_100G;
+		core_link->pcs.settings.rx_active_lanes            = SL_CORE_HW_ACTIVE_LANES_CD_100G(core_link->num);
+		core_link->pcs.settings.rx_am_lock_lanes           = SL_CORE_HW_AM_LOCK_LANES_CD_100G(core_link->num);
+		core_link->pcs.settings.tx_cdc_ready_level         = 8;
+		core_link->pcs.settings.tx_en_pk_bw_limiter        = 1;
+		core_link->pcs.settings.tx_gearbox_credits         = 4;
+		core_link->pcs.settings.cw_gap                     = 6;
+	}
+	if (SL_LGRP_CONFIG_TECH_CD_50G & link_caps->tech_map) {
+		core_link->pcs.settings.speed                      = SL_LGRP_CONFIG_TECH_CD_50G;
+		core_link->pcs.settings.pcs_mode                   = SL_CORE_HW_PCS_MODE_CD_50G;
+		core_link->pcs.settings.rx_active_lanes            = SL_CORE_HW_ACTIVE_LANES_CD_50G(core_link->num);
+		core_link->pcs.settings.rx_am_lock_lanes           = SL_CORE_HW_AM_LOCK_LANES_CD_50G(core_link->num);
+		core_link->pcs.settings.tx_cdc_ready_level         = 8;
+		core_link->pcs.settings.tx_en_pk_bw_limiter        = 1;
+		core_link->pcs.settings.tx_gearbox_credits         = 2;
+		core_link->pcs.settings.cw_gap                     = 12;
+	}
+	if (SL_LGRP_CONFIG_TECH_BJ_100G & link_caps->tech_map) {
+		core_link->pcs.settings.speed                      = SL_LGRP_CONFIG_TECH_BJ_100G;
+		core_link->pcs.settings.pcs_mode                   = SL_CORE_HW_PCS_MODE_BJ_100G;
+		core_link->pcs.settings.rx_active_lanes            = SL_CORE_HW_ACTIVE_LANES_BJ_100G;
+		core_link->pcs.settings.rx_am_lock_lanes           = SL_CORE_HW_AM_LOCK_LANES_BJ_100G;
+		core_link->pcs.settings.tx_cdc_ready_level         = 8;
+		core_link->pcs.settings.tx_en_pk_bw_limiter        = 0;
+		core_link->pcs.settings.tx_gearbox_credits         = 8;
+		core_link->pcs.settings.cw_gap                     = 6;
+	}
+
+	if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_FABRIC)) {
+		core_link->pcs.settings.mac_tx_credits = 8;
+	} else {
+		switch (lgrp_config->furcation) {
+		case SL_MEDIA_FURCATION_X1:
+			core_link->pcs.settings.mac_tx_credits = 8;
+			break;
+		case SL_MEDIA_FURCATION_X2:
+			core_link->pcs.settings.mac_tx_credits = 4;
+			break;
+		case SL_MEDIA_FURCATION_X4:
+			core_link->pcs.settings.mac_tx_credits = 2;
+			break;
+		}
+	}
+
+	switch (lgrp_config->furcation) {
+	case SL_MEDIA_FURCATION_X1:
+		core_link->pcs.settings.underrun_clr = 0;
+		break;
+	case SL_MEDIA_FURCATION_X2:
+		core_link->pcs.settings.underrun_clr = (~(3 << (core_link->num * 2)) & 0xF);
+		break;
+	case SL_MEDIA_FURCATION_X4:
+		core_link->pcs.settings.underrun_clr = (~(1 << core_link->num) & 0xF);
+		break;
+	}
+
+	/* FEC */
+	if (SL_LGRP_CONFIG_FEC_RS_LL & link_caps->fec_map) {
+		core_link->pcs.settings.rs_mode  = SL_CORE_HW_RS_MODE_CORRECT;
+		core_link->fec.settings.mode     = SL_LGRP_FEC_MODE_CORRECT;
+		core_link->fec.settings.type     = SL_LGRP_CONFIG_FEC_RS_LL;
+	} else if (SL_LGRP_CONFIG_FEC_RS & link_caps->fec_map) {
+		core_link->pcs.settings.rs_mode  = SL_CORE_HW_RS_MODE_CORRECT;
+		core_link->fec.settings.mode     = SL_LGRP_FEC_MODE_CORRECT;
+		core_link->fec.settings.type     = SL_LGRP_CONFIG_FEC_RS;
+	} else {
+		core_link->pcs.settings.rs_mode  = SL_CORE_HW_RS_MODE_OFF;
+		core_link->fec.settings.mode     = SL_LGRP_FEC_MODE_OFF;
+		core_link->fec.settings.type     = 0;
+	}
+
+	core_link->fec.settings.up_settle_wait_ms = (core_link->config.fec_up_settle_wait_ms < 0) ?
+		SL_CORE_HW_FEC_UP_SETTLE_WAIT_MS : core_link->config.fec_up_settle_wait_ms;
+	core_link->fec.settings.up_check_wait_ms  = (core_link->config.fec_up_check_wait_ms < 0) ?
+		SL_CORE_HW_FEC_UP_CHECK_WAIT_MS : core_link->config.fec_up_check_wait_ms;
+
+	if (core_link->config.fec_up_ucw_limit < 0) {
+		held_link_1 = sl_ctrl_link_get(core_link->core_lgrp->core_ldev->num,
+					       core_link->core_lgrp->num, core_link->num);
+		if (!held_link_1)
+			return -ENODEV;
+		core_link->fec.settings.up_ucw_limit =
+			sl_ctrl_link_fec_limit_calc(held_link_1,
+						    SL_CTRL_LINK_FEC_UCW_MANT,
+						    SL_CTRL_LINK_FEC_UCW_EXP);
+	} else {
+		core_link->fec.settings.up_ucw_limit = core_link->config.fec_up_ucw_limit;
+	}
+
+	if (core_link->config.fec_up_ccw_limit < 0)
+		core_link->fec.settings.up_ccw_limit = 0;
+	else
+		core_link->fec.settings.up_ccw_limit = core_link->config.fec_up_ccw_limit;
+
+	return 0;
+}
+
+void sl_core_data_link_timeouts(struct sl_core_link *core_link)
+{
+	sl_core_log_dbg(core_link, LOG_NAME, "timeouts");
+
+	if (core_link->config.link_up_timeout_ms == 0) {
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "timeouts - link up timeout is 0, setting to default");
+		core_link->timers[SL_CORE_TIMER_LINK_UP].data.timeout_ms = 10000;
+	} else {
+		core_link->timers[SL_CORE_TIMER_LINK_UP].data.timeout_ms = core_link->config.link_up_timeout_ms;
+	}
+
+	core_link->timers[SL_CORE_TIMER_LINK_UP_CHECK].data.timeout_ms = 100;
+
+	core_link->timers[SL_CORE_TIMER_LINK_UP_FEC_SETTLE].data.timeout_ms = core_link->fec.settings.up_settle_wait_ms;
+	core_link->timers[SL_CORE_TIMER_LINK_UP_FEC_CHECK].data.timeout_ms  = core_link->fec.settings.up_check_wait_ms;
+}
+
+void sl_core_data_link_state_set(struct sl_core_link *core_link,
+				 enum sl_core_link_state link_state)
+{
+	spin_lock(&core_link->link.data_lock);
+	core_link->link.state = link_state;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_media_jack_led_set(core_link->core_lgrp->core_ldev->num, core_link->core_lgrp->num);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"set (link_state = %u %s)",
+			link_state, sl_core_link_state_str(link_state));
+}
+
+int sl_core_data_link_state_get(struct sl_core_link *core_link,
+				enum sl_core_link_state *link_state)
+{
+	spin_lock(&core_link->link.data_lock);
+	*link_state = core_link->link.state;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"get (link_state = %u %s)",
+			*link_state, sl_core_link_state_str(*link_state));
+
+	return 0;
+}
+
+int sl_core_data_link_speed_get(struct sl_core_link *core_link, u32 *link_speed)
+{
+	u32 state;
+
+	spin_lock(&core_link->link.data_lock);
+	state       = core_link->link.state;
+	*link_speed = core_link->pcs.settings.speed;
+	spin_unlock(&core_link->link.data_lock);
+
+	if (state != SL_CORE_LINK_STATE_UP &&
+	    state != SL_CORE_LINK_STATE_GOING_DOWN) {
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "get speed no link (state = %u %s)",
+				       state, sl_core_link_state_str(state));
+		return -ENOLINK;
+	}
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get speed = %u", *link_speed);
+
+	return 0;
+}
+
+u16 sl_core_data_link_clocking_get(struct sl_core_link *core_link)
+{
+	u16 link_clocking;
+
+	spin_lock(&core_link->link.data_lock);
+	link_clocking = core_link->serdes.core_serdes_settings.clocking;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"get clocking = %u", link_clocking);
+
+	return link_clocking;
+}
+
+void sl_core_data_link_info_map_clr(struct sl_core_link *core_link, u32 bit_num)
+{
+	unsigned long irq_flags;
+
+	spin_lock_irqsave(&core_link->irq_data_lock, irq_flags);
+
+	if (bit_num == SL_CORE_INFO_MAP_NUM_BITS)
+		bitmap_zero((unsigned long *)&(core_link->info_map), SL_CORE_INFO_MAP_NUM_BITS);
+	else
+		clear_bit(bit_num, (unsigned long *)&(core_link->info_map));
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"clr info map 0x%016llX", core_link->info_map);
+
+	spin_unlock_irqrestore(&core_link->irq_data_lock, irq_flags);
+}
+
+void sl_core_data_link_info_map_set(struct sl_core_link *core_link, u32 bit_num)
+{
+	unsigned long irq_flags;
+
+	spin_lock_irqsave(&core_link->irq_data_lock, irq_flags);
+
+	set_bit(bit_num, (unsigned long *)&(core_link->info_map));
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"set info map 0x%016llX", core_link->info_map);
+
+	spin_unlock_irqrestore(&core_link->irq_data_lock, irq_flags);
+}
+
+u64 sl_core_data_link_info_map_get(struct sl_core_link *core_link)
+{
+	u64           info_map;
+	unsigned long irq_flags;
+
+	spin_lock_irqsave(&core_link->irq_data_lock, irq_flags);
+	info_map = core_link->info_map;
+	spin_unlock_irqrestore(&core_link->irq_data_lock, irq_flags);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"get info map 0x%016llX", info_map);
+
+	return info_map;
+}
+
+void sl_core_data_link_is_last_down_new_set(struct sl_core_link *core_link, bool is_last_down_new)
+{
+	spin_lock(&core_link->link.data_lock);
+	core_link->link.is_last_down_new = is_last_down_new;
+	spin_unlock(&core_link->link.data_lock);
+}
+
+void sl_core_data_link_last_down_cause_map_set(struct sl_core_link *core_link, u64 down_cause_map)
+{
+	struct sl_ctrl_link *held_link_1 __free(sl_ctrl_link_put) = NULL;
+	spin_lock(&core_link->link.data_lock);
+
+	if (core_link->link.is_last_down_new) {
+		core_link->link.last_down_entry_num++;
+		if (core_link->link.last_down_entry_num >= SL_CTRL_LAST_DOWN_NUM_ENTRIES)
+			core_link->link.last_down_entry_num = 0;
+
+		core_link->link.last_down_cause_map[core_link->link.last_down_entry_num] = down_cause_map;
+		core_link->link.last_down_time[core_link->link.last_down_entry_num]      = ktime_get_real_seconds();
+
+		core_link->link.is_last_down_new = false;
+	} else {
+		core_link->link.last_down_cause_map[core_link->link.last_down_entry_num] |= down_cause_map;
+	}
+
+	spin_unlock(&core_link->link.data_lock);
+
+	held_link_1 = sl_ctrl_link_get(core_link->core_lgrp->core_ldev->num,
+				       core_link->core_lgrp->num, core_link->num);
+	if (!held_link_1)
+		return;
+	sl_ctrl_link_cause_counter_inc(held_link_1, down_cause_map);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last down cause map set (num = %u, down_cause_map = 0x%llX)",
+			core_link->link.last_down_entry_num, down_cause_map);
+}
+
+int sl_core_data_link_last_down_cause_map_info_get(struct sl_core_link *core_link,
+						   u8                   entry_num,
+						    u64                 *down_cause_map,
+						    time64_t            *down_time)
+{
+	u8 actual_entry_num;
+
+	spin_lock(&core_link->link.data_lock);
+
+	if (entry_num > core_link->link.last_down_entry_num)
+		actual_entry_num = SL_CTRL_LAST_DOWN_NUM_ENTRIES - (entry_num - core_link->link.last_down_entry_num);
+	else
+		actual_entry_num = core_link->link.last_down_entry_num - entry_num;
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last down cause map info get (entry_num = %u, last_down_num = %u, actual_num = %u",
+			entry_num, core_link->link.last_down_entry_num, actual_entry_num);
+
+	*down_cause_map = core_link->link.last_down_cause_map[actual_entry_num];
+	*down_time      = core_link->link.last_down_time[actual_entry_num];
+
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last down cause map info get (down_cause_map = 0x%llX, down_time = %lld %ptTt %ptTd)",
+			*down_cause_map, *down_time, down_time, down_time);
+
+	return 0;
+}
+
+u64 sl_core_data_link_last_down_cause_map_get(struct sl_core_link *core_link)
+{
+	u64 down_cause_map;
+
+	spin_lock(&core_link->link.data_lock);
+	down_cause_map = core_link->link.last_down_cause_map[core_link->link.last_down_entry_num];
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last down cause map get (down_cause_map = 0x%llX)", down_cause_map);
+
+	return down_cause_map;
+}
+
+void sl_core_data_link_is_last_up_fail_new_set(struct sl_core_link *core_link, bool is_last_up_fail_new)
+{
+	spin_lock(&core_link->link.data_lock);
+	core_link->link.is_last_up_fail_new = is_last_up_fail_new;
+	spin_unlock(&core_link->link.data_lock);
+}
+
+void sl_core_data_link_last_up_fail_cause_map_set(struct sl_core_link *core_link, u64 up_fail_cause_map)
+{
+	struct sl_ctrl_link *held_link_1 __free(sl_ctrl_link_put) = NULL;
+	spin_lock(&core_link->link.data_lock);
+
+	if (core_link->link.is_last_up_fail_new) {
+		core_link->link.last_up_fail_entry_num++;
+		if (core_link->link.last_up_fail_entry_num >= SL_CTRL_LAST_UP_FAIL_NUM_ENTRIES)
+			core_link->link.last_up_fail_entry_num = 0;
+
+		core_link->link.last_up_fail_cause_map[core_link->link.last_up_fail_entry_num] = up_fail_cause_map;
+		core_link->link.last_up_fail_time[core_link->link.last_up_fail_entry_num]      = ktime_get_real_seconds();
+
+		core_link->link.is_last_up_fail_new = false;
+	} else {
+		core_link->link.last_up_fail_cause_map[core_link->link.last_up_fail_entry_num] |= up_fail_cause_map;
+	}
+
+	spin_unlock(&core_link->link.data_lock);
+
+	held_link_1 = sl_ctrl_link_get(core_link->core_lgrp->core_ldev->num,
+				       core_link->core_lgrp->num, core_link->num);
+	if (!held_link_1)
+		return;
+	sl_ctrl_link_cause_counter_inc(held_link_1, up_fail_cause_map);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last up_fail cause map set (num = %u, up_fail_cause_map = 0x%llX)",
+			core_link->link.last_up_fail_entry_num, up_fail_cause_map);
+}
+
+int sl_core_data_link_last_up_fail_cause_map_info_get(struct sl_core_link *core_link,
+						      u8                   entry_num,
+						       u64                 *up_fail_cause_map,
+						       time64_t            *up_fail_time)
+{
+	u8 actual_entry_num;
+
+	spin_lock(&core_link->link.data_lock);
+
+	if (entry_num > core_link->link.last_up_fail_entry_num)
+		actual_entry_num = SL_CTRL_LAST_UP_FAIL_NUM_ENTRIES - (entry_num - core_link->link.last_up_fail_entry_num);
+	else
+		actual_entry_num = core_link->link.last_up_fail_entry_num - entry_num;
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last up_fail cause map info get (entry_num = %u, last_up_fail_num = %u, actual_num = %u",
+			entry_num, core_link->link.last_up_fail_entry_num, actual_entry_num);
+
+	*up_fail_cause_map = core_link->link.last_up_fail_cause_map[actual_entry_num];
+	*up_fail_time      = core_link->link.last_up_fail_time[actual_entry_num];
+
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last up_fail cause map info get (up_fail_cause_map = 0x%llX, up_fail_time = %lld %ptTt %ptTd)",
+			*up_fail_cause_map, *up_fail_time, up_fail_time, up_fail_time);
+
+	return 0;
+}
+
+u64 sl_core_data_link_last_up_fail_cause_map_get(struct sl_core_link *core_link)
+{
+	u64 up_fail_cause_map;
+
+	spin_lock(&core_link->link.data_lock);
+	up_fail_cause_map = core_link->link.last_up_fail_cause_map[core_link->link.last_up_fail_entry_num];
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"last up_fail cause map get (up_fail_cause_map = 0x%llX)", up_fail_cause_map);
+
+	return up_fail_cause_map;
+}
+
+void sl_core_data_link_ccw_warn_limit_crossed_set(struct sl_core_link *core_link, bool is_limit_crossed)
+{
+	spin_lock(&core_link->link.data_lock);
+	core_link->link.is_ccw_warn_limit_crossed = is_limit_crossed;
+	core_link->link.last_ccw_warn_limit_crossed_time  = ktime_get_real_seconds();
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"ccw warn limit crossed set (is_limit_crossed = %d %s)", core_link->link.is_ccw_warn_limit_crossed,
+		core_link->link.is_ccw_warn_limit_crossed ? "yes" : "no");
+}
+
+int sl_core_data_link_ccw_warn_limit_crossed_get(struct sl_core_link *core_link, bool *is_limit_crossed,
+						 time64_t *limit_crossed_time)
+{
+	spin_lock(&core_link->link.data_lock);
+	*is_limit_crossed = core_link->link.is_ccw_warn_limit_crossed;
+	*limit_crossed_time = core_link->link.last_ccw_warn_limit_crossed_time;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"ccw warn limit crossed get (is_limit_crossed = %d %s)", *is_limit_crossed,
+			*is_limit_crossed ? "yes" : "no");
+
+	return 0;
+}
+
+void sl_core_data_link_ucw_warn_limit_crossed_set(struct sl_core_link *core_link, bool is_limit_crossed)
+{
+	spin_lock(&core_link->link.data_lock);
+	core_link->link.is_ucw_warn_limit_crossed = is_limit_crossed;
+	core_link->link.last_ucw_warn_limit_crossed_time  = ktime_get_real_seconds();
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"ucw warn limit crossed set (is_limit_crossed = %d %s)", core_link->link.is_ucw_warn_limit_crossed,
+		core_link->link.is_ucw_warn_limit_crossed ? "yes" : "no");
+}
+
+int sl_core_data_link_ucw_warn_limit_crossed_get(struct sl_core_link *core_link, bool *is_limit_crossed,
+						 time64_t *limit_crossed_time)
+{
+	spin_lock(&core_link->link.data_lock);
+	*is_limit_crossed = core_link->link.is_ucw_warn_limit_crossed;
+	*limit_crossed_time = core_link->link.last_ucw_warn_limit_crossed_time;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"ucw warn limit crossed get (is_limit_crossed = %d %s)", *is_limit_crossed,
+			*is_limit_crossed ? "yes" : "no");
+
+	return 0;
+}
+
+u32 sl_core_data_link_fec_mode_get(struct sl_core_link *core_link)
+{
+	u32 fec_mode;
+
+	spin_lock(&core_link->link.data_lock);
+	fec_mode = core_link->fec.settings.mode;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"fec_mode get = %u %s", fec_mode, sl_lgrp_fec_mode_str(fec_mode));
+
+	return fec_mode;
+}
+
+u32 sl_core_data_link_fec_type_get(struct sl_core_link *core_link)
+{
+	u32 fec_type;
+
+	spin_lock(&core_link->link.data_lock);
+	fec_type = core_link->fec.settings.type;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"fec_type get = %u %s", fec_type, sl_lgrp_config_fec_str(fec_type));
+
+	return fec_type;
+}
+
+u32 sl_core_data_link_an_lp_caps_state_get(struct sl_core_link *core_link)
+{
+	u32 lp_caps_state;
+
+	spin_lock(&core_link->an.data_lock);
+	lp_caps_state = core_link->an.lp_caps_state;
+	spin_unlock(&core_link->an.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "lp caps state get (lp_caps_state = %u %s)",
+			lp_caps_state, sl_link_an_lp_caps_state_str(lp_caps_state));
+
+	return lp_caps_state;
+}
+
+void sl_core_data_link_an_lp_caps_state_set(struct sl_core_link *core_link, u32 lp_caps_state)
+{
+	spin_lock(&core_link->an.data_lock);
+	core_link->an.lp_caps_state = lp_caps_state;
+	spin_unlock(&core_link->an.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "lp caps state set (lp_caps_state = %u %s)",
+			lp_caps_state, sl_link_an_lp_caps_state_str(lp_caps_state));
+}
+
+int sl_core_data_link_an_fail_cause_get(struct sl_core_link *core_link, u32 *fail_cause, time64_t *fail_time)
+{
+	unsigned long irq_flags;
+
+	spin_lock_irqsave(&core_link->irq_data_lock, irq_flags);
+	*fail_cause = core_link->an.fail_cause;
+	*fail_time  = core_link->an.fail_time;
+	spin_unlock_irqrestore(&core_link->irq_data_lock, irq_flags);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "an fail cause get (fail_cause = %u %s)",
+			*fail_cause, sl_core_link_an_fail_cause_str(*fail_cause));
+
+	return 0;
+}
+
+void sl_core_data_link_an_fail_cause_set(struct sl_core_link *core_link, u32 fail_cause)
+{
+	struct sl_ctrl_link *held_link_1 __free(sl_ctrl_link_put) = NULL;
+	unsigned long irq_flags;
+
+	spin_lock_irqsave(&core_link->irq_data_lock, irq_flags);
+	core_link->an.fail_cause = fail_cause;
+	core_link->an.fail_time  = ktime_get_real_seconds();
+	spin_unlock_irqrestore(&core_link->irq_data_lock, irq_flags);
+
+	held_link_1 = sl_ctrl_link_get(core_link->core_lgrp->core_ldev->num,
+				       core_link->core_lgrp->num, core_link->num);
+	if (!held_link_1)
+		return;
+	sl_ctrl_link_an_cause_counter_inc(held_link_1,
+					  fail_cause);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "an fail cause set (fail_cause = %u %s)",
+			fail_cause, sl_core_link_an_fail_cause_str(fail_cause));
+}
+
+u32 sl_core_data_link_an_retry_count_get(struct sl_core_link *core_link)
+{
+	u32 retry_count;
+
+	retry_count = atomic_read(&core_link->an.retry_count);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "an retry count get (retry_count = %u)", retry_count);
+
+	return retry_count;
+}
+
+u32 sl_core_data_link_config_flags_get(struct sl_core_link *core_link)
+{
+	u32 flags;
+
+	spin_lock(&core_link->data_lock);
+	flags = core_link->config.flags;
+	spin_unlock(&core_link->data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "config flags get (flags = 0x%X)", flags);
+
+	return flags;
+}
+
+static char *sl_core_link_degrade_state_str(int degrade_state)
+{
+	switch (degrade_state) {
+	case SL_LINK_DEGRADE_STATE_INVALID:
+		return "invalid";
+	case SL_LINK_DEGRADE_STATE_ACTIVE:
+		return "active";
+	case SL_LINK_DEGRADE_STATE_INACTIVE:
+		return "inactive";
+	case SL_LINK_DEGRADE_STATE_FAILED:
+		return "failed";
+	default:
+		return "unknown";
+	}
+}
+
+int sl_core_data_link_degrade_state_get(struct sl_core_link *core_link, int *degrade_state)
+{
+	spin_lock(&core_link->link.data_lock);
+	*degrade_state = core_link->degrade_state;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (degrade_state = %d %s",
+			*degrade_state, sl_core_link_degrade_state_str(*degrade_state));
+
+	return 0;
+}
+
+int sl_core_data_link_is_rx_degrade_get(struct sl_core_link *core_link, bool *is_rx_degrade)
+{
+	spin_lock(&core_link->link.data_lock);
+	*is_rx_degrade = core_link->degrade_info.is_rx_degrade;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (is_rx_degrade = %s)", *is_rx_degrade ? "yes" : "no");
+
+	return 0;
+}
+
+int sl_core_data_link_is_tx_degrade_get(struct sl_core_link *core_link, bool *is_tx_degrade)
+{
+	spin_lock(&core_link->link.data_lock);
+	*is_tx_degrade = core_link->degrade_info.is_tx_degrade;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (is_tx_degrade = %s)", *is_tx_degrade ? "yes" : "no");
+
+	return 0;
+}
+
+int sl_core_data_link_degrade_tx_link_speed_get(struct sl_core_link *core_link, u16 *tx_link_speed)
+{
+	int degrade_state;
+
+	spin_lock(&core_link->link.data_lock);
+	*tx_link_speed = core_link->degrade_info.tx_link_speed;
+	degrade_state = core_link->degrade_state;
+	spin_unlock(&core_link->link.data_lock);
+
+	if (degrade_state != SL_LINK_DEGRADE_STATE_ACTIVE) {
+		sl_core_log_dbg(core_link, LOG_NAME, "get tx_link_speed failed (degrade_state = %d %s)",
+				degrade_state, sl_core_link_degrade_state_str(degrade_state));
+		return -EBADRQC;
+	}
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (tx_link_speed = %u)", *tx_link_speed);
+
+	return 0;
+}
+
+int sl_core_data_link_degrade_rx_link_speed_get(struct sl_core_link *core_link, u16 *rx_link_speed)
+{
+	int degrade_state;
+
+	spin_lock(&core_link->link.data_lock);
+	*rx_link_speed = core_link->degrade_info.rx_link_speed;
+	degrade_state = core_link->degrade_state;
+	spin_unlock(&core_link->link.data_lock);
+
+	if (degrade_state != SL_LINK_DEGRADE_STATE_ACTIVE) {
+		sl_core_log_dbg(core_link, LOG_NAME, "get rx_link_speed failed (degrade_state = %d %s)",
+				degrade_state, sl_core_link_degrade_state_str(degrade_state));
+		return -EBADRQC;
+	}
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (rx_link_speed = %u)", *rx_link_speed);
+
+	return 0;
+}
+
+int sl_core_data_link_degrade_tx_degrade_map_get(struct sl_core_link *core_link, u8 *tx_degrade_map)
+{
+	int degrade_state;
+
+	spin_lock(&core_link->link.data_lock);
+	*tx_degrade_map = core_link->degrade_info.tx_degrade_map;
+	degrade_state = core_link->degrade_state;
+	spin_unlock(&core_link->link.data_lock);
+
+	if (degrade_state != SL_LINK_DEGRADE_STATE_ACTIVE) {
+		sl_core_log_dbg(core_link, LOG_NAME, "get tx_degrade_map failed (degrade_state = %d %s)",
+				degrade_state, sl_core_link_degrade_state_str(degrade_state));
+		return -EBADRQC;
+	}
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (tx_degrade_map = 0x%02X)", *tx_degrade_map);
+
+	return 0;
+}
+
+int sl_core_data_link_degrade_rx_degrade_map_get(struct sl_core_link *core_link, u8 *rx_degrade_map)
+{
+	int degrade_state;
+
+	spin_lock(&core_link->link.data_lock);
+	*rx_degrade_map = core_link->degrade_info.rx_degrade_map;
+	degrade_state = core_link->degrade_state;
+	spin_unlock(&core_link->link.data_lock);
+
+	if (degrade_state != SL_LINK_DEGRADE_STATE_ACTIVE) {
+		sl_core_log_dbg(core_link, LOG_NAME, "get rx_degrade_map failed (degrade_state = %d %s)",
+				degrade_state, sl_core_link_degrade_state_str(degrade_state));
+		return -EBADRQC;
+	}
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (rx_degrade_map = 0x%02X)", *rx_degrade_map);
+
+	return 0;
+}
+
+int sl_core_data_link_degrade_is_recoverable_get(struct sl_core_link *core_link, bool *is_recoverable)
+{
+	int degrade_state;
+
+	spin_lock(&core_link->link.data_lock);
+	*is_recoverable = core_link->degrade_info.is_recoverable;
+	degrade_state = core_link->degrade_state;
+	spin_unlock(&core_link->link.data_lock);
+
+	if (degrade_state != SL_LINK_DEGRADE_STATE_ACTIVE) {
+		sl_core_log_dbg(core_link, LOG_NAME, "get is_recoverable failed (degrade_state = %d %s)",
+				degrade_state, sl_core_link_degrade_state_str(degrade_state));
+		return -EBADRQC;
+	}
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (is_recoverable = %u)", *is_recoverable);
+
+	return 0;
+}
+
+int sl_core_data_link_pml_rec_attempts_get(struct sl_core_link *core_link, int *attempts)
+{
+	*attempts = atomic_read(&core_link->pml_rec.pml_rec_info.pml_rec_counters[SL_LINK_PML_REC_ATTEMPTS]);
+
+	return 0;
+}
+
+int sl_core_data_link_pml_rec_successes_get(struct sl_core_link *core_link, int *successes)
+{
+	*successes = atomic_read(&core_link->pml_rec.pml_rec_info.pml_rec_counters[SL_LINK_PML_REC_SUCCESSES]);
+
+	return 0;
+}
+
+int sl_core_data_link_pml_rec_link_fault_cause_get(struct sl_core_link *core_link, int *fault_cause)
+{
+	*fault_cause = atomic_read(&core_link->pml_rec.pml_rec_info.pml_rec_counters[SL_LINK_PML_REC_LINK_LOCAL_FAULT_CAUSE]);
+
+	return 0;
+}
+
+int sl_core_data_link_pml_rec_link_down_cause_get(struct sl_core_link *core_link, int *down_cause)
+{
+	*down_cause = atomic_read(&core_link->pml_rec.pml_rec_info.pml_rec_counters[SL_LINK_PML_REC_LINK_DOWN_CAUSE]);
+
+	return 0;
+}
+
+int sl_core_data_link_pml_rec_link_fault_failed_cause_get(struct sl_core_link *core_link, int *fault_failed_cause)
+{
+	*fault_failed_cause = atomic_read(&core_link->pml_rec.pml_rec_info.pml_rec_counters[SL_LINK_PML_REC_LINK_LOCAL_FAULT_FAILED_CAUSE]);
+
+	return 0;
+}
+
+int sl_core_data_link_pml_rec_link_down_failed_cause_get(struct sl_core_link *core_link, int *down_failed_cause)
+{
+	*down_failed_cause = atomic_read(&core_link->pml_rec.pml_rec_info.pml_rec_counters[SL_LINK_PML_REC_LINK_DOWN_FAILED_CAUSE]);
+
+	return 0;
+}
+
+int sl_core_data_link_pml_rec_rate_limit_exceeded_get(struct sl_core_link *core_link, int *rate_limit_exceeded)
+{
+	*rate_limit_exceeded = atomic_read(&core_link->pml_rec.pml_rec_info.pml_rec_counters[SL_LINK_PML_REC_RATE_LIMIT_EXCEEDED]);
+
+	return 0;
+}
+
+int sl_core_data_link_fec_up_settle_wait_ms_get(struct sl_core_link *core_link, u32 *fec_settle_wait_ms)
+{
+	spin_lock(&core_link->link.data_lock);
+	*fec_settle_wait_ms = core_link->fec.settings.up_settle_wait_ms;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (fec_settle_wait_ms = %u)", *fec_settle_wait_ms);
+
+	return 0;
+}
+
+int sl_core_data_link_fec_up_check_wait_ms_get(struct sl_core_link *core_link, u32 *fec_check_wait_ms)
+{
+	spin_lock(&core_link->link.data_lock);
+	*fec_check_wait_ms = core_link->fec.settings.up_check_wait_ms;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (fec_check_wait_ms = %u)", *fec_check_wait_ms);
+
+	return 0;
+}
+
+int sl_core_data_link_fec_up_ucw_limit_get(struct sl_core_link *core_link, s32 *fec_up_ucw_limit)
+{
+	spin_lock(&core_link->link.data_lock);
+	*fec_up_ucw_limit = core_link->fec.settings.up_ucw_limit;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (fec_up_ucw_limit = %d)", *fec_up_ucw_limit);
+
+	return 0;
+}
+
+int sl_core_data_link_fec_up_ccw_limit_get(struct sl_core_link *core_link, s32 *fec_up_ccw_limit)
+{
+	spin_lock(&core_link->link.data_lock);
+	*fec_up_ccw_limit = core_link->fec.settings.up_ccw_limit;
+	spin_unlock(&core_link->link.data_lock);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "get (fec_up_ccw_limit = %d)", *fec_up_ccw_limit);
+
+	return 0;
+}

@@ -0,0 +1,526 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022,2023,2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+
+#include <linux/hpe/sl/sl_lgrp.h>
+#include <linux/hpe/sl/sl_media.h>
+
+#include "base/sl_core_log.h"
+#include "sl_core_lgrp.h"
+#include "sl_core_llr.h"
+#include "sl_core_str.h"
+#include "hw/sl_core_hw_llr.h"
+#include "hw/sl_core_hw_intr_llr.h"
+#include "sl_core_hw_intr_flgs_llr.h"
+#include "data/sl_core_data_llr.h"
+#include "sl_ctrl_llr_counters.h"
+
+static struct sl_core_llr *core_llrs[SL_ASIC_MAX_LDEVS][SL_ASIC_MAX_LGRPS][SL_ASIC_MAX_LINKS];
+static DEFINE_SPINLOCK(core_llrs_lock);
+
+#define LOG_NAME SL_CORE_DATA_LLR_LOG_NAME
+
+#define SL_CORE_TIMER_LLR_INIT(_llr, _timer_num, _work_num, _log)        \
+	do {                                                             \
+		(_llr)->timers[_timer_num].data.core_llr   = _llr;       \
+		(_llr)->timers[_timer_num].data.timer_num  = _timer_num; \
+		(_llr)->timers[_timer_num].data.work_num   = _work_num;  \
+		strscpy_pad((_llr)->timers[_timer_num].data.log, _log,  \
+			sizeof((_llr)->timers[_timer_num].data.log));    \
+	} while (0)
+#define SL_CORE_INTR_LLR_INIT(_llr, _intr_num, _work_num, _log)           \
+	do {                                                              \
+		(_llr)->intrs[_intr_num].flgs =                           \
+			sl_core_hw_intr_flgs_llr[_intr_num][(_llr)->num]; \
+		(_llr)->intrs[_intr_num].data.core_llr = _llr;            \
+		(_llr)->intrs[_intr_num].data.intr_num = _intr_num;       \
+		(_llr)->intrs[_intr_num].data.work_num = _work_num;       \
+		strscpy_pad((_llr)->intrs[_intr_num].data.log, _log,     \
+			sizeof((_llr)->intrs[_intr_num].data.log));       \
+	} while (0)
+
+int sl_core_data_llr_new(u8 ldev_num, u8 lgrp_num, u8 llr_num)
+{
+	int                 rtn;
+	struct sl_core_llr *core_llr;
+
+	core_llr = sl_core_data_llr_get(ldev_num, lgrp_num, llr_num);
+	if (core_llr) {
+		sl_core_log_err(NULL, LOG_NAME, "exists (llr = 0x%p)", core_llr);
+		return -EBADRQC;
+	}
+
+	core_llr = kzalloc(sizeof(struct sl_core_llr), GFP_KERNEL);
+	if (!core_llr)
+		return -ENOMEM;
+
+	core_llr->magic               = SL_CORE_LLR_MAGIC;
+	core_llr->num                 = llr_num;
+	core_llr->core_lgrp           = sl_core_lgrp_get(ldev_num, lgrp_num);
+	if (!core_llr->core_lgrp) {
+		kfree(core_llr);
+		return -ENODEV;
+	}
+	core_llr->last_fail_cause     = SL_LLR_FAIL_CAUSE_NONE;
+
+	spin_lock_init(&core_llr->data_lock);
+
+	sl_core_hw_llr_stop(core_llr);
+	sl_core_data_llr_state_set(core_llr, SL_CORE_LLR_STATE_NEW);
+	init_completion(&core_llr->stop_complete);
+
+	timer_setup(&(core_llr->timers[SL_CORE_TIMER_LLR_SETUP].timer),
+		    sl_core_timer_llr_timeout, 0);
+	SL_CORE_TIMER_LLR_INIT(core_llr, SL_CORE_TIMER_LLR_SETUP,
+			       SL_CORE_WORK_LLR_SETUP_TIMEOUT, "llr setup");
+	timer_setup(&(core_llr->timers[SL_CORE_TIMER_LLR_START].timer),
+		    sl_core_timer_llr_timeout, 0);
+	SL_CORE_TIMER_LLR_INIT(core_llr, SL_CORE_TIMER_LLR_START,
+			       SL_CORE_WORK_LLR_START_TIMEOUT, "llr start");
+
+	INIT_WORK(&(core_llr->work[SL_CORE_WORK_LLR_SETUP]),
+		  sl_core_hw_llr_setup_work);
+	INIT_WORK(&(core_llr->work[SL_CORE_WORK_LLR_SETUP_TIMEOUT]),
+		  sl_core_hw_llr_setup_timeout_work);
+	INIT_WORK(&(core_llr->work[SL_CORE_WORK_LLR_SETUP_UNEXP_LOOP_TIME_INTR]),
+		  sl_core_hw_llr_setup_unexp_loop_time_intr_work);
+	INIT_WORK(&(core_llr->work[SL_CORE_WORK_LLR_SETUP_LOOP_TIME_INTR]),
+		  sl_core_hw_llr_setup_loop_time_intr_work);
+	INIT_WORK(&(core_llr->work[SL_CORE_WORK_LLR_START]),
+		  sl_core_hw_llr_start_work);
+	INIT_WORK(&(core_llr->work[SL_CORE_WORK_LLR_START_TIMEOUT]),
+		  sl_core_hw_llr_start_timeout_work);
+	INIT_WORK(&(core_llr->work[SL_CORE_WORK_LLR_START_INIT_COMPLETE_INTR]),
+		  sl_core_hw_llr_start_init_complete_intr_work);
+
+	SL_CORE_INTR_LLR_INIT(core_llr, SL_CORE_HW_INTR_LLR_SETUP_UNEXP_LOOP_TIME,
+			      SL_CORE_WORK_LLR_SETUP_UNEXP_LOOP_TIME_INTR, "llr setup unexp loop time");
+	SL_CORE_INTR_LLR_INIT(core_llr, SL_CORE_HW_INTR_LLR_SETUP_LOOP_TIME,
+			      SL_CORE_WORK_LLR_SETUP_LOOP_TIME_INTR, "llr setup loop time");
+	SL_CORE_INTR_LLR_INIT(core_llr, SL_CORE_HW_INTR_LLR_START_INIT_COMPLETE,
+			      SL_CORE_WORK_LLR_START_INIT_COMPLETE_INTR, "llr start init complete");
+
+	rtn = sl_core_hw_intr_llr_hdlr_register(core_llr);
+	if (rtn != 0) {
+		sl_core_log_err(core_llr, LOG_NAME,
+				"core_hw_intr_llr_hdlr_register failed [%d]", rtn);
+		sl_core_lgrp_put(core_llr->core_lgrp);
+		kfree(core_llr);
+		return rtn;
+	}
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "new (llr = 0x%p)", core_llr);
+
+	spin_lock(&core_llrs_lock);
+	core_llrs[ldev_num][lgrp_num][llr_num] = core_llr;
+	spin_unlock(&core_llrs_lock);
+
+	return 0;
+}
+
+void sl_core_data_llr_del(u8 ldev_num, u8 lgrp_num, u8 llr_num)
+{
+	struct sl_core_llr *core_llr;
+
+	core_llr = sl_core_llr_get(ldev_num, lgrp_num, llr_num);
+	if (!core_llr) {
+		sl_core_log_err(NULL, LOG_NAME, "not found (llr_num = %u)", llr_num);
+		return;
+	}
+
+	spin_lock(&core_llrs_lock);
+	core_llrs[ldev_num][lgrp_num][llr_num] = NULL;
+	spin_unlock(&core_llrs_lock);
+
+	sl_core_timer_llr_end(core_llr, SL_CORE_TIMER_LLR_SETUP);
+	sl_core_timer_llr_end(core_llr, SL_CORE_TIMER_LLR_START);
+
+	cancel_work_sync(&(core_llr->work[SL_CORE_WORK_LLR_SETUP]));
+	cancel_work_sync(&(core_llr->work[SL_CORE_WORK_LLR_SETUP_TIMEOUT]));
+	cancel_work_sync(&(core_llr->work[SL_CORE_WORK_LLR_START]));
+	cancel_work_sync(&(core_llr->work[SL_CORE_WORK_LLR_START_TIMEOUT]));
+
+	sl_core_hw_intr_llr_flgs_disable(core_llr, SL_CORE_HW_INTR_LLR_SETUP_UNEXP_LOOP_TIME);
+	sl_core_hw_intr_llr_flgs_disable(core_llr, SL_CORE_HW_INTR_LLR_SETUP_LOOP_TIME);
+	sl_core_hw_intr_llr_flgs_disable(core_llr, SL_CORE_HW_INTR_LLR_START_INIT_COMPLETE);
+
+	cancel_work_sync(&(core_llr->work[SL_CORE_WORK_LLR_SETUP_UNEXP_LOOP_TIME_INTR]));
+	cancel_work_sync(&(core_llr->work[SL_CORE_WORK_LLR_SETUP_LOOP_TIME_INTR]));
+	cancel_work_sync(&(core_llr->work[SL_CORE_WORK_LLR_START_INIT_COMPLETE_INTR]));
+
+	sl_core_hw_intr_llr_hdlr_unregister(core_llr);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "del (llr = 0x%p)", core_llr);
+
+	sl_core_lgrp_put(core_llr->core_lgrp);
+	kfree(core_llr);
+}
+
+struct sl_core_llr *sl_core_data_llr_get(u8 ldev_num, u8 lgrp_num, u8 llr_num)
+{
+	struct sl_core_llr *core_llr;
+
+	spin_lock(&core_llrs_lock);
+	core_llr = core_llrs[ldev_num][lgrp_num][llr_num];
+	spin_unlock(&core_llrs_lock);
+
+	sl_core_log_dbg(NULL, LOG_NAME,
+			"get (ldev_num = %u, lgrp_num = %u, llr_num = %u, llr = 0x%p)",
+			ldev_num, lgrp_num, llr_num, core_llr);
+
+	return core_llr;
+}
+
+#define SL_CORE_DATA_LLR_CONFIG_SETUP_TIMEOUT_MS     3000
+#define SL_CORE_DATA_LLR_CONFIG_SETUP_TIMEOUT_MAX_MS 180000
+#define SL_CORE_DATA_LLR_CONFIG_START_TIMEOUT_MS     3000
+#define SL_CORE_DATA_LLR_CONFIG_START_TIMEOUT_MAX_MS 180000
+int sl_core_data_llr_config_set(struct sl_core_llr *core_llr, struct sl_llr_config *llr_config)
+{
+	core_llr->settings.size              = 1;
+	core_llr->settings.lossless_when_off = 1;
+
+	switch (llr_config->link_dn_behavior) {
+	default:
+	case SL_LLR_LINK_DN_BEHAVIOR_DISCARD:
+		core_llr->settings.link_down_behavior = SS2_PORT_PML_LINK_DN_BEHAVIOR_T_LD_DISCARD;
+		break;
+	case SL_LLR_LINK_DN_BEHAVIOR_BLOCK:
+		core_llr->settings.link_down_behavior = SS2_PORT_PML_LINK_DN_BEHAVIOR_T_LD_BLOCK;
+		break;
+	case SL_LLR_LINK_DN_BEHAVIOR_BEST_EFFORT:
+		core_llr->settings.link_down_behavior = SS2_PORT_PML_LINK_DN_BEHAVIOR_T_LD_BEST_EFFORT;
+		break;
+	}
+
+	core_llr->settings.filter_ctl_frames   = 1;
+	core_llr->settings.ctl_frame_smac      = 0;
+	core_llr->settings.ctl_frame_ethertype = 0x88B6;
+	core_llr->settings.retry_threshold     = 2;
+	core_llr->settings.allow_re_init       = 0;
+	core_llr->settings.replay_ct_max       = 0xFF;
+	core_llr->settings.replay_timer_max    = 15500;
+
+	if ((llr_config->setup_timeout_ms <= 0) ||
+	    (llr_config->setup_timeout_ms > SL_CORE_DATA_LLR_CONFIG_SETUP_TIMEOUT_MAX_MS)) {
+		sl_core_log_warn_trace(core_llr, LOG_NAME,
+				       "config set setting setup timeout to default (%ums)",
+			SL_CORE_DATA_LLR_CONFIG_SETUP_TIMEOUT_MS);
+		core_llr->timers[SL_CORE_TIMER_LLR_SETUP].data.timeout_ms = SL_CORE_DATA_LLR_CONFIG_SETUP_TIMEOUT_MS;
+	} else {
+		core_llr->timers[SL_CORE_TIMER_LLR_SETUP].data.timeout_ms = llr_config->setup_timeout_ms;
+	}
+	if ((llr_config->start_timeout_ms <= 0) ||
+	    (llr_config->start_timeout_ms > SL_CORE_DATA_LLR_CONFIG_START_TIMEOUT_MAX_MS)) {
+		sl_core_log_warn_trace(core_llr, LOG_NAME,
+				       "config set setting start timeout to default (%ums)",
+			SL_CORE_DATA_LLR_CONFIG_START_TIMEOUT_MS);
+		core_llr->timers[SL_CORE_TIMER_LLR_START].data.timeout_ms = SL_CORE_DATA_LLR_CONFIG_START_TIMEOUT_MS;
+	} else {
+		core_llr->timers[SL_CORE_TIMER_LLR_START].data.timeout_ms = llr_config->start_timeout_ms;
+	}
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"config set settings (link_dn_behavior %u %s = %u)",
+		llr_config->link_dn_behavior, sl_llr_link_dn_behavior_str(llr_config->link_dn_behavior),
+		core_llr->settings.link_down_behavior);
+
+	return 0;
+}
+
+int sl_core_data_llr_policy_set(struct sl_core_llr *core_llr, struct sl_llr_policy *llr_policy)
+{
+	sl_core_log_dbg(core_llr, LOG_NAME, "policy set");
+
+	spin_lock(&core_llr->data_lock);
+	core_llr->policy = *llr_policy;
+	spin_unlock(&core_llr->data_lock);
+
+	return 0;
+}
+
+int sl_core_data_llr_policy_get(struct sl_core_llr *core_llr, struct sl_llr_policy *llr_policy)
+{
+	sl_core_log_dbg(core_llr, LOG_NAME, "policy get");
+
+	spin_lock(&core_llr->data_lock);
+	*llr_policy = core_llr->policy;
+	spin_unlock(&core_llr->data_lock);
+
+	return 0;
+}
+
+int sl_core_data_llr_settings(struct sl_core_llr *core_llr)
+{
+	struct sl_lgrp_config *lgrp_config;
+	struct sl_link_caps   *link_caps;
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "settings");
+
+	sl_core_data_llr_last_fail_cause_set(core_llr, SL_LLR_FAIL_CAUSE_NONE);
+
+	lgrp_config = &(core_llr->core_lgrp->config);
+	link_caps   = &(core_llr->core_lgrp->link_caps[core_llr->num]);
+
+	if (hweight_long(link_caps->tech_map) != 1) {
+		sl_core_log_err_trace(core_llr, LOG_NAME,
+				      "settings - tech map invalid (map = 0x%08X)",
+			link_caps->tech_map);
+		sl_core_data_llr_last_fail_cause_set(core_llr, SL_LLR_FAIL_CAUSE_SETUP_CONFIG);
+		return -EINVAL;
+	}
+
+	if (SL_LGRP_CONFIG_TECH_CK_400G & link_caps->tech_map)
+		core_llr->settings.bytes_per_ns = 50;
+	if (SL_LGRP_CONFIG_TECH_CK_200G & link_caps->tech_map)
+		core_llr->settings.bytes_per_ns = 25;
+	if (SL_LGRP_CONFIG_TECH_CK_100G & link_caps->tech_map)
+		core_llr->settings.bytes_per_ns = 13;
+	if (SL_LGRP_CONFIG_TECH_BS_200G & link_caps->tech_map)
+		core_llr->settings.bytes_per_ns = 25;
+	if (SL_LGRP_CONFIG_TECH_CD_100G & link_caps->tech_map)
+		core_llr->settings.bytes_per_ns = 13;
+	if (SL_LGRP_CONFIG_TECH_CD_50G  & link_caps->tech_map)
+		core_llr->settings.bytes_per_ns = 7;
+	if (SL_LGRP_CONFIG_TECH_BJ_100G & link_caps->tech_map)
+		core_llr->settings.bytes_per_ns = 13;
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "settings (bytes = %u)", core_llr->settings.bytes_per_ns);
+
+	if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_FABRIC)) {
+		core_llr->settings.max_cap_data   = 0x800ULL;
+		core_llr->settings.max_cap_seq    = 0x800ULL;
+	} else {
+		switch (lgrp_config->furcation) {
+		case SL_MEDIA_FURCATION_X1:
+			core_llr->settings.max_cap_data   = 0x800ULL;
+			core_llr->settings.max_cap_seq    = 0x800ULL;
+			break;
+		case SL_MEDIA_FURCATION_X2:
+			core_llr->settings.max_cap_data   = 0x400ULL;
+			core_llr->settings.max_cap_seq    = 0x400ULL;
+			break;
+		case SL_MEDIA_FURCATION_X4:
+			core_llr->settings.max_cap_data   = 0x200ULL;
+			core_llr->settings.max_cap_seq    = 0x200ULL;
+			break;
+		}
+	}
+
+	return 0;
+}
+
+void sl_core_data_llr_state_set(struct sl_core_llr *core_llr,
+				enum sl_core_llr_state llr_state)
+{
+	spin_lock(&core_llr->data_lock);
+	core_llr->state = llr_state;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "set (llr_state = %u %s)",
+			llr_state, sl_core_llr_state_str(llr_state));
+}
+
+int sl_core_data_llr_state_get(struct sl_core_llr *core_llr,
+			       enum sl_core_llr_state *llr_state)
+{
+	spin_lock(&core_llr->data_lock);
+	*llr_state = core_llr->state;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "get (llr_state = %u %s)",
+			*llr_state, sl_core_llr_state_str(*llr_state));
+
+	return 0;
+}
+
+void sl_core_data_llr_data_set(struct sl_core_llr *core_llr, struct sl_llr_data llr_data)
+{
+	spin_lock(&core_llr->data_lock);
+	core_llr->is_data_valid = true;
+	core_llr->data          = llr_data;
+	core_llr->data.magic    = SL_CORE_LLR_DATA_MAGIC;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"data set (min = %lldns, max = %lldns, average = %lldns, calc = %lldns)",
+		llr_data.loop.min, llr_data.loop.max,
+		llr_data.loop.average, llr_data.loop.calculated);
+}
+
+struct sl_llr_data sl_core_data_llr_data_get(struct sl_core_llr *core_llr)
+{
+	struct sl_llr_data llr_data;
+
+	spin_lock(&core_llr->data_lock);
+	llr_data = core_llr->data;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"data get (min = %lluns, max = %lluns, average = %lluns, calc = %lluns)",
+		llr_data.loop.min, llr_data.loop.max,
+		llr_data.loop.average, llr_data.loop.calculated);
+
+	return llr_data;
+}
+
+void sl_core_data_llr_data_clr(struct sl_core_llr *core_llr)
+{
+	sl_core_log_dbg(core_llr, LOG_NAME, "data clear");
+
+	spin_lock(&core_llr->data_lock);
+	core_llr->is_data_valid = false;
+	memset(&(core_llr->data), 0, sizeof(core_llr->data));
+	spin_unlock(&core_llr->data_lock);
+}
+
+bool sl_core_data_llr_data_is_valid(struct sl_core_llr *core_llr)
+{
+	bool is_valid;
+
+	spin_lock(&core_llr->data_lock);
+	is_valid = core_llr->is_data_valid;
+	spin_unlock(&core_llr->data_lock);
+
+	return is_valid;
+}
+
+void sl_core_data_llr_info_map_clr(struct sl_core_llr *core_llr, u32 bit_num)
+{
+	spin_lock(&core_llr->data_lock);
+
+	if (bit_num == SL_CORE_INFO_MAP_NUM_BITS)
+		bitmap_zero((unsigned long *)&(core_llr->info_map), SL_CORE_INFO_MAP_NUM_BITS);
+	else
+		clear_bit(bit_num, (unsigned long *)&(core_llr->info_map));
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"clr info map 0x%016llX", core_llr->info_map);
+
+	spin_unlock(&core_llr->data_lock);
+}
+
+void sl_core_data_llr_info_map_set(struct sl_core_llr *core_llr, u32 bit_num)
+{
+	spin_lock(&core_llr->data_lock);
+	set_bit(bit_num, (unsigned long *)&(core_llr->info_map));
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"set info map 0x%016llX", core_llr->info_map);
+
+	spin_unlock(&core_llr->data_lock);
+}
+
+int sl_core_data_llr_info_map_get(struct sl_core_llr *core_llr, u64 *info_map)
+{
+	spin_lock(&core_llr->data_lock);
+	*info_map = core_llr->info_map;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"get (info_map = 0x%016llX)", *info_map);
+
+	return 0;
+}
+
+int sl_core_data_llr_last_fail_cause_get(struct sl_core_llr *core_llr, u32 *llr_fail_cause,
+					 time64_t *llr_fail_time)
+{
+	spin_lock(&core_llr->data_lock);
+	*llr_fail_cause = core_llr->last_fail_cause;
+	*llr_fail_time  = core_llr->last_fail_time;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"last llr fail cause get (cause = %u %s)", *llr_fail_cause,
+		sl_core_llr_fail_cause_str(*llr_fail_cause));
+
+	return 0;
+}
+
+void sl_core_data_llr_last_fail_cause_set(struct sl_core_llr *core_llr, u32 llr_fail_cause)
+{
+	spin_lock(&core_llr->data_lock);
+	core_llr->last_fail_cause = llr_fail_cause;
+	core_llr->last_fail_time  = ktime_get_real_seconds();
+	spin_unlock(&core_llr->data_lock);
+
+	sl_ctrl_llr_cause_counter_inc(core_llr, llr_fail_cause);
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"last llr fail cause set (cause = %u %s)", llr_fail_cause, sl_core_llr_fail_cause_str(llr_fail_cause));
+}
+
+int sl_core_data_llr_policy_options_get(struct sl_core_llr *core_llr, u32 *options)
+{
+	spin_lock(&core_llr->data_lock);
+	*options = core_llr->policy.options;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "get (options = 0x%X)", *options);
+
+	return 0;
+}
+
+int sl_core_data_llr_loop_time_get(struct sl_core_llr *core_llr, u64 *loop_time)
+{
+	spin_lock(&core_llr->data_lock);
+	memcpy(loop_time, core_llr->loop_time, sizeof(core_llr->loop_time));
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME,
+			"get (loop time 0 = %lluns, 1 = %lluns, 2 = %lluns, 3 = %lluns, 4 = %lluns, "
+			"5 = %lluns, 6 = %lluns, 7 = %lluns, 8 = %lluns, 9 = %lluns)",
+			loop_time[0], loop_time[1], loop_time[2], loop_time[3], loop_time[4],
+			loop_time[5], loop_time[6], loop_time[7], loop_time[8], loop_time[9]);
+
+	return 0;
+}
+
+int sl_core_data_llr_loop_calculated_ns_get(struct sl_core_llr *core_llr, u64 *calculated_ns)
+{
+	spin_lock(&core_llr->data_lock);
+	*calculated_ns = core_llr->data.loop.calculated;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "get (calculated_ns = %lldns)", *calculated_ns);
+
+	return 0;
+}
+
+int sl_core_data_llr_loop_min_ns_get(struct sl_core_llr *core_llr, u64 *min_ns)
+{
+	spin_lock(&core_llr->data_lock);
+	*min_ns = core_llr->data.loop.min;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "get (min_ns = %lldns)", *min_ns);
+
+	return 0;
+}
+
+int sl_core_data_llr_loop_max_ns_get(struct sl_core_llr *core_llr, u64 *max_ns)
+{
+	spin_lock(&core_llr->data_lock);
+	*max_ns = core_llr->data.loop.max;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "get (max_ns = %lldns)", *max_ns);
+
+	return 0;
+}
+
+int sl_core_data_llr_loop_average_ns_get(struct sl_core_llr *core_llr, u64 *average_ns)
+{
+	spin_lock(&core_llr->data_lock);
+	*average_ns = core_llr->data.loop.average;
+	spin_unlock(&core_llr->data_lock);
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "get (average_ns = %lldns)", *average_ns);
+
+	return 0;
+}

@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022,2023,2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#include <linux/hpe/sl/sl_lgrp.h>
+#include <linux/hpe/sl/sl_media.h>
+
+#include "base/sl_core_log.h"
+#include "sl_core_lgrp.h"
+#include "sl_core_mac.h"
+#include "hw/sl_core_hw_intr.h"
+#include "data/sl_core_data_link.h"
+#include "data/sl_core_data_mac.h"
+#include "hw/sl_core_hw_mac.h"
+#include "hw/sl_core_hw_settings.h"
+
+static struct sl_core_mac *core_macs[SL_ASIC_MAX_LDEVS][SL_ASIC_MAX_LGRPS][SL_ASIC_MAX_LINKS];
+static DEFINE_SPINLOCK(core_macs_lock);
+
+#define LOG_NAME SL_CORE_DATA_MAC_LOG_NAME
+
+int sl_core_data_mac_new(u8 ldev_num, u8 lgrp_num, u8 mac_num)
+{
+	struct sl_core_mac *core_mac;
+
+	core_mac = sl_core_data_mac_get(ldev_num, lgrp_num, mac_num);
+	if (core_mac) {
+		sl_core_log_err(NULL, LOG_NAME, "exists (mac = 0x%p)", core_mac);
+		return -EBADRQC;
+	}
+
+	core_mac = kzalloc(sizeof(struct sl_core_mac), GFP_KERNEL);
+	if (!core_mac)
+		return -ENOMEM;
+
+	core_mac->magic     = SL_CORE_MAC_MAGIC;
+	core_mac->num       = mac_num;
+	core_mac->core_lgrp = sl_core_lgrp_get(ldev_num, lgrp_num);
+	if (!core_mac->core_lgrp) {
+		kfree(core_mac);
+		return -ENODEV;
+	}
+
+	spin_lock_init(&core_mac->data_lock);
+
+	sl_core_hw_mac_tx_stop(core_mac);
+	sl_core_hw_mac_rx_stop(core_mac);
+
+	sl_core_log_dbg(core_mac, LOG_NAME, "new (link = 0x%p)", core_mac);
+
+	spin_lock(&core_macs_lock);
+	core_macs[ldev_num][lgrp_num][mac_num] = core_mac;
+	spin_unlock(&core_macs_lock);
+
+	return 0;
+}
+
+void sl_core_data_mac_del(u8 ldev_num, u8 lgrp_num, u8 mac_num)
+{
+	struct sl_core_mac *core_mac;
+
+	core_mac = sl_core_mac_get(ldev_num, lgrp_num, mac_num);
+	if (!core_mac) {
+		sl_core_log_dbg(NULL, LOG_NAME, "not found (mac_num = %u)", mac_num);
+		return;
+	}
+
+	sl_core_hw_mac_tx_stop(core_mac);
+	sl_core_hw_mac_rx_stop(core_mac);
+
+	spin_lock(&core_macs_lock);
+	core_macs[ldev_num][lgrp_num][mac_num] = NULL;
+	spin_unlock(&core_macs_lock);
+
+	sl_core_log_dbg(core_mac, LOG_NAME, "del (mac = 0x%p)", core_mac);
+
+	sl_core_lgrp_put(core_mac->core_lgrp);
+	kfree(core_mac);
+}
+
+struct sl_core_mac *sl_core_data_mac_get(u8 ldev_num, u8 lgrp_num, u8 mac_num)
+{
+	struct sl_core_mac *core_mac;
+
+	spin_lock(&core_macs_lock);
+	core_mac = core_macs[ldev_num][lgrp_num][mac_num];
+	spin_unlock(&core_macs_lock);
+
+	sl_core_log_dbg(NULL, LOG_NAME,
+			"get (ldev_num = %u, lgrp_num = %u, mac_num = %u, mac = 0x%p)",
+			ldev_num, lgrp_num, mac_num, core_mac);
+
+	return core_mac;
+}
+
+int sl_core_data_mac_tx_settings(struct sl_core_mac *core_mac)
+{
+	struct sl_lgrp_config *lgrp_config;
+	struct sl_link_caps   *link_caps;
+
+	sl_core_log_dbg(core_mac, LOG_NAME, "tx settings");
+
+	lgrp_config = &(core_mac->core_lgrp->config);
+	link_caps   = &(core_mac->core_lgrp->link_caps[core_mac->num]);
+
+	if (hweight_long(link_caps->tech_map) != 1) {
+		sl_core_log_err_trace(core_mac, LOG_NAME, "tx settings - tech map invalid (map = 0x%08X)",
+				      link_caps->tech_map);
+		return -EINVAL;
+	}
+
+	if (SL_LGRP_CONFIG_TECH_CK_400G & link_caps->tech_map)
+		core_mac->settings.tx_ifg_adj = SL_CORE_HW_IFG_ADJ_400G;
+	if (SL_LGRP_CONFIG_TECH_CK_200G & link_caps->tech_map)
+		core_mac->settings.tx_ifg_adj = SL_CORE_HW_IFG_ADJ_200G;
+	if (SL_LGRP_CONFIG_TECH_CK_100G & link_caps->tech_map)
+		core_mac->settings.tx_ifg_adj = SL_CORE_HW_IFG_ADJ_100G;
+	if (SL_LGRP_CONFIG_TECH_BS_200G & link_caps->tech_map)
+		core_mac->settings.tx_ifg_adj = SL_CORE_HW_IFG_ADJ_200G;
+	if (SL_LGRP_CONFIG_TECH_CD_100G & link_caps->tech_map)
+		core_mac->settings.tx_ifg_adj = SL_CORE_HW_IFG_ADJ_100G;
+	if (SL_LGRP_CONFIG_TECH_CD_50G  & link_caps->tech_map)
+		core_mac->settings.tx_ifg_adj = SL_CORE_HW_IFG_ADJ_50G;
+	if (SL_LGRP_CONFIG_TECH_BJ_100G & link_caps->tech_map)
+		core_mac->settings.tx_ifg_adj = SL_CORE_HW_IFG_ADJ_100G;
+
+	sl_core_log_dbg(core_mac, LOG_NAME, "tx settings (ifg = %u)", core_mac->settings.tx_ifg_adj);
+
+	if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_FABRIC)) {
+		core_mac->settings.tx_ifg_adj          = SL_CORE_HW_IFG_ADJ_NONE;
+		core_mac->settings.tx_ifg_mode         = 0;
+		core_mac->settings.tx_pad_idle_thresh  = 10;
+		core_mac->settings.tx_idle_delay       = 0;
+		core_mac->settings.tx_priority_thresh  = 0;
+		core_mac->settings.tx_cdt_thresh_2     = 0;
+		core_mac->settings.tx_cdt_thresh       = 15;
+		core_mac->settings.tx_cdt_init_val     = 72;
+		core_mac->settings.tx_pcs_credits      = 8;
+		core_mac->settings.tx_short_preamble   = 1;
+		core_mac->settings.llr_if_credits      = 8;
+	} else {
+		core_mac->settings.tx_ifg_mode         = 1;
+		core_mac->settings.tx_pad_idle_thresh  = 10;
+		switch (lgrp_config->furcation) {
+		case SL_MEDIA_FURCATION_X1:
+			core_mac->settings.tx_idle_delay      = 0;
+			core_mac->settings.tx_priority_thresh = 0;
+			core_mac->settings.tx_cdt_thresh_2    = 0;
+			core_mac->settings.tx_cdt_thresh      = 15;
+			core_mac->settings.tx_cdt_init_val    = sl_core_data_mac_tx_cdt_init_get();
+			core_mac->settings.tx_pcs_credits     = 8;
+			core_mac->settings.llr_if_credits     = 8;
+			break;
+		case SL_MEDIA_FURCATION_X2:
+			core_mac->settings.tx_idle_delay      = 0;
+			core_mac->settings.tx_priority_thresh = 32;
+			core_mac->settings.tx_cdt_thresh_2    = 32;
+			core_mac->settings.tx_cdt_thresh      = 15;
+			core_mac->settings.tx_cdt_init_val    = 72;
+			core_mac->settings.tx_pcs_credits     = 4;
+			core_mac->settings.llr_if_credits     = 4;
+			break;
+		case SL_MEDIA_FURCATION_X4:
+			core_mac->settings.tx_idle_delay      = 1;
+			core_mac->settings.tx_priority_thresh = 23;
+			core_mac->settings.tx_cdt_thresh_2    = 20;
+			core_mac->settings.tx_cdt_thresh      = 12;
+			core_mac->settings.tx_cdt_init_val    = 40;
+			core_mac->settings.tx_pcs_credits     = 2;
+			core_mac->settings.llr_if_credits     = 2;
+			break;
+		}
+		core_mac->settings.tx_short_preamble = 0;
+	}
+
+	if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_8BYTE_PREAMBLE))
+		core_mac->settings.tx_short_preamble = 0;
+
+	return 0;
+}
+
+int sl_core_data_mac_rx_settings(struct sl_core_mac *core_mac)
+{
+	struct sl_lgrp_config *lgrp_config;
+
+	sl_core_log_dbg(core_mac, LOG_NAME, "rx settings");
+
+	lgrp_config = &(core_mac->core_lgrp->config);
+
+	if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_FABRIC)) {
+		core_mac->settings.rx_flit_packing_cnt = 1;
+		core_mac->settings.rx_short_preamble   = 1;
+	} else {
+		core_mac->settings.rx_flit_packing_cnt = 1;
+		core_mac->settings.rx_short_preamble   = 0;
+	}
+
+	if (is_flag_set(lgrp_config->options, SL_LGRP_CONFIG_OPT_8BYTE_PREAMBLE))
+		core_mac->settings.rx_short_preamble   = 0;
+
+	return 0;
+}
+
+u32 sl_core_data_mac_tx_state_get(struct sl_core_mac *core_mac)
+{
+	switch (sl_core_hw_mac_tx_state_get(core_mac)) {
+	case 0:
+		sl_core_log_dbg(core_mac, LOG_NAME, "get TX OFF");
+		return SL_CORE_MAC_STATE_OFF;
+	case 1:
+		sl_core_log_dbg(core_mac, LOG_NAME, "get TX ON");
+		return SL_CORE_MAC_STATE_ON;
+	}
+
+	return SL_CORE_MAC_STATE_INVALID;
+}
+
+u32 sl_core_data_mac_rx_state_get(struct sl_core_mac *core_mac)
+{
+	switch (sl_core_hw_mac_rx_state_get(core_mac)) {
+	case 0:
+		sl_core_log_dbg(core_mac, LOG_NAME, "get RX OFF");
+		return SL_CORE_MAC_STATE_OFF;
+	case 1:
+		sl_core_log_dbg(core_mac, LOG_NAME, "get RX ON");
+		return SL_CORE_MAC_STATE_ON;
+	}
+
+	return SL_CORE_MAC_STATE_INVALID;
+}
+
+void sl_core_data_mac_info_map_clr(struct sl_core_mac *core_mac, u32 bit_num)
+{
+	spin_lock(&core_mac->data_lock);
+
+	if (bit_num == SL_CORE_INFO_MAP_NUM_BITS)
+		bitmap_zero((unsigned long *)&(core_mac->info_map), SL_CORE_INFO_MAP_NUM_BITS);
+	else
+		clear_bit(bit_num, (unsigned long *)&(core_mac->info_map));
+
+	sl_core_log_dbg(core_mac, LOG_NAME,
+			"clr info map 0x%016llX", core_mac->info_map);
+
+	spin_unlock(&core_mac->data_lock);
+}
+
+void sl_core_data_mac_info_map_set(struct sl_core_mac *core_mac, u32 bit_num)
+{
+	spin_lock(&core_mac->data_lock);
+	set_bit(bit_num, (unsigned long *)&(core_mac->info_map));
+
+	sl_core_log_dbg(core_mac, LOG_NAME,
+			"set info map 0x%016llX", core_mac->info_map);
+
+	spin_unlock(&core_mac->data_lock);
+}
+
+u64 sl_core_data_mac_info_map_get(struct sl_core_mac *core_mac)
+{
+	u64 info_map;
+
+	spin_lock(&core_mac->data_lock);
+	info_map = core_mac->info_map;
+	spin_unlock(&core_mac->data_lock);
+
+	sl_core_log_dbg(core_mac, LOG_NAME,
+			"get info map 0x%016llX", info_map);
+
+	return info_map;
+}

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+
+#include "base/sl_core_log.h"
+#include "sl_core_link.h"
+#include "hw/sl_core_hw_io.h"
+#include "hw/sl_core_hw_an.h"
+
+#define LOG_NAME SL_CORE_HW_AN_LOG_NAME
+
+void sl_core_hw_an_config_timers(struct sl_core_link *core_link)
+{
+	u32                                       port;
+	union ss2_port_pml_cfg_pcs_autoneg_timers autoneg_timers = {};
+
+	port = core_link->core_lgrp->num;
+	autoneg_timers.link_fail_inhibit_timer_max = 0x3FFFFFFFF;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "config timers (port = %d)", port);
+
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG_TIMERS + 8, autoneg_timers.qw[1]);
+
+	sl_core_flush64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG_TIMERS + 8);
+}

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+
+#include "sl_core_ldev.h"
+#include "sl_core_link.h"
+#include "sl_core_link_fec.h"
+#include "base/sl_core_log.h"
+#include "hw/sl_core_hw_fec.h"
+
+#define LOG_NAME SL_CORE_HW_FEC_LOG_NAME
+
+static int sl_core_hw_fec_dmac_xfer(struct sl_core_link *core_link, void *data)
+{
+	int                   rtn;
+	struct sl_core_ldev  *core_ldev;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "dmac_xfer");
+
+	core_ldev = core_link->core_lgrp->core_ldev;
+
+	if (!core_ldev->ops.dmac_xfer) {
+		sl_core_log_dbg(core_link, LOG_NAME, "dmac_xfer NULL");
+		return 0;
+	}
+
+	rtn = core_ldev->ops.dmac_xfer(core_ldev->accessors.dmac, data);
+	if (rtn) {
+		sl_core_log_err(core_link, LOG_NAME, "op dmac_xfer failed [%d]", rtn);
+		return rtn;
+	}
+
+	return 0;
+}
+
+int sl_core_hw_fec_cw_cntrs_get(struct sl_core_link *core_link, struct sl_core_link_fec_cw_cntrs *cw_cntrs)
+{
+	int                                rtn;
+	struct sl_core_link_fec_data_cntrs data_cntrs;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "cw_cntrs_get");
+
+	rtn = sl_core_hw_fec_dmac_xfer(core_link, &data_cntrs);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "cw_cntrs_get dmac_xfer failed [%d]", rtn);
+		return rtn;
+	}
+
+	*cw_cntrs = data_cntrs.cw_cntrs;
+
+	return 0;
+}
+
+int sl_core_hw_fec_lane_cntrs_get(struct sl_core_link *core_link, struct sl_core_link_fec_lane_cntrs *lane_cntrs)
+{
+	int                                rtn;
+	struct sl_core_link_fec_data_cntrs data_cntrs;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "lane_cntrs_get");
+
+	rtn = sl_core_hw_fec_dmac_xfer(core_link, &data_cntrs);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "lane_cntrs_get dmac_xfer failed [%d]", rtn);
+		return rtn;
+	}
+
+	*lane_cntrs = data_cntrs.lane_cntrs;
+
+	return 0;
+}
+
+int sl_core_hw_fec_tail_cntrs_get(struct sl_core_link *core_link,
+				  struct sl_core_link_fec_tail_cntrs *tail_cntrs)
+{
+	int                                rtn;
+	struct sl_core_link_fec_data_cntrs data_cntrs;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "tail_cntr_get");
+
+	rtn = sl_core_hw_fec_dmac_xfer(core_link, &data_cntrs);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "tail_cntr_get dmac_xfer failed [%d]", rtn);
+		return rtn;
+	}
+
+	*tail_cntrs = data_cntrs.tail_cntrs;
+
+	return 0;
+}
+
+int sl_core_hw_fec_data_get(struct sl_core_link *core_link,
+			    struct sl_core_link_fec_cw_cntrs *cw_cntrs,
+			    struct sl_core_link_fec_lane_cntrs *lane_cntrs,
+			    struct sl_core_link_fec_tail_cntrs *tail_cntr)
+{
+	int                                rtn;
+	struct sl_core_link_fec_data_cntrs data_cntrs;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "fec_data_get");
+
+	rtn = sl_core_hw_fec_dmac_xfer(core_link, &data_cntrs);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "fec_data_get dmac_xfer failed [%d]", rtn);
+		return rtn;
+	}
+
+	*cw_cntrs    = data_cntrs.cw_cntrs;
+	*lane_cntrs  = data_cntrs.lane_cntrs;
+	*tail_cntr   = data_cntrs.tail_cntrs;
+
+	return 0;
+}

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2025,2026 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+
+#include "base/sl_core_log.h"
+#include "sl_core_link.h"
+#include "hw/sl_core_hw_io.h"
+#include "hw/sl_core_hw_llr.h"
+
+#define LOG_NAME SL_CORE_HW_LLR_LOG_NAME
+
+void sl_core_hw_llr_config_timeouts(struct sl_core_llr *core_llr)
+{
+	u32                  port;
+	u64                  data64;
+	struct sl_core_link *core_link __free(sl_core_link_put) = NULL;
+	bool                 is_pml_rec_enabled;
+
+	port = core_llr->core_lgrp->num;
+
+	sl_core_log_dbg(core_llr, LOG_NAME, "config timeouts (port = %d)", port);
+
+	core_link = sl_core_link_get(core_llr->core_lgrp->core_ldev->num, core_llr->core_lgrp->num, core_llr->num);
+	if (!core_link)
+		return;
+
+	is_pml_rec_enabled = sl_core_link_config_is_enable_pml_recovery_set(core_link);
+
+	sl_core_llr_read64(core_llr, SS2_PORT_PML_CFG_LLR_TIMEOUTS(core_llr->num), &data64);
+	if (is_pml_rec_enabled) {
+		data64 = SS2_PORT_PML_CFG_LLR_TIMEOUTS_DATA_AGE_TIMER_MAX_UPDATE(data64,
+										 (core_link->config.pml_rec_timeout_ms + 8) * 1000000);
+		data64 = SS2_PORT_PML_CFG_LLR_TIMEOUTS_PCS_LINK_DN_TIMER_MAX_UPDATE(data64,
+										    (core_link->config.pml_rec_timeout_ms + 8) * 1000000);
+	} else {
+		data64 = SS2_PORT_PML_CFG_LLR_TIMEOUTS_DATA_AGE_TIMER_MAX_UPDATE(data64, 0xEE6B2800);
+		data64 = SS2_PORT_PML_CFG_LLR_TIMEOUTS_PCS_LINK_DN_TIMER_MAX_UPDATE(data64, 0x389ACA00);
+	}
+
+	sl_core_llr_write64(core_llr, SS2_PORT_PML_CFG_LLR_TIMEOUTS(core_llr->num), data64);
+
+	sl_core_llr_flush64(core_llr, SS2_PORT_PML_CFG_LLR_TIMEOUTS(core_llr->num));
+}

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+
+#include "base/sl_core_log.h"
+#include "sl_core_mac.h"
+#include "hw/sl_core_hw_io.h"
+#include "hw/sl_core_hw_mac.h"
+
+#define LOG_NAME SL_CORE_HW_MAC_LOG_NAME
+
+void sl_core_hw_mac_tx_config_subport(struct sl_core_mac *core_mac)
+{
+	u64 data64;
+	u32 port;
+
+	port = core_mac->core_lgrp->num;
+
+	sl_core_log_dbg(core_mac, LOG_NAME, "tx config subport (port = %d)", port);
+
+	sl_core_mac_read64(core_mac, SS2_PORT_PML_CFG_TX_MAC_SUBPORT(core_mac->num), &data64);
+	data64 = SS2_PORT_PML_CFG_TX_MAC_SUBPORT_MAC_CDT_THRESH_UPDATE(data64,
+								       core_mac->settings.tx_cdt_thresh);
+	data64 = SS2_PORT_PML_CFG_TX_MAC_SUBPORT_MAC_CDT_INIT_VAL_UPDATE(data64,
+									 core_mac->settings.tx_cdt_init_val);
+	data64 = SS2_PORT_PML_CFG_TX_MAC_SUBPORT_SHORT_PREAMBLE_UPDATE(data64,
+								       core_mac->settings.tx_short_preamble);
+	sl_core_mac_write64(core_mac, SS2_PORT_PML_CFG_TX_MAC_SUBPORT(core_mac->num), data64);
+
+	sl_core_mac_flush64(core_mac, SS2_PORT_PML_CFG_TX_MAC_SUBPORT(core_mac->num));
+}

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2026 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+
+#include "sl_core_link.h"
+#include "hw/sl_core_hw_pcs.h"
+
+#define LOG_NAME SL_CORE_HW_PCS_LOG_NAME
+
+void sl_core_hw_pcs_keep_all_lanes_active_set(struct sl_core_link *core_link, u64 value)
+{
+	/* TODO: Add graceful lane-degrade support, currently absent from SL. */
+}

@@ -0,0 +1,602 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022,2023,2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/random.h>
+#include <linux/workqueue.h>
+
+#include "sl_core_link.h"
+#include "base/sl_core_log.h"
+#include "hw/sl_core_hw_intr.h"
+#include "data/sl_core_data_link.h"
+#include "hw/sl_core_hw_io.h"
+#include "hw/sl_core_hw_an.h"
+#include "hw/sl_core_hw_pcs.h"
+
+#define LOG_NAME SL_CORE_HW_AN_LOG_NAME
+
+#define SL_CORE_HW_AN_STATE_COMPLETE_ACK  5
+#define SL_CORE_HW_AN_STATE_AN_GOOD_CHECK 9
+
+void sl_core_hw_an_tx_pages_encode(struct sl_core_link *core_link, struct sl_link_caps *my_caps)
+{
+	int x;
+
+	memset(core_link->an.tx_pages, 0, sizeof(core_link->an.tx_pages));
+
+	/* 1 - base page */
+	core_link->an.tx_pages[0] |= SL_CORE_HW_AN_BP_802_3;
+	core_link->an.tx_pages[0] |= ((u64)(my_caps->pause_map & SL_LINK_CONFIG_PAUSE_MASK) <<
+		SL_CORE_HW_AN_BP_PAUSE_SHIFT);
+	core_link->an.tx_pages[0] |= ((u64)(my_caps->tech_map & SL_LGRP_CONFIG_TECH_MASK) <<
+		SL_CORE_HW_AN_BP_TECH_SHIFT);
+	core_link->an.tx_pages[0] |= ((u64)(my_caps->fec_map & SL_LGRP_CONFIG_FEC_MASK) <<
+		SL_CORE_HW_AN_BP_FEC_SHIFT);
+
+	/* 2 - OUI message next page */
+	set_bit(SL_CORE_HW_AN_NP_BIT_MP, (unsigned long *)&(core_link->an.tx_pages[1]));
+	core_link->an.tx_pages[1] |= SL_CORE_HW_AN_NP_MSG_OUI_EXTD;
+	core_link->an.tx_pages[1] |= SL_CORE_HW_AN_NP_OUI_HPE;
+
+	/* 3 - unformatted page with OUI message next page */
+	core_link->an.tx_pages[2] |= SL_CORE_HW_AN_NP_OUI_VER_0_1;
+	core_link->an.tx_pages[2] |= ((my_caps->hpe_map & SL_LINK_CONFIG_HPE_MASK) <<
+		SL_CORE_HW_AN_NP_HPE_SHIFT);
+	core_link->an.tx_pages[2] |= (2ULL << SL_CORE_HW_AN_NP_BIT_OUI_ASIC_VER);
+
+	core_link->an.tx_count = 3;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "tx pages encode (count = %u)", core_link->an.tx_count);
+	for (x = 0; x < core_link->an.tx_count; ++x)
+		sl_core_log_dbg(core_link, LOG_NAME,
+				"tx pages encode pages (%d = 0x%016llX)", x, core_link->an.tx_pages[x]);
+}
+
+#define SL_CORE_HW_AN_NUONCE_MASK 0xF
+static u64 sl_core_hw_an_nonce_get(struct sl_core_link *core_link)
+{
+	u8 num;
+
+	do {
+		get_random_bytes(&num, sizeof(num));
+		num &= SL_CORE_HW_AN_NUONCE_MASK;
+	} while (num == 0);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "nonce = 0x%X", num);
+
+	return num;
+}
+
+void sl_core_hw_an_stop(struct sl_core_link *core_link)
+{
+	u64 data64;
+	u32 port;
+
+	port = core_link->core_lgrp->num;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "stop (port = %u)", port);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_PCS_AUTONEG_RESET_UPDATE(data64, 1);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), data64);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_PCS_SUBPORT(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_PCS_SUBPORT_ENABLE_AUTO_NEG_UPDATE(data64, 0);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_SUBPORT(core_link->num), data64);
+
+	sl_core_flush64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num));
+}
+
+static void sl_core_hw_an_start(struct sl_core_link *core_link)
+{
+	u64 data64;
+	u32 port;
+
+	port = core_link->core_lgrp->num;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "start (port = %u)", port);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_PCS_SUBPORT(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_PCS_SUBPORT_ENABLE_AUTO_NEG_UPDATE(data64, 1);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_SUBPORT(core_link->num), data64);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_PCS_AUTONEG_RESET_UPDATE(data64, 0);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), data64);
+
+	sl_core_flush64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num));
+}
+
+void sl_core_hw_an_init(struct sl_core_link *core_link)
+{
+	sl_core_log_dbg(core_link, LOG_NAME, "init");
+
+	core_link->an.state    = SL_CORE_HW_AN_STATE_START;
+	core_link->an.page_num = 0;
+	core_link->an.tx_count = 0;
+	core_link->an.rx_count = 0;
+	memset(core_link->an.rx_pages, 0, sizeof(core_link->an.rx_pages));
+}
+
+void sl_core_hw_an_config(struct sl_core_link *core_link)
+{
+	u64 data64;
+	u32 port;
+
+	port = core_link->core_lgrp->num;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "config (port = %d)", port);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_PCS_SUBPORT(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_PCS_SUBPORT_PCS_ENABLE_UPDATE(data64, 0);
+	data64 = SS2_PORT_PML_CFG_PCS_SUBPORT_ENABLE_AUTO_NEG_UPDATE(data64, 0);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_SUBPORT(core_link->num), data64);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_PCS_AUTONEG_RESET_UPDATE(data64, 1);
+	data64 = SS2_PORT_PML_CFG_PCS_AUTONEG_RESTART_UPDATE(data64, 0);
+	data64 = SS2_PORT_PML_CFG_PCS_AUTONEG_NEXT_PAGE_LOADED_UPDATE(data64, 0);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), data64);
+
+	sl_core_hw_pcs_config_swizzles(core_link);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_RX_PCS_SUBPORT(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_RX_PCS_SUBPORT_ENABLE_LOCK_UPDATE(data64, 0);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_RX_PCS_SUBPORT(core_link->num), data64);
+
+	sl_core_hw_an_config_timers(core_link);
+
+	sl_core_flush64(core_link, SS2_PORT_PML_CFG_RX_PCS);
+}
+
+static void sl_core_hw_an_base_page_write(struct sl_core_link *core_link)
+{
+	u32 port;
+	u64 page;
+
+	port = core_link->core_lgrp->num;
+	page = core_link->an.tx_pages[core_link->an.page_num];
+
+	/* add control bits */
+	if (core_link->an.page_num < core_link->an.tx_count - 1)
+		set_bit(SL_CORE_HW_AN_BP_BIT_NP, (unsigned long *)&(page));
+	page |= (sl_core_hw_an_nonce_get(core_link) << SL_CORE_HW_AN_BP_BIT_TRANS_NONCE);
+
+	/* store toggle bit */
+	core_link->an.toggle = test_bit(SL_CORE_HW_AN_NP_BIT_T, (unsigned long *)&(page));
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"base page write (port = %u, pg %u = 0x%016llX, toggle = %d)",
+		port, core_link->an.page_num, page, core_link->an.toggle);
+
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG_BASE_PAGE(core_link->num), page);
+
+	sl_core_flush64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG_BASE_PAGE(core_link->num));
+}
+
+static void sl_core_hw_an_next_page_write(struct sl_core_link *core_link)
+{
+	u32 port;
+	u64 page;
+
+	port = core_link->core_lgrp->num;
+	if (core_link->an.page_num < core_link->an.tx_count)
+		page = core_link->an.tx_pages[core_link->an.page_num];
+	else
+		page = SL_CORE_HW_AN_NP_MSG_NULL;
+
+	/* add control bits */
+	if (core_link->an.page_num < core_link->an.tx_count - 1)
+		set_bit(SL_CORE_HW_AN_NP_BIT_NP, (unsigned long *)&(page));
+	if (core_link->an.toggle)
+		set_bit(SL_CORE_HW_AN_NP_BIT_T, (unsigned long *)&(page));
+	core_link->an.toggle = !core_link->an.toggle;
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"next page write (port = %u, pg %u = 0x%016llX, toggle = %d)",
+		port, core_link->an.page_num, page, core_link->an.toggle);
+
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG_NEXT_PAGE(core_link->num), page);
+
+	sl_core_flush64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG_NEXT_PAGE(core_link->num));
+}
+
+static void sl_core_hw_an_next_page_go(struct sl_core_link *core_link)
+{
+	u64 data64;
+	u32 port;
+
+	port = core_link->core_lgrp->num;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "next page go (port = %u)", port);
+
+	sl_core_read64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), &data64);
+	data64 = SS2_PORT_PML_CFG_PCS_AUTONEG_NEXT_PAGE_LOADED_UPDATE(data64, 1);
+	sl_core_write64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num), data64);
+
+	sl_core_flush64(core_link, SS2_PORT_PML_CFG_PCS_AUTONEG(core_link->num));
+}
+
+int sl_core_hw_an_base_page_send(struct sl_core_link *core_link)
+{
+	int rtn;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "base page send (pg = %u)", core_link->an.page_num);
+
+	sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_NEXT_PAGE);
+	sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_ERROR);
+	sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_DONE);
+	sl_core_data_link_info_map_set(core_link, SL_CORE_INFO_MAP_AN_BASE_PAGE);
+	core_link->an.state = SL_CORE_HW_AN_STATE_BASE;
+
+	sl_core_hw_an_base_page_write(core_link);
+
+	sl_core_hw_intr_flgs_clr(core_link, SL_CORE_HW_INTR_AN_PAGE_RECV);
+
+	rtn = sl_core_hw_intr_enable(core_link,
+				     core_link->intrs[SL_CORE_HW_INTR_AN_PAGE_RECV].flgs, sl_core_hw_an_intr_hdlr);
+	if (rtn != 0) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "base page send intr enable failed [%d]", rtn);
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_BP_SEND_INTR_ENABLE_FAIL);
+		return rtn;
+	}
+
+	sl_core_hw_an_start(core_link);
+
+	return 0;
+}
+
+static int sl_core_hw_an_next_page_send(struct sl_core_link *core_link)
+{
+	sl_core_log_dbg(core_link, LOG_NAME, "next page send (pg = %u)", core_link->an.page_num);
+
+	sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_BASE_PAGE);
+	sl_core_data_link_info_map_set(core_link, SL_CORE_INFO_MAP_AN_NEXT_PAGE);
+	core_link->an.state = SL_CORE_HW_AN_STATE_NEXT;
+
+	sl_core_hw_an_next_page_write(core_link);
+
+	sl_core_hw_an_next_page_go(core_link);
+
+	return 0;
+}
+
+static void sl_core_hw_an_base_page_store(struct sl_core_link *core_link)
+{
+	u64 data64;
+	u32 port;
+	u64 state;
+
+	port = core_link->core_lgrp->num;
+
+	sl_core_read64(core_link, SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE(core_link->num), &data64);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"base page store (port = %u, pg %u = 0x%016llX, state = %llu)",
+		port, core_link->an.page_num, data64,
+		SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_STATE_GET(data64));
+
+	state = SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_STATE_GET(data64);
+	if ((state != SL_CORE_HW_AN_STATE_COMPLETE_ACK) &&
+	    (state != SL_CORE_HW_AN_STATE_AN_GOOD_CHECK)) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "base page store bad state (pg %u = 0x%016llX)",
+			core_link->an.page_num, data64);
+		sl_core_data_link_an_fail_cause_set(core_link, SL_CORE_HW_AN_FAIL_CAUSE_BP_STORE_STATE_BAD);
+		core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+		return;
+	}
+
+	if (!SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_LP_ABILITY_GET(data64)) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "base page store lp ability not set (pg %u = 0x%016llX)",
+			core_link->an.page_num, data64);
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_BP_STORE_LP_ABILITY_NOT_SET);
+		core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+		return;
+	}
+
+	if (!SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_BASE_PAGE_GET(data64)) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "base page store base page not set (pg %u = 0x%016llX)",
+			core_link->an.page_num, data64);
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_BP_STORE_BP_NOT_SET);
+		core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+		return;
+	}
+
+	core_link->an.rx_pages[core_link->an.page_num] =
+		SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_LP_BASE_PAGE_GET(data64);
+	core_link->an.rx_count++;
+
+	if (SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_COMPLETE_GET(data64)) {
+		core_link->an.state = SL_CORE_HW_AN_STATE_COMPLETE;
+		return;
+	}
+
+	if (!test_bit(SL_CORE_HW_AN_BP_BIT_NP,
+		      (unsigned long *)&(core_link->an.rx_pages[core_link->an.page_num]))) {
+		core_link->an.state = SL_CORE_HW_AN_STATE_LP_DONE;
+		return;
+	}
+}
+
+static void sl_core_hw_an_next_page_store(struct sl_core_link *core_link)
+{
+	u64 data64;
+	u32 port;
+	u64 state;
+
+	port = core_link->core_lgrp->num;
+
+	sl_core_read64(core_link, SS2_PORT_PML_STS_PCS_AUTONEG_NEXT_PAGE(core_link->num), &data64);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"next page store (port = %u, pg %u = 0x%016llX, state = %llu)",
+		port, core_link->an.page_num, data64,
+		SS2_PORT_PML_STS_PCS_AUTONEG_NEXT_PAGE_STATE_GET(data64));
+
+	state = SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_STATE_GET(data64);
+	if ((state != SL_CORE_HW_AN_STATE_COMPLETE_ACK) &&
+	    (state != SL_CORE_HW_AN_STATE_AN_GOOD_CHECK)) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "next page store bad state (pg %u = 0x%016llX)",
+			core_link->an.page_num, data64);
+		sl_core_data_link_an_fail_cause_set(core_link, SL_CORE_HW_AN_FAIL_CAUSE_NP_STORE_STATE_BAD);
+		core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+		return;
+	}
+
+	if (SS2_PORT_PML_STS_PCS_AUTONEG_NEXT_PAGE_BASE_PAGE_GET(data64)) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "next page store base page set (pg %u = 0x%016llX)",
+			core_link->an.page_num, data64);
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_NP_STORE_BP_SET);
+		core_link->an.state = SL_CORE_HW_AN_STATE_RETRY;
+		return;
+	}
+
+	core_link->an.rx_pages[core_link->an.page_num] =
+		SS2_PORT_PML_STS_PCS_AUTONEG_NEXT_PAGE_LP_NEXT_PAGE_GET(data64);
+	core_link->an.rx_count++;
+
+	if (SS2_PORT_PML_STS_PCS_AUTONEG_NEXT_PAGE_COMPLETE_GET(data64)) {
+		core_link->an.state = SL_CORE_HW_AN_STATE_COMPLETE;
+		return;
+	}
+
+	if (!test_bit(SL_CORE_HW_AN_NP_BIT_NP,
+		      (unsigned long *)&(core_link->an.rx_pages[core_link->an.page_num]))) {
+		core_link->an.state = SL_CORE_HW_AN_STATE_LP_DONE;
+		return;
+	}
+}
+
+static void sl_core_hw_an_next_page_check(struct sl_core_link *core_link)
+{
+	u64 data64;
+	u32 port;
+	u64 state;
+
+	port = core_link->core_lgrp->num;
+
+	sl_core_read64(core_link, SS2_PORT_PML_STS_PCS_AUTONEG_NEXT_PAGE(core_link->num), &data64);
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"next page check (port = %u, data = 0x%016llX)", port, data64);
+
+	state = SS2_PORT_PML_STS_PCS_AUTONEG_BASE_PAGE_STATE_GET(data64);
+	if ((state != SL_CORE_HW_AN_STATE_COMPLETE_ACK) &&
+	    (state != SL_CORE_HW_AN_STATE_AN_GOOD_CHECK)) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "next page check bad state (pg %u = 0x%016llX)",
+			core_link->an.page_num, data64);
+		sl_core_data_link_an_fail_cause_set(core_link, SL_CORE_HW_AN_FAIL_CAUSE_NP_CHECK_STATE_BAD);
+		core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+		return;
+	}
+
+	if (SS2_PORT_PML_STS_PCS_AUTONEG_NEXT_PAGE_COMPLETE_GET(data64)) {
+		core_link->an.state = SL_CORE_HW_AN_STATE_COMPLETE;
+		return;
+	}
+}
+
+#define AN_IS_OUI_HPE_EXTD(_page)                                                   \
+	(((_page) & (SL_CORE_HW_AN_NP_MSG_MASK | SL_CORE_HW_AN_NP_OUI_HPE_MASK)) == \
+		(SL_CORE_HW_AN_NP_MSG_OUI_EXTD | SL_CORE_HW_AN_NP_OUI_HPE))
+#define AN_OUI_VER_GET(_page) \
+	((_page) & SL_CORE_HW_AN_NP_OUI_VER_MASK)
+#define AN_HPE_MAP_GET(_page) \
+	(((_page) >> SL_CORE_HW_AN_NP_HPE_SHIFT) & SL_LINK_CONFIG_HPE_MASK)
+
+int sl_core_hw_an_rx_pages_decode(struct sl_core_link *core_link,
+				  struct sl_link_caps *my_caps, struct sl_link_caps *link_caps)
+{
+	int x;
+	u32 pause_map;
+	u32 tech_map;
+	u32 fec_map;
+	u32 hpe_map;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "rx pages decode (count = %u)", core_link->an.rx_count);
+	for (x = 0; x < core_link->an.rx_count; ++x)
+		sl_core_log_dbg(core_link, LOG_NAME,
+				"rx pages decode pages (%d = 0x%016llX)", x, core_link->an.rx_pages[x]);
+
+	/* base page */
+	if (!(core_link->an.rx_pages[0] & SL_CORE_HW_AN_BP_802_3)) {
+		sl_core_log_err_trace(core_link, LOG_NAME, "rx pages decode no base page");
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_PAGES_DECODE_NO_BP);
+		return -EIO;
+	}
+	pause_map  = (core_link->an.rx_pages[0] >> SL_CORE_HW_AN_BP_PAUSE_SHIFT);
+	pause_map &= SL_LINK_CONFIG_PAUSE_MASK;
+	pause_map &= core_link->config.pause_map;
+	tech_map   = (core_link->an.rx_pages[0] >> SL_CORE_HW_AN_BP_TECH_SHIFT);
+	tech_map  &= SL_LGRP_CONFIG_TECH_MASK;
+	tech_map  &= core_link->core_lgrp->config.tech_map;
+	fec_map    = (core_link->an.rx_pages[0] >> SL_CORE_HW_AN_BP_FEC_SHIFT);
+	fec_map   &= SL_LGRP_CONFIG_FEC_MASK;
+	fec_map   &= core_link->core_lgrp->config.fec_map;
+
+	/* next pages */
+	hpe_map = 0;
+	for (x = 1; x < core_link->an.rx_count; ++x) {
+		if (AN_IS_OUI_HPE_EXTD(core_link->an.rx_pages[x])) {
+			x++;
+			switch (AN_OUI_VER_GET(core_link->an.rx_pages[x])) {
+			case SL_CORE_HW_AN_NP_OUI_VER_0_2:
+				sl_core_log_dbg(core_link, LOG_NAME, "rx pages decode v2 oui");
+				fallthrough;
+			case SL_CORE_HW_AN_NP_OUI_VER_0_1:
+				sl_core_log_dbg(core_link, LOG_NAME, "rx pages decode v1 oui");
+				hpe_map = AN_HPE_MAP_GET(core_link->an.rx_pages[x]);
+				break;
+			default:
+				sl_core_log_err_trace(core_link, LOG_NAME,
+						      "rx pages decode invalid oui (ver = 0x%llX)",
+						      AN_OUI_VER_GET(core_link->an.rx_pages[x]));
+				sl_core_data_link_an_fail_cause_set(core_link,
+								    SL_CORE_HW_AN_FAIL_CAUSE_PAGES_DECODE_OUI_INVALID);
+				return -EIO;
+			}
+			break;
+		}
+	}
+
+	/* common maps */
+	tech_map &= my_caps->tech_map;
+	for (x = 31; x >= 0; --x) {
+		if (tech_map & BIT(x)) {
+			link_caps->tech_map = BIT(x);
+			break;
+		}
+	}
+	link_caps->pause_map = pause_map & my_caps->pause_map;
+	link_caps->fec_map   = fec_map & my_caps->fec_map;
+	link_caps->fec_map  |= SL_LGRP_CONFIG_FEC_RS;
+	link_caps->hpe_map   = hpe_map & my_caps->hpe_map;
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"rx pages decode (pause = 0x%X, tech = 0x%X, fec = 0x%X, hpe = 0x%X)",
+			link_caps->pause_map, link_caps->tech_map, link_caps->fec_map, link_caps->hpe_map);
+
+	return 0;
+}
+
+/**
+ * sl_core_hw_an_page_recv_intr - Handle page AN receive interrupt
+ * @core_link: Pointer to the core link structure
+ *
+ * Context: Interrupt Context
+ */
+static void sl_core_hw_an_page_recv_intr(struct sl_core_link *core_link)
+{
+	int rtn;
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"page recv intr (state = %u)", core_link->an.state);
+
+	switch (core_link->an.state) {
+	case SL_CORE_HW_AN_STATE_BASE:
+		sl_core_hw_an_base_page_store(core_link);
+		break;
+	case SL_CORE_HW_AN_STATE_NEXT:
+		sl_core_hw_an_next_page_store(core_link);
+		break;
+	case SL_CORE_HW_AN_STATE_LP_DONE:
+		sl_core_hw_an_next_page_check(core_link);
+		break;
+	default:
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "page recv intr invalid (state = %u)", core_link->an.state);
+		sl_core_data_link_an_fail_cause_set(core_link, SL_CORE_HW_AN_FAIL_CAUSE_INTR_STATE_INVALID);
+		goto out;
+	}
+
+	if (core_link->an.state == SL_CORE_HW_AN_STATE_COMPLETE) {
+		sl_core_log_dbg(core_link, LOG_NAME, "page recv intr autoneg complete");
+		sl_core_data_link_an_fail_cause_set(core_link, SL_CORE_HW_AN_FAIL_CAUSE_NONE);
+		sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_NEXT_PAGE);
+		sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_BASE_PAGE);
+		sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_ERROR);
+		sl_core_data_link_info_map_set(core_link, SL_CORE_INFO_MAP_AN_DONE);
+		goto out;
+	}
+
+	if (core_link->an.state == SL_CORE_HW_AN_STATE_ERROR) {
+		sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_NEXT_PAGE);
+		sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_BASE_PAGE);
+		sl_core_data_link_info_map_clr(core_link, SL_CORE_INFO_MAP_AN_DONE);
+		sl_core_data_link_info_map_set(core_link, SL_CORE_INFO_MAP_AN_ERROR);
+		goto out;
+	}
+
+	if (core_link->an.state == SL_CORE_HW_AN_STATE_RETRY) {
+		atomic_inc(&core_link->an.retry_count);
+		rtn = sl_core_hw_an_next_page_send(core_link);
+		if (rtn != 0) {
+			sl_core_log_err_trace(core_link, LOG_NAME,
+					      "page recv intr an next page send retry failed [%d]", rtn);
+			sl_core_data_link_an_fail_cause_set(core_link,
+							    SL_CORE_HW_AN_FAIL_CAUSE_INTR_AN_RETRY_NP_SEND_FAIL);
+			core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+			goto out;
+		}
+		return;
+	}
+
+	core_link->an.page_num++;
+
+	if (core_link->an.page_num >= SL_CORE_LINK_AN_MAX_PAGES) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "page recv intr out of pages");
+		sl_core_data_link_an_fail_cause_set(core_link, SL_CORE_HW_AN_FAIL_CAUSE_INTR_OUT_OF_PAGES);
+		core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+		goto out;
+	}
+
+	rtn = sl_core_hw_an_next_page_send(core_link);
+	if (rtn != 0) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "page recv intr an next page send failed [%d]", rtn);
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_INTR_NP_SEND_FAIL);
+		core_link->an.state = SL_CORE_HW_AN_STATE_ERROR;
+		goto out;
+	}
+
+	return;
+
+out:
+	rtn = sl_core_hw_intr_disable(core_link,
+				      core_link->intrs[SL_CORE_HW_INTR_AN_PAGE_RECV].flgs, sl_core_hw_an_intr_hdlr);
+	if (rtn != 0)
+		sl_core_log_warn_trace(core_link, LOG_NAME, "page recv intr disable failed [%d]", rtn);
+
+	queue_work(core_link->core_lgrp->core_ldev->workqueue, &core_link->work[core_link->an.done_work_num]);
+}
+
+void sl_core_hw_an_intr_hdlr(u64 *err_flgs, int num_err_flgs, void *data)
+{
+	struct sl_core_hw_intr_data *info;
+	struct sl_core_link         *core_link;
+
+	info = data;
+	core_link = info->link;
+
+	sl_core_log_dbg(core_link, LOG_NAME,
+			"hdlr %s (link = 0x%p, intr = %u)",
+		info->log, core_link, info->intr_num);
+
+	sl_core_hw_intr_flgs_clr(core_link, SL_CORE_HW_INTR_AN_PAGE_RECV);
+
+	sl_core_hw_an_page_recv_intr(core_link);
+}

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022,2023,2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+
+#include "sl_platform.h"
+#include "sl_core_link.h"
+#include "sl_core_str.h"
+#include "base/sl_core_log.h"
+#include "hw/sl_core_hw_intr.h"
+#include "data/sl_core_data_link.h"
+#include "hw/sl_core_hw_serdes_link.h"
+#include "hw/sl_core_hw_an.h"
+#include "hw/sl_core_hw_an_lp.h"
+
+#define LOG_NAME SL_CORE_HW_AN_LOG_NAME
+
+static void sl_core_an_lp_caps_get_callback(struct sl_core_link *link)
+{
+	int rtn;
+
+	sl_core_log_dbg(link, LOG_NAME, "lp caps get callback");
+
+	rtn = link->an.callbacks.lp_caps_get(link->an.tag,
+		&(link->an.lp_caps), link->an.lp_caps_state);
+	if (rtn != 0)
+		sl_core_log_warn_trace(link, LOG_NAME,
+				       "lp caps get callback - failed [%d]", rtn);
+}
+
+void sl_core_hw_an_lp_caps_get_cmd(struct sl_core_link *core_link,
+				   enum sl_core_link_state link_state,
+				   sl_core_link_an_callback_t callback,
+				   void *tag, struct sl_link_caps *caps, u32 timeout_ms, u32 flags)
+{
+	int rtn;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "lp caps get cmd");
+
+	sl_core_hw_an_stop(core_link);
+
+	core_link->an.link_state             = link_state;
+	core_link->an.tag                    = tag;
+	core_link->an.callbacks.lp_caps_get  = callback;
+	core_link->an.done_work_num          = SL_CORE_WORK_LINK_AN_LP_CAPS_GET_DONE;
+	core_link->an.my_caps                = *caps;
+
+	sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_RUNNING);
+
+	core_link->timers[SL_CORE_TIMER_LINK_AN_LP_CAPS_GET].data.timeout_ms = timeout_ms;
+
+	/* test check */
+	if (core_link->an.use_test_caps) {
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "lp caps get cmd - using test caps");
+		core_link->an.lp_caps       = core_link->an.test_caps;
+		sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_DATA);
+		sl_core_data_link_state_set(core_link, core_link->an.link_state);
+		sl_core_an_lp_caps_get_callback(core_link);
+		return;
+	}
+
+	memset(&(core_link->an.lp_caps), 0, sizeof(core_link->an.lp_caps));
+	core_link->an.lp_caps.magic = SL_CORE_LINK_AN_MAGIC;
+
+	if (!SL_PLATFORM_IS_HARDWARE(core_link->core_lgrp->core_ldev)) {
+		sl_core_data_link_state_set(core_link, core_link->an.link_state);
+		sl_core_an_lp_caps_get_callback(core_link);
+		return;
+	}
+
+	sl_core_timer_link_begin(core_link, SL_CORE_TIMER_LINK_AN_LP_CAPS_GET);
+
+	rtn = sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_AN_PAGE_RECV);
+	if (rtn != 0)
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "lp caps get cmd - an page recv disable failed [%d]", rtn);
+
+	queue_work(core_link->core_lgrp->core_ldev->workqueue, &core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET]);
+}
+
+void sl_core_hw_an_lp_caps_get_work(struct work_struct *work)
+{
+	int                  rtn;
+	struct sl_core_link *core_link;
+	enum sl_core_link_state link_state;
+
+	core_link = container_of(work, struct sl_core_link, work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET]);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "up lp caps get work");
+
+	rtn = sl_core_data_link_state_get(core_link, &link_state);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "lp caps get work - failed to get link state [%d]", rtn);
+		return;
+	}
+
+	if (link_state != SL_CORE_LINK_STATE_AN) {
+		sl_core_log_dbg(core_link, LOG_NAME, "up lp caps get work - invalid state (link_state = %u %s)",
+				link_state, sl_core_link_state_str(link_state));
+		return;
+	}
+
+	sl_core_hw_serdes_link_down(core_link);
+
+	rtn = sl_core_hw_serdes_link_up_an(core_link);
+	if (rtn != 0) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "lp caps get work hw_serdes_link_up_an failed [%d]", rtn);
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_LP_CAPS_SERDES_LINK_UP_FAIL);
+		sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_AN_LP_CAPS_GET);
+		sl_core_hw_serdes_link_down(core_link);
+		sl_core_data_link_state_set(core_link, core_link->an.link_state);
+		sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_ERROR);
+		sl_core_an_lp_caps_get_callback(core_link);
+		return;
+	}
+
+	sl_core_hw_an_init(core_link);
+
+	sl_core_hw_an_config(core_link);
+
+	sl_core_hw_an_tx_pages_encode(core_link, &(core_link->an.my_caps));
+
+	rtn = sl_core_hw_an_base_page_send(core_link);
+	if (rtn != 0)
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "lp caps get work an base page send failed [%d]", rtn);
+}
+
+void sl_core_hw_an_lp_caps_stop_cmd(struct sl_core_link *core_link)
+{
+	int rtn;
+
+	sl_core_log_dbg(core_link, LOG_NAME, "lp caps stop cmd");
+
+	if (sl_core_data_link_an_lp_caps_state_get(core_link) == SL_CORE_LINK_LP_CAPS_NOT_RUNNING) {
+		sl_core_log_dbg(core_link, LOG_NAME, "lp caps stop cmd - already stopped");
+		return;
+	}
+
+	rtn = sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_AN_PAGE_RECV);
+	if (rtn != 0)
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "lp caps stop cmd - an page recv disable failed [%d]", rtn);
+
+	cancel_work_sync(&core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET]);
+	cancel_work_sync(&core_link->work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET_TIMEOUT]);
+
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_AN_LP_CAPS_GET);
+
+	sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_NOT_RUNNING);
+	sl_core_data_link_state_set(core_link, core_link->an.link_state);
+}
+
+void sl_core_hw_an_lp_caps_get_timeout_work(struct work_struct *work)
+{
+	int                  rtn;
+	struct sl_core_link *core_link;
+	enum sl_core_link_state link_state;
+
+	core_link = container_of(work, struct sl_core_link, work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET_TIMEOUT]);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "lp caps get timeout work");
+
+	rtn = sl_core_data_link_state_get(core_link, &link_state);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "lp caps get timeout work - failed to get link state [%d]", rtn);
+		return;
+	}
+
+	if (link_state != SL_CORE_LINK_STATE_AN) {
+		sl_core_log_dbg(core_link, LOG_NAME, "lp caps get timeout work - invalid state (link_state = %u %s)",
+				link_state, sl_core_link_state_str(link_state));
+		return;
+	}
+
+	rtn = sl_core_hw_intr_flgs_disable(core_link, SL_CORE_HW_INTR_AN_PAGE_RECV);
+	if (rtn != 0)
+		sl_core_log_warn_trace(core_link, LOG_NAME,
+				       "lp caps get timeout work an page recv disable failed [%d]", rtn);
+
+	sl_core_hw_an_stop(core_link);
+	sl_core_hw_serdes_link_down(core_link);
+
+	sl_core_data_link_state_set(core_link, core_link->an.link_state);
+	sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_TIMEOUT);
+
+	sl_core_an_lp_caps_get_callback(core_link);
+}
+
+void sl_core_hw_an_lp_caps_get_done_work(struct work_struct *work)
+{
+	int                  rtn;
+	int                  x;
+	struct sl_core_link *core_link;
+	enum sl_core_link_state link_state;
+
+	core_link = container_of(work, struct sl_core_link, work[SL_CORE_WORK_LINK_AN_LP_CAPS_GET_DONE]);
+
+	sl_core_log_dbg(core_link, LOG_NAME, "lp caps get done work");
+
+	rtn = sl_core_data_link_state_get(core_link, &link_state);
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "lp caps get done work - failed to get link state [%d]", rtn);
+		return;
+	}
+
+	if (link_state != SL_CORE_LINK_STATE_AN) {
+		sl_core_log_dbg(core_link, LOG_NAME, "lp caps get done work - invalid state (link_state = %u %s)",
+				link_state, sl_core_link_state_str(link_state));
+		return;
+	}
+
+	for (x = 0; x < core_link->an.rx_count; ++x)
+		sl_core_log_dbg(core_link, LOG_NAME,
+				"lp caps get done work rx pages (%d = 0x%016llX)",
+			x, core_link->an.rx_pages[x]);
+
+	sl_core_timer_link_end(core_link, SL_CORE_TIMER_LINK_AN_LP_CAPS_GET);
+
+	sl_core_hw_an_stop(core_link);
+	sl_core_hw_serdes_link_down(core_link);
+	sl_core_data_link_state_set(core_link, core_link->an.link_state);
+
+	if (core_link->an.state != SL_CORE_HW_AN_STATE_COMPLETE) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "lp caps get done work not complete");
+		sl_core_data_link_an_fail_cause_set(core_link,
+						    SL_CORE_HW_AN_FAIL_CAUSE_LP_CAPS_NOT_COMPLETE);
+		sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_ERROR);
+		goto out;
+	}
+
+	rtn = sl_core_hw_an_rx_pages_decode(core_link,
+					    &(core_link->an.my_caps), &(core_link->an.lp_caps));
+	if (rtn) {
+		sl_core_log_err_trace(core_link, LOG_NAME,
+				      "lp caps get done work hw_an_rx_pages_decode failure [%d]", rtn);
+		sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_ERROR);
+		goto out;
+	}
+
+	sl_core_data_link_an_lp_caps_state_set(core_link, SL_CORE_LINK_LP_CAPS_DATA);
+
+out:
+	sl_core_an_lp_caps_get_callback(core_link);
+}