staging: octeon: replace pr_warn with dev_warn in fill and rx paths

Add struct platform_device parameter to cvm_oct_fill_hw_memory,
cvm_oct_mem_fill_fpa, cvm_oct_rx_refill_pool and
cvm_oct_rx_initialize to support device-aware logging. Replace
pr_warn with dev_warn using &pdev->dev.
To avoid passing these parameters through global state, introduce
struct octeon_ethernet_platform to hold per-device state including
the rx_refill_work and the oct_rx_group array. This ensures all
receive group state and workers are correctly associated with the
platform device.
Define struct oct_rx_group and struct octeon_ethernet_platform in
octeon-ethernet.h so they are shared across compilation units.

Signed-off-by: Ayush Mukkanwar <ayushmukkanwar@gmail.com>
Link: https://patch.msgid.link/20260511150931.93382-4-ayushmukkanwar@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/octeon/ethernet-mem.c b/drivers/staging/octeon/ethernet-mem.c
index af79b2bdac278e432e20a2b7a6ae48eb295ebb26..68c3ef984e565dc1add1c9170cfca7c25f28ecec 100644 (file)
--- a/drivers/staging/octeon/ethernet-mem.c
+++ b/drivers/staging/octeon/ethernet-mem.c
@@ -71,13 +71,15 @@ static void cvm_oct_free_hw_skbuff(struct platform_device *pdev,
 
 /**
  * cvm_oct_fill_hw_memory - fill a hardware pool with memory.
+ * @pdev:     Platform 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 platform_device *pdev, int pool, int size,
+                                 int elements)
 {
        char *memory;
        char *fpa;
@@ -96,8 +98,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(&pdev->dev, "Unable to allocate %u bytes for FPA pool %d\n",
+                                elements * size, pool);
                        break;
                }
                fpa = (char *)(((unsigned long)memory + 256) & ~0x7fUL);
@@ -139,14 +141,14 @@ static void cvm_oct_free_hw_memory(struct platform_device *pdev,
                         pool, elements);
 }
 
-int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
+int cvm_oct_mem_fill_fpa(struct platform_device *pdev, 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(pdev, pool, size, elements);
        return freed;
 }
 

diff --git a/drivers/staging/octeon/ethernet-mem.h b/drivers/staging/octeon/ethernet-mem.h
index ff10ba4525ee84faa4eec664edb0df075ebd35dc..9279bb0de2db48dcc2a6dd7d4f5e779f3e5f9a71 100644 (file)
--- a/drivers/staging/octeon/ethernet-mem.h
+++ b/drivers/staging/octeon/ethernet-mem.h
@@ -5,8 +5,9 @@
  * Copyright (c) 2003-2007 Cavium Networks
  */
 
-int cvm_oct_mem_fill_fpa(int pool, int size, int elements);
 struct platform_device;
 
+int cvm_oct_mem_fill_fpa(struct platform_device *pdev, int pool, int size,
+                        int elements);
 void cvm_oct_mem_empty_fpa(struct platform_device *pdev, int pool, int size,
                           int elements);

diff --git a/drivers/staging/octeon/ethernet-rx.c b/drivers/staging/octeon/ethernet-rx.c
index d0b43d50b83ce113f4fc6a2ac828ad25a2282cf6..cd36b5ba6f6c294df595b7b6c675b2e44f064702 100644 (file)
--- a/drivers/staging/octeon/ethernet-rx.c
+++ b/drivers/staging/octeon/ethernet-rx.c
@@ -5,6 +5,7 @@
  * Copyright (c) 2003-2010 Cavium Networks
  */
 
+#include <linux/platform_device.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/cache.h>
@@ -31,12 +32,6 @@
 
 static atomic_t oct_rx_ready = ATOMIC_INIT(0);
 
-static struct oct_rx_group {
-       int irq;
-       int group;
-       struct napi_struct napi;
-} oct_rx_group[16];
-
 /**
  * cvm_oct_do_interrupt - interrupt handler.
  * @irq: Interrupt number.
@@ -397,7 +392,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->pdev, 0);
 
        return rx_count;
 }
@@ -434,24 +429,28 @@ static int cvm_oct_napi_poll(struct napi_struct *napi, int budget)
  */
 void cvm_oct_poll_controller(struct net_device *dev)
 {
+       struct platform_device *pdev = to_platform_device(dev->dev.parent);
+       struct octeon_ethernet_platform *plat = platform_get_drvdata(pdev);
        int i;
 
        if (!atomic_read(&oct_rx_ready))
                return;
 
-       for (i = 0; i < ARRAY_SIZE(oct_rx_group); i++) {
+       for (i = 0; i < ARRAY_SIZE(plat->rx_group); i++) {
                if (!(pow_receive_groups & BIT(i)))
                        continue;
 
-               cvm_oct_poll(&oct_rx_group[i], 16);
+               cvm_oct_poll(&plat->rx_group[i], 16);
        }
 }
 #endif
 
-void cvm_oct_rx_initialize(void)
+void cvm_oct_rx_initialize(struct platform_device *pdev)
 {
        int i;
        struct net_device *dev_for_napi = NULL;
+       struct octeon_ethernet_platform *plat = platform_get_drvdata(pdev);
+       struct oct_rx_group *rx_group = plat->rx_group;
 
        for (i = 0; i < TOTAL_NUMBER_OF_PORTS; i++) {
                if (cvm_oct_device[i]) {
@@ -463,27 +462,28 @@ void cvm_oct_rx_initialize(void)
        if (!dev_for_napi)
                panic("No net_devices were allocated.");
 
-       for (i = 0; i < ARRAY_SIZE(oct_rx_group); i++) {
+       for (i = 0; i < ARRAY_SIZE(plat->rx_group); i++) {
                int ret;
 
                if (!(pow_receive_groups & BIT(i)))
                        continue;
 
-               netif_napi_add_weight(dev_for_napi, &oct_rx_group[i].napi,
+               netif_napi_add_weight(dev_for_napi, &rx_group[i].napi,
                                      cvm_oct_napi_poll, rx_napi_weight);
-               napi_enable(&oct_rx_group[i].napi);
+               napi_enable(&rx_group[i].napi);
 
-               oct_rx_group[i].irq = OCTEON_IRQ_WORKQ0 + i;
-               oct_rx_group[i].group = i;
+               rx_group[i].irq = OCTEON_IRQ_WORKQ0 + i;
+               rx_group[i].group = i;
+               rx_group[i].pdev = pdev;
 
                /* Register an IRQ handler to receive POW interrupts */
-               ret = request_irq(oct_rx_group[i].irq, cvm_oct_do_interrupt, 0,
-                                 "Ethernet", &oct_rx_group[i].napi);
+               ret = request_irq(rx_group[i].irq, cvm_oct_do_interrupt, 0,
+                                 "Ethernet", &rx_group[i].napi);
                if (ret)
                        panic("Could not acquire Ethernet IRQ %d\n",
-                             oct_rx_group[i].irq);
+                             rx_group[i].irq);
 
-               disable_irq_nosync(oct_rx_group[i].irq);
+               disable_irq_nosync(rx_group[i].irq);
 
                /* Enable POW interrupt when our port has at least one packet */
                if (OCTEON_IS_MODEL(OCTEON_CN68XX)) {
@@ -515,16 +515,17 @@ void cvm_oct_rx_initialize(void)
                /* Schedule NAPI now. This will indirectly enable the
                 * interrupt.
                 */
-               napi_schedule(&oct_rx_group[i].napi);
+               napi_schedule(&rx_group[i].napi);
        }
        atomic_inc(&oct_rx_ready);
 }
 
-void cvm_oct_rx_shutdown(void)
+void cvm_oct_rx_shutdown(struct platform_device *pdev)
 {
+       struct octeon_ethernet_platform *plat = platform_get_drvdata(pdev);
        int i;
 
-       for (i = 0; i < ARRAY_SIZE(oct_rx_group); i++) {
+       for (i = 0; i < ARRAY_SIZE(plat->rx_group); i++) {
                if (!(pow_receive_groups & BIT(i)))
                        continue;
 
@@ -535,8 +536,8 @@ void cvm_oct_rx_shutdown(void)
                        cvmx_write_csr(CVMX_POW_WQ_INT_THRX(i), 0);
 
                /* Free the interrupt handler */
-               free_irq(oct_rx_group[i].irq, &oct_rx_group[i].napi);
+               free_irq(plat->rx_group[i].irq, &plat->rx_group[i].napi);
 
-               netif_napi_del(&oct_rx_group[i].napi);
+               netif_napi_del(&plat->rx_group[i].napi);
        }
 }

diff --git a/drivers/staging/octeon/ethernet-rx.h b/drivers/staging/octeon/ethernet-rx.h
index ff6482fa20d69dc761dff882f797a51dbe2e34ba..6093694326cb61a6f0e4c164136f826f767a5230 100644 (file)
--- a/drivers/staging/octeon/ethernet-rx.h
+++ b/drivers/staging/octeon/ethernet-rx.h
@@ -5,11 +5,14 @@
  * Copyright (c) 2003-2007 Cavium Networks
  */
 
+struct platform_device;
+
 void cvm_oct_poll_controller(struct net_device *dev);
-void cvm_oct_rx_initialize(void);
-void cvm_oct_rx_shutdown(void);
+void cvm_oct_rx_initialize(struct platform_device *pdev);
+void cvm_oct_rx_shutdown(struct platform_device *pdev);
 
-static inline void cvm_oct_rx_refill_pool(int fill_threshold)
+static inline void cvm_oct_rx_refill_pool(struct platform_device *pdev,
+                                         int fill_threshold)
 {
        int number_to_free;
        int num_freed;
@@ -20,7 +23,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(pdev, 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 eaa4f04093b8962fab5672adb4d98264f0022893..f3fa221f452e29bd9ff3d93810dfa2e1bbc19fa7 100644 (file)
--- a/drivers/staging/octeon/ethernet.c
+++ b/drivers/staging/octeon/ethernet.c
@@ -104,11 +104,10 @@ 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);
-
 static void cvm_oct_rx_refill_worker(struct work_struct *work)
 {
+       struct octeon_ethernet_platform *plat = 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 +115,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(plat->pdev, num_packet_buffers / 2);
 
        if (!atomic_read(&cvm_oct_poll_queue_stopping))
-               schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
+               schedule_delayed_work(&plat->rx_refill_work, HZ);
 }
 
 static void cvm_oct_periodic_worker(struct work_struct *work)
@@ -138,16 +137,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 platform_device *pdev)
 {
        /* 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(pdev, 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(pdev, 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(pdev, CVMX_FPA_OUTPUT_BUFFER_POOL,
                                     CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 1024);
 
 #ifdef __LITTLE_ENDIAN
@@ -678,6 +677,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 *plat;
+
+       plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
+       if (!plat)
+               return -ENOMEM;
+
+       plat->pdev = pdev;
+       INIT_DELAYED_WORK(&plat->rx_refill_work, cvm_oct_rx_refill_worker);
+       platform_set_drvdata(pdev, plat);
 
 #if IS_ENABLED(CONFIG_VLAN_8021Q)
        mtu_overhead += VLAN_HLEN;
@@ -689,7 +697,7 @@ static int cvm_oct_probe(struct platform_device *pdev)
                return -EINVAL;
        }
 
-       cvm_oct_configure_common_hw();
+       cvm_oct_configure_common_hw(pdev);
 
        cvmx_helper_initialize_packet_io_global();
 
@@ -912,28 +920,29 @@ static int cvm_oct_probe(struct platform_device *pdev)
        }
 
        cvm_oct_tx_initialize();
-       cvm_oct_rx_initialize();
+       cvm_oct_rx_initialize(pdev);
 
        /*
         * 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(&plat->rx_refill_work, HZ);
 
        return 0;
 }
 
 static void cvm_oct_remove(struct platform_device *pdev)
 {
+       struct octeon_ethernet_platform *plat = 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(&plat->rx_refill_work);
 
-       cvm_oct_rx_shutdown();
+       cvm_oct_rx_shutdown(pdev);
        cvm_oct_tx_shutdown();
 
        cvmx_pko_disable();

diff --git a/drivers/staging/octeon/octeon-ethernet.h b/drivers/staging/octeon/octeon-ethernet.h
index a6140705706f49c6d07111761ca157200b32b264..0ac430db1e6eb92728caa518715ba6eaca080c7e 100644 (file)
--- a/drivers/staging/octeon/octeon-ethernet.h
+++ b/drivers/staging/octeon/octeon-ethernet.h
@@ -11,6 +11,7 @@
 #ifndef OCTEON_ETHERNET_H
 #define OCTEON_ETHERNET_H
 
+#include <linux/netdevice.h>
 #include <linux/of.h>
 #include <linux/phy.h>
 
@@ -74,6 +75,19 @@ struct octeon_ethernet {
        struct device_node      *of_node;
 };
 
+struct oct_rx_group {
+       int irq;
+       int group;
+       struct napi_struct napi;
+       struct platform_device *pdev;
+};
+
+struct octeon_ethernet_platform {
+       struct platform_device *pdev;
+       struct delayed_work rx_refill_work;
+       struct oct_rx_group rx_group[16];
+};
+
 int cvm_oct_free_work(void *work_queue_entry);
 
 int cvm_oct_rgmii_open(struct net_device *dev);