mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Doug Ledford <doug.ledford@hpe.com>
To: "Slingshot Open Source Team"
	<slingshot-os-team@groups.ext.hpe.com>,
	"Nathan Chancellor" <nathan@kernel.org>,
	"Nicolas Schier" <nsc@kernel.org>,
	"Richard Cochran" <richardcochran@gmail.com>,
	"Andrew Lunn" <andrew+netdev@lunn.ch>,
	"David S. Miller" <davem@davemloft.net>,
	"Eric Dumazet" <edumazet@kernel.org>,
	"Jakub Kicinski" <kuba@kernel.org>,
	"Paolo Abeni" <pabeni@redhat.com>,
	"Sumit Semwal" <sumit.semwal@linaro.org>,
	"Christian König" <christian.koenig@amd.com>,
	"Guenter Roeck" <linux@roeck-us.net>
Cc: <linux-kernel@vger.kernel.org>, <netdev@vger.kernel.org>,
	<linux-kbuild@vger.kernel.org>,
	Doug Ledford <doug.ledford@hpe.com>,
	"Sandeep Bhoot" <sandeep.bhoot@hpe.com>
Subject: [PATCH 15/23] net: hpe: sl: add the NIC binding and logging helpers
Date: Fri, 30 Oct 2026 13:59:11 -0700	[thread overview]
Message-ID: <20261030-cxi-netdev-submission-v1-15-8c2c391cc283@hpe.com> (raw)
In-Reply-To: <20261030-cxi-netdev-submission-v1-0-8c2c391cc283@hpe.com>

Add the glue that binds SL to a NIC: ASIC and CSR definitions, the NIC
logical device and media hooks, and the logging helpers.

sl_asic_csrs.h is generated from the hardware register description and
is kept in that form; its integer types were converted to the kernel
types in the same pass as the other UAPI/header cleanups.

checkpatch --strict (100 columns) still reports the following in this
patch. They need coordination with the internal repositories this code
is maintained in and will be fixed in V2:
- WARNING: LONG_LINE (18)
- CHECK: UNNECESSARY_PARENTHESES (16), COMPARISON_TO_NULL (3)

Co-developed-by: Sandeep Bhoot <sandeep.bhoot@hpe.com>
Signed-off-by: Sandeep Bhoot <sandeep.bhoot@hpe.com>
Signed-off-by: Doug Ledford <doug.ledford@hpe.com>
---
 drivers/net/ethernet/hpe/sl/log/sl_log.c   | 566 +++++++++++++++++++++++++++++
 drivers/net/ethernet/hpe/sl/nic/sl_ldev.c  | 147 ++++++++
 drivers/net/ethernet/hpe/sl/nic/sl_media.c |  53 +++
 3 files changed, 766 insertions(+)

diff --git a/drivers/net/ethernet/hpe/sl/log/sl_log.c b/drivers/net/ethernet/hpe/sl/log/sl_log.c
new file mode 100644
index 000000000000..64382f9b46bb
--- /dev/null
+++ b/drivers/net/ethernet/hpe/sl/log/sl_log.c
@@ -0,0 +1,566 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2022-2026 Hewlett Packard Enterprise Development LP */
+
+#include <linux/module.h>
+#include <linux/sched.h>
+
+#include "sl_asic.h"
+
+#include "sl_log.h"
+
+#include "sl_ldev.h"
+#include "sl_lgrp.h"
+#include "sl_link.h"
+#include "sl_llr.h"
+#include "sl_mac.h"
+
+#include "sl_ctrl_ldev.h"
+#include "sl_ctrl_lgrp.h"
+#include "sl_ctrl_link.h"
+#include "sl_ctrl_llr.h"
+#include "sl_ctrl_mac.h"
+
+#include "sl_core_ldev.h"
+#include "sl_core_lgrp.h"
+#include "sl_core_link.h"
+#include "sl_core_mac.h"
+#include "sl_core_llr.h"
+
+#include "sl_media_ldev.h"
+#include "sl_media_lgrp.h"
+#include "sl_media_jack.h"
+
+#include "data/sl_ctrl_data_lgrp_trace.h"
+
+#include "hw/sl_core_hw_intr.h"
+#include "data/sl_core_data_link.h"
+#include "data/sl_core_data_lgrp.h"
+#include "data/sl_core_data_lgrp_trace.h"
+#include "data/sl_core_data_ldev.h"
+
+#include "data/sl_media_data_lgrp_trace.h"
+
+#define SL_LOG_MSG_LEN              150
+#define SL_LOG_NULL_ID_FMT          "%c[-:--:-] ???         "
+#define SL_LOG_DFLT_ID_FMT          "%c[-:--:-] 0x%08X  "
+#define SL_LOG_LDEV_ID_FMT          "%c[%1u:--:-] ldev%1u       "
+#define SL_LOG_LGRP_ID_FMT          "%c[%1u:%02u:-] %-12s"
+#define SL_LOG_LINK_ID_FMT          "%c[%1u:%02u:%1u] %-12s"
+#define SL_LOG_JACK_ID_FMT          "%c[-:--:-] jack%03u     "
+#define SL_LOG_CONTEXT              (in_interrupt() ? '^' : ' ')
+
+static int remaining_chars(int idx)
+{
+	return max(SL_LOG_MSG_LEN - idx, 0);
+}
+
+static void sl_log_msg_create(const char *level, void *ptr, char *msg,
+			      const char *block, const char *name, const char *text)
+{
+	struct sl_ldev            *ldev;
+	struct sl_lgrp            *lgrp;
+	struct sl_link            *link;
+	struct sl_llr             *llr;
+	struct sl_mac             *mac;
+	struct sl_ctrl_ldev       *ctrl_ldev;
+	struct sl_ctrl_lgrp       *ctrl_lgrp;
+	struct sl_ctrl_link       *ctrl_link;
+	struct sl_ctrl_llr        *ctrl_llr;
+	struct sl_ctrl_mac        *ctrl_mac;
+	struct sl_core_ldev       *core_ldev;
+	struct sl_core_lgrp       *core_lgrp;
+	struct sl_core_link       *core_link;
+	struct sl_core_mac        *core_mac;
+	struct sl_core_llr        *core_llr;
+	struct sl_media_ldev      *media_ldev;
+	struct sl_media_lgrp      *media_lgrp;
+	struct sl_media_jack      *media_jack;
+	int                        idx;
+	unsigned long              irq_flags;
+
+	idx = snprintf(msg, SL_LOG_MSG_LEN, "%s%s", level, module_name(THIS_MODULE));
+	if (ptr != NULL) {
+		switch (*((u32 *)ptr)) {
+		case SL_LDEV_MAGIC:
+			ldev = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LDEV_ID_FMT,
+				SL_LOG_CONTEXT,
+				ldev->num, ldev->num);
+			break;
+		case SL_LGRP_MAGIC:
+			lgrp = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LGRP_ID_FMT,
+				SL_LOG_CONTEXT,
+				lgrp->ldev_num, lgrp->num, "lgrp");
+			break;
+		case SL_LINK_MAGIC:
+			link = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				link->ldev_num, link->lgrp_num, link->num, "link");
+			break;
+		case SL_LLR_MAGIC:
+			llr = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				llr->ldev_num, llr->lgrp_num, llr->num, "llr");
+			break;
+		case SL_MAC_MAGIC:
+			mac = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				mac->ldev_num, mac->lgrp_num, mac->num, "mac");
+			break;
+		case SL_CTRL_LDEV_MAGIC:
+			ctrl_ldev = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LDEV_ID_FMT,
+				SL_LOG_CONTEXT,
+				ctrl_ldev->num, ctrl_ldev->num);
+			break;
+		case SL_CTRL_LGRP_MAGIC:
+			ctrl_lgrp = ptr;
+			spin_lock_irqsave(&(ctrl_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LGRP_ID_FMT,
+				SL_LOG_CONTEXT,
+				ctrl_lgrp->ctrl_ldev->num, ctrl_lgrp->num,
+				ctrl_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(ctrl_lgrp->log_lock), irq_flags);
+			break;
+		case SL_CTRL_LINK_MAGIC:
+			ctrl_link = ptr;
+			spin_lock_irqsave(&(ctrl_link->ctrl_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				ctrl_link->ctrl_lgrp->ctrl_ldev->num, ctrl_link->ctrl_lgrp->num, ctrl_link->num,
+				ctrl_link->ctrl_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(ctrl_link->ctrl_lgrp->log_lock), irq_flags);
+			break;
+		case SL_CTRL_LLR_MAGIC:
+			ctrl_llr = ptr;
+			spin_lock_irqsave(&(ctrl_llr->ctrl_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				ctrl_llr->ctrl_lgrp->ctrl_ldev->num, ctrl_llr->ctrl_lgrp->num, ctrl_llr->num,
+				ctrl_llr->ctrl_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(ctrl_llr->ctrl_lgrp->log_lock), irq_flags);
+			break;
+		case SL_CTRL_MAC_MAGIC:
+			ctrl_mac = ptr;
+			spin_lock_irqsave(&(ctrl_mac->ctrl_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				ctrl_mac->ctrl_lgrp->ctrl_ldev->num, ctrl_mac->ctrl_lgrp->num, ctrl_mac->num,
+				ctrl_mac->ctrl_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(ctrl_mac->ctrl_lgrp->log_lock), irq_flags);
+			break;
+		case SL_CORE_LDEV_MAGIC:
+			core_ldev = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LDEV_ID_FMT,
+				SL_LOG_CONTEXT,
+				core_ldev->num, core_ldev->num);
+			break;
+		case SL_CORE_LGRP_MAGIC:
+			core_lgrp = ptr;
+			spin_lock_irqsave(&(core_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LGRP_ID_FMT,
+				SL_LOG_CONTEXT,
+				core_lgrp->core_ldev->num, core_lgrp->num,
+				core_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(core_lgrp->log_lock), irq_flags);
+			break;
+		case SL_CORE_LINK_MAGIC:
+			core_link = ptr;
+			spin_lock_irqsave(&(core_link->core_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				core_link->core_lgrp->core_ldev->num, core_link->core_lgrp->num, core_link->num,
+				core_link->core_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(core_link->core_lgrp->log_lock), irq_flags);
+			break;
+		case SL_CORE_MAC_MAGIC:
+			core_mac = ptr;
+			spin_lock_irqsave(&(core_mac->core_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				core_mac->core_lgrp->core_ldev->num, core_mac->core_lgrp->num, core_mac->num,
+				core_mac->core_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(core_mac->core_lgrp->log_lock), irq_flags);
+			break;
+		case SL_CORE_LLR_MAGIC:
+			core_llr = ptr;
+			spin_lock_irqsave(&(core_llr->core_lgrp->log_lock), irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LINK_ID_FMT,
+				SL_LOG_CONTEXT,
+				core_llr->core_lgrp->core_ldev->num, core_llr->core_lgrp->num, core_llr->num,
+				core_llr->core_lgrp->log_connect_id);
+			spin_unlock_irqrestore(&(core_llr->core_lgrp->log_lock), irq_flags);
+			break;
+		case SL_MEDIA_LDEV_MAGIC:
+			media_ldev = ptr;
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LDEV_ID_FMT,
+				SL_LOG_CONTEXT,
+				media_ldev->num, media_ldev->num);
+			break;
+		case SL_MEDIA_LGRP_MAGIC:
+			media_lgrp = ptr;
+			spin_lock_irqsave(&media_lgrp->log_lock, irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_LGRP_ID_FMT,
+				SL_LOG_CONTEXT,
+				media_lgrp->media_ldev->num, media_lgrp->num,
+				media_lgrp->connect_id);
+			spin_unlock_irqrestore(&media_lgrp->log_lock, irq_flags);
+			break;
+		case SL_MEDIA_JACK_MAGIC:
+			media_jack = ptr;
+			spin_lock_irqsave(&media_jack->log_lock, irq_flags);
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_JACK_ID_FMT,
+				SL_LOG_CONTEXT,
+				media_jack->physical_num);
+			spin_unlock_irqrestore(&media_jack->log_lock, irq_flags);
+			break;
+		default:
+			idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_DFLT_ID_FMT,
+				SL_LOG_CONTEXT,
+				*((u32 *)ptr));
+			break;
+		}
+	} else {
+		idx += snprintf(msg + idx, remaining_chars(idx), SL_LOG_NULL_ID_FMT,
+			SL_LOG_CONTEXT);
+	}
+
+	snprintf(msg + idx, remaining_chars(idx), " %5s-%-10s: %s\n", block, name, text);
+}
+
+void sl_log(void *ptr, const char *level, const char *block,
+	    const char *name, const char *text, ...)
+{
+	char    msg[SL_LOG_MSG_LEN + 1];
+	va_list args;
+
+	if (!level) {
+		pr_err("NULL level\n");
+		return;
+	}
+	if (!block) {
+		pr_err("NULL block\n");
+		return;
+	}
+	if (!name) {
+		pr_err("NULL name\n");
+		return;
+	}
+	if (!text) {
+		pr_err("NULL text\n");
+		return;
+	}
+
+	sl_log_msg_create(level, ptr, msg, block, name, text);
+
+	va_start(args, text);
+	vprintk(msg, args);
+	va_end(args);
+}
+
+void sl_log_err_trace(void *ptr, const char *block,
+		      const char *name, const char *text, ...)
+{
+	int                  rtn;
+	char                 msg[SL_LOG_MSG_LEN + 1];
+	va_list              args;
+	struct sl_ctrl_lgrp  *ctrl_lgrp;
+	struct sl_ctrl_link  *ctrl_link;
+	struct sl_ctrl_llr   *ctrl_llr;
+	struct sl_ctrl_mac   *ctrl_mac;
+	struct sl_core_lgrp  *core_lgrp;
+	struct sl_core_link  *core_link;
+	struct sl_core_mac   *core_mac;
+	struct sl_core_llr   *core_llr;
+	struct sl_media_lgrp *media_lgrp;
+	bool                  err_trace_enable;
+
+	if (!block) {
+		pr_err("NULL block\n");
+		return;
+	}
+	if (!name) {
+		pr_err("NULL name\n");
+		return;
+	}
+	if (!text) {
+		pr_err("NULL text\n");
+		return;
+	}
+
+	if (ptr == NULL)
+		return;
+
+	switch (*((u32 *)ptr)) {
+	case SL_CTRL_LGRP_MAGIC:
+		ctrl_lgrp = ptr;
+		rtn = sl_ctrl_data_lgrp_is_err_trace_enabled(ctrl_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_CTRL_LINK_MAGIC:
+		ctrl_link = ptr;
+		rtn = sl_ctrl_data_lgrp_is_err_trace_enabled(ctrl_link->ctrl_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_CTRL_LLR_MAGIC:
+		ctrl_llr = ptr;
+		rtn = sl_ctrl_data_lgrp_is_err_trace_enabled(ctrl_llr->ctrl_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_CTRL_MAC_MAGIC:
+		ctrl_mac = ptr;
+		rtn = sl_ctrl_data_lgrp_is_err_trace_enabled(ctrl_mac->ctrl_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_CORE_LGRP_MAGIC:
+		core_lgrp = ptr;
+		rtn = sl_core_data_lgrp_is_err_trace_enabled(core_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_CORE_LINK_MAGIC:
+		core_link = ptr;
+		rtn = sl_core_data_lgrp_is_err_trace_enabled(core_link->core_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_CORE_MAC_MAGIC:
+		core_mac = ptr;
+		rtn = sl_core_data_lgrp_is_err_trace_enabled(core_mac->core_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_CORE_LLR_MAGIC:
+		core_llr = ptr;
+		rtn = sl_core_data_lgrp_is_err_trace_enabled(core_llr->core_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	case SL_MEDIA_LGRP_MAGIC:
+		media_lgrp = ptr;
+		rtn = sl_media_data_lgrp_is_err_trace_enabled(media_lgrp, &err_trace_enable);
+		if (rtn)
+			return;
+		if (!err_trace_enable)
+			return;
+		break;
+	default:
+		return;
+	}
+
+	sl_log_msg_create(KERN_ERR, ptr, msg, block, name, text);
+
+	va_start(args, text);
+	vprintk(msg, args);
+	va_end(args);
+}
+
+void sl_log_warn_trace(void *ptr, const char *block,
+		       const char *name, const char *text, ...)
+{
+	int                   rtn;
+	char                  msg[SL_LOG_MSG_LEN + 1];
+	va_list               args;
+	struct sl_ctrl_lgrp  *ctrl_lgrp;
+	struct sl_ctrl_link  *ctrl_link;
+	struct sl_ctrl_llr   *ctrl_llr;
+	struct sl_ctrl_mac   *ctrl_mac;
+	struct sl_core_lgrp  *core_lgrp;
+	struct sl_core_link  *core_link;
+	struct sl_core_mac   *core_mac;
+	struct sl_core_llr   *core_llr;
+	struct sl_media_lgrp *media_lgrp;
+	bool                  warn_trace_enable;
+
+	if (!block) {
+		pr_err("NULL block\n");
+		return;
+	}
+	if (!name) {
+		pr_err("NULL name\n");
+		return;
+	}
+	if (!text) {
+		pr_err("NULL text\n");
+		return;
+	}
+
+	if (ptr == NULL)
+		return;
+
+	switch (*((u32 *)ptr)) {
+	case SL_CTRL_LGRP_MAGIC:
+		ctrl_lgrp = ptr;
+		rtn = sl_ctrl_data_lgrp_is_warn_trace_enabled(ctrl_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_CTRL_LINK_MAGIC:
+		ctrl_link = ptr;
+		rtn = sl_ctrl_data_lgrp_is_warn_trace_enabled(ctrl_link->ctrl_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_CTRL_LLR_MAGIC:
+		ctrl_llr = ptr;
+		rtn = sl_ctrl_data_lgrp_is_warn_trace_enabled(ctrl_llr->ctrl_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_CTRL_MAC_MAGIC:
+		ctrl_mac = ptr;
+		rtn = sl_ctrl_data_lgrp_is_warn_trace_enabled(ctrl_mac->ctrl_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_CORE_LGRP_MAGIC:
+		core_lgrp = ptr;
+		rtn = sl_core_data_lgrp_is_warn_trace_enabled(core_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_CORE_LINK_MAGIC:
+		core_link = ptr;
+		rtn = sl_core_data_lgrp_is_warn_trace_enabled(core_link->core_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_CORE_MAC_MAGIC:
+		core_mac = ptr;
+		rtn = sl_core_data_lgrp_is_warn_trace_enabled(core_mac->core_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_CORE_LLR_MAGIC:
+		core_llr = ptr;
+		rtn = sl_core_data_lgrp_is_warn_trace_enabled(core_llr->core_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	case SL_MEDIA_LGRP_MAGIC:
+		media_lgrp = ptr;
+		rtn = sl_media_data_lgrp_is_warn_trace_enabled(media_lgrp, &warn_trace_enable);
+		if (rtn)
+			return;
+		if (!warn_trace_enable)
+			return;
+		break;
+	default:
+		return;
+	}
+
+	sl_log_msg_create(KERN_WARNING, ptr, msg, block, name, text);
+
+	va_start(args, text);
+	vprintk(msg, args);
+	va_end(args);
+}
+
+void sl_log_io_trace(void *ptr, const char *block, const char *name, const char *text, ...)
+{
+	char                 msg[SL_LOG_MSG_LEN + 1];
+	va_list              args;
+	struct sl_core_lgrp *core_lgrp;
+
+	if (!block) {
+		pr_err("NULL block\n");
+		return;
+	}
+	if (!name) {
+		pr_err("NULL name\n");
+		return;
+	}
+	if (!text) {
+		pr_err("NULL text\n");
+		return;
+	}
+
+	if (!ptr)
+		return;
+
+	switch (*((u32 *)ptr)) {
+	case SL_CORE_LGRP_MAGIC:
+		core_lgrp = ptr;
+		if (!sl_core_data_lgrp_is_io_trace_enabled(core_lgrp))
+			return;
+		break;
+	default:
+		return;
+	}
+
+	sl_log_msg_create(KERN_INFO, ptr, msg, block, name, text);
+
+	va_start(args, text);
+	vprintk(msg, args);
+	va_end(args);
+}
+
+void __sl_log_dynamic_dbg(struct _ddebug *desc, void *ptr, const char *block,
+			  const char *name, const char *text, ...)
+{
+	char    msg[SL_LOG_MSG_LEN + 1];
+	va_list args;
+
+	if (!desc) {
+		pr_err("NULL desc\n");
+		return;
+	}
+	if (!block) {
+		pr_err("NULL desc\n");
+		return;
+	}
+	if (!name) {
+		pr_err("NULL name\n");
+		return;
+	}
+	if (!text) {
+		pr_err("NULL text\n");
+		return;
+	}
+
+	sl_log_msg_create(KERN_DEBUG, ptr, msg, block, name, text);
+
+	va_start(args, text);
+	vprintk(msg, args);
+	va_end(args);
+}
diff --git a/drivers/net/ethernet/hpe/sl/nic/sl_ldev.c b/drivers/net/ethernet/hpe/sl/nic/sl_ldev.c
new file mode 100644
index 000000000000..e93cd667dab8
--- /dev/null
+++ b/drivers/net/ethernet/hpe/sl/nic/sl_ldev.c
@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/module.h>
+
+#include <linux/hpe/sl/sl_ldev.h>
+
+#include "sl_log.h"
+#include "sl_ldev.h"
+#include "sl_media_ldev.h"
+
+#define LOG_BLOCK SL_LOG_BLOCK
+#define LOG_NAME  SL_LOG_LDEV_LOG_NAME
+
+int sl_ldev_attr_check(struct sl_ldev_attr *ldev_attr)
+{
+	if (!ldev_attr) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ldev_attr");
+		return -EINVAL;
+	}
+	if (IS_ERR(ldev_attr)) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "ldev_attr pointer error");
+		return -EINVAL;
+	}
+	if (ldev_attr->magic != SL_LDEV_ATTR_MAGIC) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "bad ldev_attr magic");
+		return -EINVAL;
+	}
+	if (ldev_attr->ver != SL_LDEV_ATTR_VER) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "bad ldev_attr version");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ldev_attr ops");
+		return -EINVAL;
+	}
+	if (!ldev_attr->accessors) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ldev_attr accessors");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->read64) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops read64");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->write64) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops write64");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->sbus_op) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops sbus_op");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->pmi_op) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops pmi_op");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->pml_intr_register) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops pml_intr_register");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->pml_intr_unregister) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops pml_intr_unregister");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->pml_intr_enable) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops pml_intr_enable");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->pml_intr_disable) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops pml_intr_disable");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->dt_info_get) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops dt_info_get");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->mb_info_get) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops mb_info_get");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->dmac_alloc) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops dmac_alloc");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->dmac_free) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops dmac_free");
+		return -EINVAL;
+	}
+	if (!ldev_attr->ops->dmac_xfer) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL ops dmac_xfer");
+		return -EINVAL;
+	}
+
+	if (!ldev_attr->accessors->pci) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL accessor PCI");
+		return -EINVAL;
+	}
+	if (!ldev_attr->accessors->sbus) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL accessor SBUS");
+		return -EINVAL;
+	}
+	if (!ldev_attr->accessors->pmi) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL accessor PMI");
+		return -EINVAL;
+	}
+	if (!ldev_attr->accessors->intr) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL accessor INTR");
+		return -EINVAL;
+	}
+	if (!ldev_attr->accessors->dt) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL accessor DT");
+		return -EINVAL;
+	}
+	if (!ldev_attr->accessors->mb) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL accessor MB");
+		return -EINVAL;
+	}
+	if (!ldev_attr->accessors->dmac) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL accessor DMAC");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+int sl_ldev_uc_ops_set(struct sl_ldev *ldev, struct sl_uc_ops *uc_ops,
+		       struct sl_uc_accessor *uc_accessor)
+{
+	int rtn;
+
+	rtn = sl_ldev_check(ldev);
+	if (rtn) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "check fail");
+		return rtn;
+	}
+
+	sl_log_dbg(ldev, LOG_BLOCK, LOG_NAME, "uc ops_set");
+
+	rtn = sl_media_ldev_uc_ops_set(ldev->num, uc_ops, uc_accessor);
+	if (rtn) {
+		sl_log_err(ldev, LOG_BLOCK, LOG_NAME, "media_ldev_uc_ops_set failed [%d]", rtn);
+		return rtn;
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(sl_ldev_uc_ops_set);
diff --git a/drivers/net/ethernet/hpe/sl/nic/sl_media.c b/drivers/net/ethernet/hpe/sl/nic/sl_media.c
new file mode 100644
index 000000000000..dddfaef0cb28
--- /dev/null
+++ b/drivers/net/ethernet/hpe/sl/nic/sl_media.c
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright 2024,2025 Hewlett Packard Enterprise Development LP */
+
+#include <linux/module.h>
+
+#include <linux/hpe/sl/sl_media.h>
+
+#include "base/sl_media_log.h"
+#include "sl_lgrp.h"
+#include "sl_media_lgrp.h"
+#include "sl_media_jack.h"
+
+#define LOG_BLOCK SL_LOG_BLOCK
+#define LOG_NAME  SL_LOG_MEDIA_LOG_NAME
+
+int sl_media_cable_insert(struct sl_lgrp *lgrp, u8 *eeprom_page0, u8 *eeprom_page1, u32 flags)
+{
+	int rtn;
+
+	rtn = sl_lgrp_check(lgrp);
+	if (rtn) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "cable insert fail");
+		return rtn;
+	}
+	if (!eeprom_page0) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "NULL eeprom");
+		return -EINVAL;
+	}
+
+	/*
+	 * hardcoding 0 for now since there is only one jack. Might change in future
+	 */
+	return sl_media_jack_cable_insert(lgrp->ldev_num, lgrp->num, 0, eeprom_page0,
+					  eeprom_page1, flags);
+}
+EXPORT_SYMBOL(sl_media_cable_insert);
+
+int sl_media_cable_remove(struct sl_lgrp *lgrp)
+{
+	int rtn;
+
+	rtn = sl_lgrp_check(lgrp);
+	if (rtn) {
+		sl_log_err(NULL, LOG_BLOCK, LOG_NAME, "cable remove fail");
+		return rtn;
+	}
+
+	/*
+	 * hardcoding 0 for now since there is only one jack. Might change in future
+	 */
+	return sl_media_jack_cable_remove(lgrp->ldev_num, lgrp->num, 0);
+}
+EXPORT_SYMBOL(sl_media_cable_remove);

-- 
2.56.0


  parent reply	other threads:[~2026-10-30 21:01 UTC|newest]

Thread overview: 42+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-10-30 20:58 [PATCH 00/23] Subject: [PATCH net-next 00/23] net/hpe: add HPE Slingshot NIC drivers Doug Ledford
2026-10-30 20:58 ` [PATCH 01/23] net: hpe: ss1: add the Cassini headers Doug Ledford
2026-10-31 13:58   ` Andrew Lunn
2026-10-31 19:34     ` Doug Ledford
2026-10-30 20:58 ` [PATCH 02/23] net: hpe: sbl: add the Slingshot Base Link headers Doug Ledford
2026-10-30 20:58 ` [PATCH 03/23] net: hpe: sbl: add the core instance and configuration layer Doug Ledford
2026-10-30 20:59 ` [PATCH 04/23] net: hpe: sbl: add the SerDes layer Doug Ledford
2026-10-30 20:59 ` [PATCH 05/23] net: hpe: sbl: add the PML link layer Doug Ledford
2026-10-30 20:59 ` [PATCH 06/23] net: hpe: sbl: add link state management Doug Ledford
2026-10-30 20:59 ` [PATCH 07/23] net: hpe: sbl: add the SBM serial bus layer Doug Ledford
2026-10-30 20:59 ` [PATCH 08/23] net: hpe: sbl: add media, FEC and counter support Doug Ledford
2026-10-30 20:59 ` [PATCH 09/23] net: hpe: sl: add the Slingshot Link headers Doug Ledford
2026-10-30 20:59 ` [PATCH 10/23] net: hpe: sl: add the module entry points Doug Ledford
2026-10-30 20:59 ` [PATCH 11/23] net: hpe: sl: add the core link state machines Doug Ledford
2026-10-30 20:59 ` [PATCH 12/23] net: hpe: sl: add the control layer Doug Ledford
2026-10-30 20:59 ` [PATCH 13/23] net: hpe: sl: add media and cable handling Doug Ledford
2026-10-30 20:59 ` [PATCH 14/23] net: hpe: sl: add the sysfs interface Doug Ledford
2026-10-30 20:59 ` Doug Ledford [this message]
2026-10-30 20:59 ` [PATCH 16/23] net: hpe: ss1: add the Cassini core device layer Doug Ledford
2026-10-30 20:59 ` [PATCH 17/23] net: hpe: ss1: add the datapath and memory translation layers Doug Ledford
2026-10-30 20:59 ` [PATCH 18/23] net: hpe: ss1: add the link layer glue Doug Ledford
2026-10-30 20:59 ` [PATCH 19/23] net: hpe: ss1: add SR-IOV support Doug Ledford
2026-10-30 20:59 ` [PATCH 20/23] net: hpe: ss1: add the CXI core interfaces Doug Ledford
2026-10-30 20:59 ` [PATCH 21/23] net: hpe: ss1: add resource groups, QoS and services Doug Ledford
2026-10-30 20:59 ` [PATCH 22/23] net: hpe: ss1: add the Ethernet personality Doug Ledford
2026-10-30 20:59 ` [PATCH 23/23] net: hpe: wire up the Slingshot NIC drivers Doug Ledford
2026-10-30 22:11 ` [PATCH 00/23] Subject: [PATCH net-next 00/23] net/hpe: add HPE " Jakub Kicinski
2026-10-31 20:17   ` Andrew Lunn
2026-11-02  1:02     ` Doug Ledford
2026-11-02  1:35       ` Andrew Lunn
2026-11-02  3:45         ` Doug Ledford
2026-11-02 14:26           ` Andrew Lunn
2026-11-04  4:21             ` Doug Ledford
2026-11-04 13:39               ` Jason Gunthorpe
2026-11-04 16:03                 ` Doug Ledford
2026-11-04 14:48               ` Andrew Lunn
2026-11-04 15:04                 ` Jason Gunthorpe
2026-11-04 16:13                   ` Doug Ledford
2026-11-02  3:01       ` Guenter Roeck
2026-11-02 17:01         ` Doug Ledford
2026-11-02 17:39           ` Andrew Lunn
2026-11-02 18:12             ` Doug Ledford

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261030-cxi-netdev-submission-v1-15-8c2c391cc283@hpe.com \
    --to=doug.ledford@hpe.com \
    --cc=andrew+netdev@lunn.ch \
    --cc=christian.koenig@amd.com \
    --cc=davem@davemloft.net \
    --cc=edumazet@kernel.org \
    --cc=kuba@kernel.org \
    --cc=linux-kbuild@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux@roeck-us.net \
    --cc=nathan@kernel.org \
    --cc=netdev@vger.kernel.org \
    --cc=nsc@kernel.org \
    --cc=pabeni@redhat.com \
    --cc=richardcochran@gmail.com \
    --cc=sandeep.bhoot@hpe.com \
    --cc=slingshot-os-team@groups.ext.hpe.com \
    --cc=sumit.semwal@linaro.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®