[PATCH v5 2/4] staging: octeon: replace pr_warn with dev_warn in fill path

Ayush Mukkanwar
2026-04-27T15:18:06Z

Replace pr_warn() with dev_warn() in cvm_oct_fill_hw_memory() to
include device information in log messages.

To make the device pointer accessible from the workqueue callback,
introduce struct octeon_ethernet_platform to hold both a struct
device pointer and the delayed_work. This replaces the static global
cvm_oct_rx_refill_work. The struct is allocated with devm_kzalloc()
in probe() and stored via platform_set_drvdata(). The worker
retrieves it using container_of().

Add a struct device pointer to oct_rx_group and thread it through
cvm_oct_rx_initialize() to support the NAPI poll refill path.

Signed-off-by: Ayush Mukkanwar <ayushmukkanwar@gmail.com>
---
drivers/staging/octeon/ethernet-mem.c | 12 +++++----
drivers/staging/octeon/ethernet-mem.h | 2 +-
drivers/staging/octeon/ethernet-rx.c | 6 +++--
drivers/staging/octeon/ethernet-rx.h | 6 ++---
drivers/staging/octeon/ethernet.c | 39 ++++++++++++++++++---------
5 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/drivers/staging/octeon/ethernet-mem.c b/drivers/staging/octeon/ethernet-mem.c
index 501a2f7487c1..f182698dd057 100644
--- a/drivers/staging/octeon/ethernet-mem.c
+++ b/drivers/staging/octeon/ethernet-mem.c
@@ -70,13 +70,15 @@ static void cvm_oct_free_hw_skbuff(struct device *dev,

/**
* cvm_oct_fill_hw_memory - fill a hardware pool with memory.
+ * @dev: Device for logging
* @pool: Pool to populate
* @size: Size of each buffer in the pool
* @elements: Number of buffers to allocate
*
* Returns the actual number of buffers allocated.
*/
-static int cvm_oct_fill_hw_memory(int pool, int size, int elements)
+static int cvm_oct_fill_hw_memory(struct device *dev, int pool, int size,
+ int elements)
{
char *memory;
char *fpa;
@@ -95,8 +97,8 @@ static int cvm_oct_fill_hw_memory(int pool, int size, int elements)
*/
memory = kmalloc(size + 256, GFP_ATOMIC);
if (unlikely(!memory)) {
- pr_warn("Unable to allocate %u bytes for FPA pool %d\n",
- elements * size, pool);
+ dev_warn(dev, "Unable to allocate %u bytes for FPA pool %d\n",
+ elements * size, pool);
break;
}
fpa = (char *)(((unsigned long)memory + 256) & ~0x7fUL);
@@ -138,14 +140,14 @@ static void cvm_oct_free_hw_memory(struct device *dev,
pool, elements);
}

-int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
+int cvm_oct_mem_fill_fpa(struct device *dev, int pool, int size, int elements)
{
int freed;

if (pool == CVMX_FPA_PACKET_POOL)
freed = cvm_oct_fill_hw_skbuff(pool, size, elements);
else
- freed = cvm_oct_fill_hw_memory(pool, size, elements);
+ freed = cvm_oct_fill_hw_memory(dev, pool, size, elements);
return freed;
}

diff --git a/drivers/staging/octeon/ethernet-mem.h b/drivers/staging/octeon/ethernet-mem.h
index 591e0bbb6f10..edfc93b2b23b 100644
--- a/drivers/staging/octeon/ethernet-mem.h
+++ b/drivers/staging/octeon/ethernet-mem.h
@@ -5,5 +5,5 @@
* Copyright (c) 2003-2007 Cavium Networks
*/

-int cvm_oct_mem_fill_fpa(int pool, int size, int elements);
+int cvm_oct_mem_fill_fpa(struct device *dev, int pool, int size, int elements);
void cvm_oct_mem_empty_fpa(struct device *dev, int pool, int size, int elements);
diff --git a/drivers/staging/octeon/ethernet-rx.c b/drivers/staging/octeon/ethernet-rx.c
index d0b43d50b83c..a2f4e52d69f3 100644
--- a/drivers/staging/octeon/ethernet-rx.c
+++ b/drivers/staging/octeon/ethernet-rx.c
@@ -35,6 +35,7 @@ static struct oct_rx_group {
int irq;
int group;
struct napi_struct napi;
+ struct device *dev;
} oct_rx_group[16];

/**
@@ -397,7 +398,7 @@ static int cvm_oct_poll(struct oct_rx_group *rx_group, int budget)
/* Restore the scratch area */
cvmx_scratch_write64(CVMX_SCR_SCRATCH, old_scratch);
}
- cvm_oct_rx_refill_pool(0);
+ cvm_oct_rx_refill_pool(rx_group->dev, 0);

return rx_count;
}
@@ -448,7 +449,7 @@ void cvm_oct_poll_controller(struct net_device *dev)
}
#endif

-void cvm_oct_rx_initialize(void)
+void cvm_oct_rx_initialize(struct device *dev)
{
int i;
struct net_device *dev_for_napi = NULL;
@@ -475,6 +476,7 @@ void cvm_oct_rx_initialize(void)

oct_rx_group[i].irq = OCTEON_IRQ_WORKQ0 + i;
oct_rx_group[i].group = i;
+ oct_rx_group[i].dev = dev;

/* Register an IRQ handler to receive POW interrupts */
ret = request_irq(oct_rx_group[i].irq, cvm_oct_do_interrupt, 0,
diff --git a/drivers/staging/octeon/ethernet-rx.h b/drivers/staging/octeon/ethernet-rx.h
index ff6482fa20d6..636ee7d549f6 100644
--- a/drivers/staging/octeon/ethernet-rx.h
+++ b/drivers/staging/octeon/ethernet-rx.h
@@ -6,10 +6,10 @@
*/

void cvm_oct_poll_controller(struct net_device *dev);
-void cvm_oct_rx_initialize(void);
+void cvm_oct_rx_initialize(struct device *dev);
void cvm_oct_rx_shutdown(void);

-static inline void cvm_oct_rx_refill_pool(int fill_threshold)
+static inline void cvm_oct_rx_refill_pool(struct device *dev, int fill_threshold)
{
int number_to_free;
int num_freed;
@@ -20,7 +20,7 @@ static inline void cvm_oct_rx_refill_pool(int fill_threshold)
if (number_to_free > fill_threshold) {
cvmx_fau_atomic_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE,
-number_to_free);
- num_freed = cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL,
+ num_freed = cvm_oct_mem_fill_fpa(dev, CVMX_FPA_PACKET_POOL,
CVMX_FPA_PACKET_POOL_SIZE,
number_to_free);
if (num_freed != number_to_free) {
diff --git a/drivers/staging/octeon/ethernet.c b/drivers/staging/octeon/ethernet.c
index 9eed0a89a2f3..a7ac29c0a4ca 100644
--- a/drivers/staging/octeon/ethernet.c
+++ b/drivers/staging/octeon/ethernet.c
@@ -104,11 +104,15 @@ struct net_device *cvm_oct_device[TOTAL_NUMBER_OF_PORTS];

u64 cvm_oct_tx_poll_interval;

-static void cvm_oct_rx_refill_worker(struct work_struct *work);
-static DECLARE_DELAYED_WORK(cvm_oct_rx_refill_work, cvm_oct_rx_refill_worker);
+struct octeon_ethernet_platform {
+ struct device *dev;
+ struct delayed_work rx_refill_work;
+};

static void cvm_oct_rx_refill_worker(struct work_struct *work)
{
+ struct octeon_ethernet_platform *plt = container_of(work,
+ struct octeon_ethernet_platform, rx_refill_work.work);
/*
* FPA 0 may have been drained, try to refill it if we need
* more than num_packet_buffers / 2, otherwise normal receive
@@ -116,10 +120,10 @@ static void cvm_oct_rx_refill_worker(struct work_struct *work)
* could be received so cvm_oct_napi_poll would never be
* invoked to do the refill.
*/
- cvm_oct_rx_refill_pool(num_packet_buffers / 2);
+ cvm_oct_rx_refill_pool(plt->dev, num_packet_buffers / 2);

if (!atomic_read(&cvm_oct_poll_queue_stopping))
- schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
+ schedule_delayed_work(&plt->rx_refill_work, HZ);
}

static void cvm_oct_periodic_worker(struct work_struct *work)
@@ -138,16 +142,16 @@ static void cvm_oct_periodic_worker(struct work_struct *work)
schedule_delayed_work(&priv->port_periodic_work, HZ);
}

-static void cvm_oct_configure_common_hw(void)
+static void cvm_oct_configure_common_hw(struct device *dev)
{
/* Setup the FPA */
cvmx_fpa_enable();
- cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
+ cvm_oct_mem_fill_fpa(dev, CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
num_packet_buffers);
- cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
+ cvm_oct_mem_fill_fpa(dev, CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
num_packet_buffers);
if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
- cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
+ cvm_oct_mem_fill_fpa(dev, CVMX_FPA_OUTPUT_BUFFER_POOL,
CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 1024);

#ifdef __LITTLE_ENDIAN
@@ -678,6 +682,15 @@ static int cvm_oct_probe(struct platform_device *pdev)
int qos;
struct device_node *pip;
int mtu_overhead = ETH_HLEN + ETH_FCS_LEN;
+ struct octeon_ethernet_platform *plt;
+
+ plt = devm_kzalloc(&pdev->dev, sizeof(*plt), GFP_KERNEL);
+ if (!plt)
+ return -ENOMEM;
+
+ plt->dev = &pdev->dev;
+ INIT_DELAYED_WORK(&plt->rx_refill_work, cvm_oct_rx_refill_worker);
+ platform_set_drvdata(pdev, plt);

#if IS_ENABLED(CONFIG_VLAN_8021Q)
mtu_overhead += VLAN_HLEN;
@@ -689,7 +702,7 @@ static int cvm_oct_probe(struct platform_device *pdev)
return -EINVAL;
}

- cvm_oct_configure_common_hw();
+ cvm_oct_configure_common_hw(&pdev->dev);

cvmx_helper_initialize_packet_io_global();

@@ -912,26 +925,28 @@ static int cvm_oct_probe(struct platform_device *pdev)
}

cvm_oct_tx_initialize();
- cvm_oct_rx_initialize();
+ cvm_oct_rx_initialize(&pdev->dev);

/*
* 150 uS: about 10 1500-byte packets at 1GE.
*/
cvm_oct_tx_poll_interval = 150 * (octeon_get_clock_rate() / 1000000);

- schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
+ schedule_delayed_work(&plt->rx_refill_work, HZ);

return 0;
}

static void cvm_oct_remove(struct platform_device *pdev)
{
+ struct octeon_ethernet_platform *plt = platform_get_drvdata(pdev);
int port;

cvmx_ipd_disable();

atomic_inc_return(&cvm_oct_poll_queue_stopping);
- cancel_delayed_work_sync(&cvm_oct_rx_refill_work);
+
+ cancel_delayed_work_sync(&plt->rx_refill_work);

cvm_oct_rx_shutdown();
cvm_oct_tx_shutdown();
--
2.53.0