Skip to contentSkip to conversation

staging: octeon: modernize logging and refactor to per-device state

PATCH Superseded Ayush Mukkanwar 3 participants 10 messages Apr 27 – May 4 Staging

v5 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v5 cover staging: octeon: modernize logging and refactor to per-device state

This series modernizes the logging infrastructure in the Octeon ethernet staging driver by replacing pr_warn(), pr_err(), and pr_info() calls with their device-aware counterparts (dev_warn(), dev_err(), netdev_err(), and netdev_info()), and refactors driver state to be per-device.

Patches 1-3 convert logging calls to include device context in messages. Patch 4 moves the static rx group array into the platform device private structure and passes struct platform_device through the call chains instead of struct device.

Changes in v5:
- Pass struct platform_device instead of struct device through ethernet-mem and ethernet-rx call chains (Greg)
- Move static oct_rx_group[16] array into the platform device private structure to eliminate file-scoped global state (Greg)
- Update kdoc parameter names to match renamed parameters

Changes in v4:
- Broke the series into much smaller, focused patches to ease review
- Removed the global cvm_oct_rx_refill_work by introducing a per-device struct octeon_ethernet_platform, allocated during probe
- Retrieved the device pointer via platform_get_drvdata() and passed it down the call chain (NAPI poll -> rx refill -> mem free/fill) as the first argument to avoid global state
- Note: Dropped the ethernet-spi.c IRQ handler conversions from this series for now, as those errors are SPI4 bus-level

Changes in v3:
- Use netdev_err() instead of dev_err() in ethernet-spi.c
- Pass the netdev pointer directly to request_irq/free_irq instead of dev->dev.parent
- Move the device pointer to be the first argument in helper functions
- Fix checkpatch alignment and line-length warnings
- Add missing @dev kernel-doc parameter descriptions
- Wrap commit message body to 75 characters
- Fix author name formatting

Changes in v2:
- Instead of adding pr_fmt() macros, replace pr_*() calls with proper dev_*() and netdev_*() calls
- Thread device pointer through call chains via function parameters
- Introduce struct octeon_ethernet_platform to pass device pointer through work queue callbacks via container_of
- Store device pointer in oct_rx_group for NAPI poll functions
- Use dev_id in interrupt handler to pass and retrieve device pointer

Ayush Mukkanwar (4):
staging: octeon: ethernet-mem: replace pr_warn with dev_warn in free
functions
staging: octeon: replace pr_warn with dev_warn in fill path
staging: octeon: ethernet: replace pr_err and pr_info with dev_err and
netdev_err
staging: octeon: refactor to per-device state and pass platform_device

 drivers/staging/octeon/ethernet-mem.c    | 44 +++++++++-------
 drivers/staging/octeon/ethernet-mem.h    |  8 ++-
 drivers/staging/octeon/ethernet-rx.c     | 49 +++++++++---------
 drivers/staging/octeon/ethernet-rx.h     | 11 ++--
 drivers/staging/octeon/ethernet.c        | 64 ++++++++++++++----------
 drivers/staging/octeon/octeon-ethernet.h | 18 ++++++-
 6 files changed, 116 insertions(+), 78 deletions(-)

--
2.53.0

#1 lore raw

PATCH v5 1/4 staging: octeon: ethernet-mem: replace pr_warn with dev_warn in free functions

Replace pr_warn() calls with dev_warn() in the hardware pool free functions (cvm_oct_free_hw_skbuff and cvm_oct_free_hw_memory) to include device information in log messages. The struct device pointer is passed from cvm_oct_remove() through cvm_oct_mem_empty_fpa() to the internal free functions.

---
 drivers/staging/octeon/ethernet-mem.c | 30 +++++++++++++++------------
 drivers/staging/octeon/ethernet-mem.h |  2 +-
 drivers/staging/octeon/ethernet.c     |  6 +++---
 3 files changed, 21 insertions(+), 17 deletions(-)
drivers/staging/octeon/ethernet-mem.c +17 -13
index 532594957ebc..501a2f7487c1 100644
@@ -40,11 +40,13 @@ static int cvm_oct_fill_hw_skbuff(int pool, int size, int elements)
 
 /**
  * cvm_oct_free_hw_skbuff- free hardware pool skbuffs
+ * @dev:      Device for logging
  * @pool:     Pool to allocate an skbuff for
  * @size:     Size of the buffer needed for the pool
  * @elements: Number of buffers to allocate
  */
-static void cvm_oct_free_hw_skbuff(int pool, int size, int elements)
+static void cvm_oct_free_hw_skbuff(struct device *dev,
+				   int pool, int size, int elements)
 {
 	char *memory;
 
@@ -59,11 +61,11 @@ static void cvm_oct_free_hw_skbuff(int pool, int size, int elements)
 	} while (memory);
 
 	if (elements < 0)
-		pr_warn("Freeing of pool %u had too many skbuffs (%d)\n",
-			pool, elements);
+		dev_warn(dev, "Freeing of pool %u had too many skbuffs (%d)\n",
+			 pool, elements);
 	else if (elements > 0)
-		pr_warn("Freeing of pool %u is missing %d skbuffs\n",
-			pool, elements);
+		dev_warn(dev, "Freeing of pool %u is missing %d skbuffs\n",
+			 pool, elements);
 }
 
 /**
@@ -107,11 +109,13 @@ static int cvm_oct_fill_hw_memory(int pool, int size, int elements)
 
 /**
  * cvm_oct_free_hw_memory - Free memory allocated by cvm_oct_fill_hw_memory
+ * @dev:      Device for logging
  * @pool:     FPA pool to free
  * @size:     Size of each buffer in the pool
  * @elements: Number of buffers that should be in the pool
  */
-static void cvm_oct_free_hw_memory(int pool, int size, int elements)
+static void cvm_oct_free_hw_memory(struct device *dev,
+				   int pool, int size, int elements)
 {
 	char *memory;
 	char *fpa;
@@ -127,11 +131,11 @@ static void cvm_oct_free_hw_memory(int pool, int size, int elements)
 	} while (fpa);
 
 	if (elements < 0)
-		pr_warn("Freeing of pool %u had too many buffers (%d)\n",
-			pool, elements);
+		dev_warn(dev, "Freeing of pool %u had too many buffers (%d)\n",
+			 pool, elements);
 	else if (elements > 0)
-		pr_warn("Warning: Freeing of pool %u is missing %d buffers\n",
-			pool, elements);
+		dev_warn(dev, "Freeing of pool %u is missing %d buffers\n",
+			 pool, elements);
 }
 
 int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
@@ -145,10 +149,10 @@ int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
 	return freed;
 }
 
-void cvm_oct_mem_empty_fpa(int pool, int size, int elements)
+void cvm_oct_mem_empty_fpa(struct device *dev, int pool, int size, int elements)
 {
 	if (pool == CVMX_FPA_PACKET_POOL)
-		cvm_oct_free_hw_skbuff(pool, size, elements);
+		cvm_oct_free_hw_skbuff(dev, pool, size, elements);
 	else
-		cvm_oct_free_hw_memory(pool, size, elements);
+		cvm_oct_free_hw_memory(dev, pool, size, elements);
 }
drivers/staging/octeon/ethernet-mem.h +1 -1
index 692dcdb7154d..591e0bbb6f10 100644
@@ -6,4 +6,4 @@
  */
 
 int cvm_oct_mem_fill_fpa(int pool, int size, int elements);
-void cvm_oct_mem_empty_fpa(int pool, int size, int elements);
+void cvm_oct_mem_empty_fpa(struct device *dev, int pool, int size, int elements);
drivers/staging/octeon/ethernet.c +3 -3
index eadb74fc14c8..9eed0a89a2f3 100644
@@ -958,12 +958,12 @@ static void cvm_oct_remove(struct platform_device *pdev)
 	cvmx_ipd_free_ptr();
 
 	/* Free the HW pools */
-	cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
+	cvm_oct_mem_empty_fpa(&pdev->dev, CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
 			      num_packet_buffers);
-	cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
+	cvm_oct_mem_empty_fpa(&pdev->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_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
+		cvm_oct_mem_empty_fpa(&pdev->dev, CVMX_FPA_OUTPUT_BUFFER_POOL,
 				      CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
 }
 
Signature · 1 line
2.53.0
maintainer
#2 lore raw

Re: [PATCH v5 1/4] staging: octeon: ethernet-mem: replace pr_warn with dev_warn in free functions

Quoted 5 lines · Ayush Mukkanwar

Replace pr_warn() calls with dev_warn() in the hardware pool free functions (cvm_oct_free_hw_skbuff and cvm_oct_free_hw_memory) to include device information in log messages. The struct device pointer is passed from cvm_oct_remove() through cvm_oct_mem_empty_fpa() to the internal free functions.

Why aren't you passing through the platform device pointer? Why deal with the "raw" struct device? Always try to keep the "highest level" pointer to work with where ever possible.

thanks,

greg k-h

#3 lore raw

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

In reply to Ayush Mukkanwar

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.

---
 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(-)
drivers/staging/octeon/ethernet-mem.c +7 -5
index 501a2f7487c1..f182698dd057 100644
@@ -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;
 }
 
drivers/staging/octeon/ethernet-mem.h +1 -1
index 591e0bbb6f10..edfc93b2b23b 100644
@@ -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);
drivers/staging/octeon/ethernet-rx.c +4 -2
index d0b43d50b83c..a2f4e52d69f3 100644
@@ -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,
drivers/staging/octeon/ethernet-rx.h +3 -3
index ff6482fa20d6..636ee7d549f6 100644
@@ -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) {
drivers/staging/octeon/ethernet.c +27 -12
index 9eed0a89a2f3..a7ac29c0a4ca 100644
@@ -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();
Signature · 1 line
2.53.0
maintainer
#4 lore raw

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

Quoted 10 lines · Ayush Mukkanwar

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().

Quoted 2 lines

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

Why isn't this the platform device? And why isn't this data just part of the platform device's data anyway? Why is it a separate "thing"?

thanks,

greg k-h

#5 lore raw

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

Quoted 15 lines · Greg KH
Quoted 10 lines · Ayush Mukkanwar

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().

Quoted 2 lines

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

Quoted 6 lines

Why isn't this the platform device? And why isn't this data just part of the platform device's data anyway? Why is it a separate "thing"?

thanks,

greg k-h

Hi Greg,

Thank you for the review.

The changes you're pointing out were in the later patches of the v5 series. My mistake was splitting them across patches rather than doing it correctly from the start, which left an inconsistent intermediate state.

I've reworked the series so that struct platform_device is passed from the first patch, and oct_rx_group is placed inside octeon_ethernet_platform in the same patch that introduces it.

Will send v6 shortly.

Thanks,
Ayush

#6 lore raw

PATCH v5 3/4 staging: octeon: ethernet: replace pr_err and pr_info with dev_err and netdev_err

In reply to Ayush Mukkanwar

Replace pr_err() and pr_info() calls in cvm_oct_probe() with dev_err(), netdev_err(), and netdev_info() to include device information in log messages. Use dev_err() where no net_device is available (allocation failures), and netdev_err()/netdev_info() where a net_device exists.

---
 drivers/staging/octeon/ethernet.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)
drivers/staging/octeon/ethernet.c +10 -10
index a7ac29c0a4ca..7c3cfd9efa7e 100644
@@ -698,7 +698,7 @@ static int cvm_oct_probe(struct platform_device *pdev)
 
 	pip = pdev->dev.of_node;
 	if (!pip) {
-		pr_err("Error: No 'pip' in /aliases\n");
+		dev_err(&pdev->dev, "No 'pip' in /aliases\n");
 		return -EINVAL;
 	}
 
@@ -796,16 +796,16 @@ static int cvm_oct_probe(struct platform_device *pdev)
 			dev->max_mtu = OCTEON_MAX_MTU - mtu_overhead;
 
 			if (register_netdev(dev) < 0) {
-				pr_err("Failed to register ethernet device for POW\n");
+				netdev_err(dev, "Failed to register ethernet device for POW\n");
 				free_netdev(dev);
 			} else {
 				cvm_oct_device[CVMX_PIP_NUM_INPUT_PORTS] = dev;
-				pr_info("%s: POW send group %d, receive group %d\n",
-					dev->name, pow_send_group,
-					pow_receive_group);
+				netdev_info(dev, "POW send group %d, receive group %d\n",
+					    pow_send_group,
+					    pow_receive_group);
 			}
 		} else {
-			pr_err("Failed to allocate ethernet device for POW\n");
+			dev_err(&pdev->dev, "Failed to allocate ethernet device for POW\n");
 		}
 	}
 
@@ -825,8 +825,8 @@ static int cvm_oct_probe(struct platform_device *pdev)
 			struct net_device *dev =
 			    alloc_etherdev(sizeof(struct octeon_ethernet));
 			if (!dev) {
-				pr_err("Failed to allocate ethernet device for port %d\n",
-				       port);
+				dev_err(&pdev->dev, "Failed to allocate ethernet device for port %d\n",
+					port);
 				continue;
 			}
 
@@ -910,8 +910,8 @@ static int cvm_oct_probe(struct platform_device *pdev)
 			if (!dev->netdev_ops) {
 				free_netdev(dev);
 			} else if (register_netdev(dev) < 0) {
-				pr_err("Failed to register ethernet device for interface %d, port %d\n",
-				       interface, priv->port);
+				netdev_err(dev, "Failed to register ethernet device for interface %d, port %d\n",
+					   interface, priv->port);
 				free_netdev(dev);
 			} else {
 				cvm_oct_device[priv->port] = dev;
Signature · 1 line
2.53.0
#7 lore raw

PATCH v5 4/4 staging: octeon: refactor to per-device state and pass platform_device

In reply to Ayush Mukkanwar

Move the static oct_rx_group array from ethernet-rx.c into the octeon_ethernet_platform structure to associate receive group state with the platform device. Pass struct platform_device instead of struct device through the ethernet-mem and ethernet-rx call chains, extracting &pdev->dev only at the point of use in dev_warn() calls.

Move struct oct_rx_group and struct octeon_ethernet_platform definitions into octeon-ethernet.h so they are shared across compilation units.

---
 drivers/staging/octeon/ethernet-mem.c    | 34 ++++++++--------
 drivers/staging/octeon/ethernet-mem.h    |  8 +++-
 drivers/staging/octeon/ethernet-rx.c     | 51 ++++++++++++------------
 drivers/staging/octeon/ethernet-rx.h     | 11 +++--
 drivers/staging/octeon/ethernet.c        | 29 ++++++--------
 drivers/staging/octeon/octeon-ethernet.h | 18 ++++++++-
 6 files changed, 83 insertions(+), 68 deletions(-)
drivers/staging/octeon/ethernet-mem.c +17 -17
index f182698dd057..c9b439aaf23f 100644
@@ -5,13 +5,13 @@
  * Copyright (c) 2003-2010 Cavium Networks
  */
 
+#include <linux/platform_device.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/slab.h>
 
 #include "octeon-ethernet.h"
 #include "ethernet-mem.h"
-#include "ethernet-defines.h"
 
 /**
  * cvm_oct_fill_hw_skbuff - fill the supplied hardware pool with skbuffs
@@ -40,12 +40,12 @@ static int cvm_oct_fill_hw_skbuff(int pool, int size, int elements)
 
 /**
  * cvm_oct_free_hw_skbuff- free hardware pool skbuffs
- * @dev:      Device for logging
+ * @pdev:     Platform device for logging
  * @pool:     Pool to allocate an skbuff for
  * @size:     Size of the buffer needed for the pool
  * @elements: Number of buffers to allocate
  */
-static void cvm_oct_free_hw_skbuff(struct device *dev,
+static void cvm_oct_free_hw_skbuff(struct platform_device *pdev,
 				   int pool, int size, int elements)
 {
 	char *memory;
@@ -61,23 +61,23 @@ static void cvm_oct_free_hw_skbuff(struct device *dev,
 	} while (memory);
 
 	if (elements < 0)
-		dev_warn(dev, "Freeing of pool %u had too many skbuffs (%d)\n",
+		dev_warn(&pdev->dev, "Freeing of pool %u had too many skbuffs (%d)\n",
 			 pool, elements);
 	else if (elements > 0)
-		dev_warn(dev, "Freeing of pool %u is missing %d skbuffs\n",
+		dev_warn(&pdev->dev, "Freeing of pool %u is missing %d skbuffs\n",
 			 pool, elements);
 }
 
 /**
  * cvm_oct_fill_hw_memory - fill a hardware pool with memory.
- * @dev:      Device for logging
+ * @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(struct device *dev, int pool, int size,
+static int cvm_oct_fill_hw_memory(struct platform_device *pdev, int pool, int size,
 				  int elements)
 {
 	char *memory;
@@ -97,7 +97,7 @@ static int cvm_oct_fill_hw_memory(struct device *dev, int pool, int size,
 		 */
 		memory = kmalloc(size + 256, GFP_ATOMIC);
 		if (unlikely(!memory)) {
-			dev_warn(dev, "Unable to allocate %u bytes for FPA pool %d\n",
+			dev_warn(&pdev->dev, "Unable to allocate %u bytes for FPA pool %d\n",
 				 elements * size, pool);
 			break;
 		}
@@ -111,12 +111,12 @@ static int cvm_oct_fill_hw_memory(struct device *dev, int pool, int size,
 
 /**
  * cvm_oct_free_hw_memory - Free memory allocated by cvm_oct_fill_hw_memory
- * @dev:      Device for logging
+ * @pdev:     Platform device for logging
  * @pool:     FPA pool to free
  * @size:     Size of each buffer in the pool
  * @elements: Number of buffers that should be in the pool
  */
-static void cvm_oct_free_hw_memory(struct device *dev,
+static void cvm_oct_free_hw_memory(struct platform_device *pdev,
 				   int pool, int size, int elements)
 {
 	char *memory;
@@ -133,28 +133,28 @@ static void cvm_oct_free_hw_memory(struct device *dev,
 	} while (fpa);
 
 	if (elements < 0)
-		dev_warn(dev, "Freeing of pool %u had too many buffers (%d)\n",
+		dev_warn(&pdev->dev, "Freeing of pool %u had too many buffers (%d)\n",
 			 pool, elements);
 	else if (elements > 0)
-		dev_warn(dev, "Freeing of pool %u is missing %d buffers\n",
+		dev_warn(&pdev->dev, "Freeing of pool %u is missing %d buffers\n",
 			 pool, elements);
 }
 
-int cvm_oct_mem_fill_fpa(struct device *dev, 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(dev, pool, size, elements);
+		freed = cvm_oct_fill_hw_memory(pdev, pool, size, elements);
 	return freed;
 }
 
-void cvm_oct_mem_empty_fpa(struct device *dev, int pool, int size, int elements)
+void cvm_oct_mem_empty_fpa(struct platform_device *pdev, int pool, int size, int elements)
 {
 	if (pool == CVMX_FPA_PACKET_POOL)
-		cvm_oct_free_hw_skbuff(dev, pool, size, elements);
+		cvm_oct_free_hw_skbuff(pdev, pool, size, elements);
 	else
-		cvm_oct_free_hw_memory(dev, pool, size, elements);
+		cvm_oct_free_hw_memory(pdev, pool, size, elements);
 }
drivers/staging/octeon/ethernet-mem.h +6 -2
index edfc93b2b23b..9279bb0de2db 100644
@@ -5,5 +5,9 @@
  * Copyright (c) 2003-2007 Cavium Networks
  */
 
-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);
+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);
drivers/staging/octeon/ethernet-rx.c +25 -26

127 lines not on this page · raw message

drivers/staging/octeon/ethernet-rx.h +7 -4
index 636ee7d549f6..6093694326cb 100644
@@ -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(struct device *dev);
-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(struct device *dev, 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(struct device *dev, 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(dev, 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) {
drivers/staging/octeon/ethernet.c +12 -17
index 7c3cfd9efa7e..02984a27523c 100644
@@ -104,11 +104,6 @@ struct net_device *cvm_oct_device[TOTAL_NUMBER_OF_PORTS];
 
 u64 cvm_oct_tx_poll_interval;
 
-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,
@@ -120,7 +115,7 @@ 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(plt->dev, num_packet_buffers / 2);
+	cvm_oct_rx_refill_pool(plt->pdev, num_packet_buffers / 2);
 
 	if (!atomic_read(&cvm_oct_poll_queue_stopping))
 		schedule_delayed_work(&plt->rx_refill_work, HZ);
@@ -142,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(struct device *dev)
+static void cvm_oct_configure_common_hw(struct platform_device *pdev)
 {
 	/* Setup the FPA */
 	cvmx_fpa_enable();
-	cvm_oct_mem_fill_fpa(dev, 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(dev, 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(dev, 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
@@ -688,7 +683,7 @@ static int cvm_oct_probe(struct platform_device *pdev)
 	if (!plt)
 		return -ENOMEM;
 
-	plt->dev = &pdev->dev;
+	plt->pdev = pdev;
 	INIT_DELAYED_WORK(&plt->rx_refill_work, cvm_oct_rx_refill_worker);
 	platform_set_drvdata(pdev, plt);
 
@@ -702,7 +697,7 @@ static int cvm_oct_probe(struct platform_device *pdev)
 		return -EINVAL;
 	}
 
-	cvm_oct_configure_common_hw(&pdev->dev);
+	cvm_oct_configure_common_hw(pdev);
 
 	cvmx_helper_initialize_packet_io_global();
 
@@ -925,7 +920,7 @@ static int cvm_oct_probe(struct platform_device *pdev)
 	}
 
 	cvm_oct_tx_initialize();
-	cvm_oct_rx_initialize(&pdev->dev);
+	cvm_oct_rx_initialize(pdev);
 
 	/*
 	 * 150 uS: about 10 1500-byte packets at 1GE.
@@ -948,7 +943,7 @@ static void cvm_oct_remove(struct platform_device *pdev)
 
 	cancel_delayed_work_sync(&plt->rx_refill_work);
 
-	cvm_oct_rx_shutdown();
+	cvm_oct_rx_shutdown(pdev);
 	cvm_oct_tx_shutdown();
 
 	cvmx_pko_disable();
@@ -973,12 +968,12 @@ static void cvm_oct_remove(struct platform_device *pdev)
 	cvmx_ipd_free_ptr();
 
 	/* Free the HW pools */
-	cvm_oct_mem_empty_fpa(&pdev->dev, CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
+	cvm_oct_mem_empty_fpa(pdev, CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
 			      num_packet_buffers);
-	cvm_oct_mem_empty_fpa(&pdev->dev, CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
+	cvm_oct_mem_empty_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_empty_fpa(&pdev->dev, CVMX_FPA_OUTPUT_BUFFER_POOL,
+		cvm_oct_mem_empty_fpa(pdev, CVMX_FPA_OUTPUT_BUFFER_POOL,
 				      CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
 }
 
drivers/staging/octeon/octeon-ethernet.h +16 -2
index a6140705706f..57e4029a13d0 100644
@@ -11,6 +11,7 @@
 #ifndef OCTEON_ETHERNET_H
 #define OCTEON_ETHERNET_H
 
+#include <linux/netdevice.h>
 #include <linux/of.h>
 #include <linux/phy.h>
 
@@ -70,8 +71,21 @@ struct octeon_ethernet {
 	u64 link_info;
 	/* Called periodically to check link status */
 	void (*poll)(struct net_device *dev);
-	struct delayed_work	port_periodic_work;
-	struct device_node	*of_node;
+	struct delayed_work port_periodic_work;
+	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);
Signature · 1 line
2.53.0
#8 lore raw

Re: [PATCH v5 4/4] staging: octeon: refactor to per-device state and pass platform_device

Quoted 3 lines · Ayush Mukkanwar

Move the static oct_rx_group array from ethernet-rx.c into the octeon_ethernet_platform structure to associate receive group state with the platform device.

How is this related to logging?

Quoted 3 lines

Pass struct platform_device instead of
struct device through the ethernet-mem and ethernet-rx call chains, extracting &pdev->dev only at the point of use in dev_warn() calls.

You're undoing something that you did in patch 1. Just do it correctly the first time instead of doing it and the fixing it in the same patchset.

Quoted 5 lines

Move struct oct_rx_group and struct octeon_ethernet_platform definitions into octeon-ethernet.h so they are shared across compilation units.

Btw, here:

Review

Quoted 1 line
(quoted diff) +1 -0
+	struct octeon_ethernet_platform *plt = platform_get_drvdata(pdev);

Could you name it "plat" instead of "plt"? Generally "plt" is an acronym for something else. Procedure Linkage Table or Phy LED Trigger. There are a couple other meanings.

regards,
dan carpenter

#9 lore raw

Re: [PATCH v5 4/4] staging: octeon: refactor to per-device state and pass platform_device

Quoted 24 lines · Dan Carpenter
Quoted 3 lines · Ayush Mukkanwar

Move the static oct_rx_group array from ethernet-rx.c into the octeon_ethernet_platform structure to associate receive group state with the platform device.

How is this related to logging?

Quoted 3 lines

Pass struct platform_device instead of
struct device through the ethernet-mem and ethernet-rx call chains, extracting &pdev->dev only at the point of use in dev_warn() calls.

You're undoing something that you did in patch 1. Just do it correctly the first time instead of doing it and the fixing it in the same patchset.

Quoted 5 lines

Move struct oct_rx_group and struct octeon_ethernet_platform definitions into octeon-ethernet.h so they are shared across compilation units.

Btw, here:

Quoted 9 lines
Quoted 1 line

+ struct octeon_ethernet_platform *plt = platform_get_drvdata(pdev);

Could you name it "plat" instead of "plt"? Generally "plt" is an acronym for something else. Procedure Linkage Table or Phy LED Trigger. There are a couple other meanings.

regards,
dan carpenter

Thanks for the review, Dan.

The rx_group refactoring was requested by Greg in his v4 review. The logging conversion required storing a device pointer in the static oct_rx_group array to pass it through the rx poll path. Greg asked to eliminate that global state by moving it into the platform device local structure.

You're right that I should fold the platform_device change into the earlier patches to avoid the undo. I'll also rename plt to plat. Will send v6 with these fixes.