* [PATCH v3 1/2] staging: octeon: ethernet-spi: replace pr_err with dev_err
2026-04-02 11:42 [PATCH v3 0/2] staging: octeon: replace pr_* with dev_* and netdev_* Ayush Mukkanwar
@ 2026-04-02 11:42 ` Ayush Mukkanwar
2026-04-02 11:42 ` [PATCH v3 2/2] staging: octeon: ethernet: replace pr_* with dev_* and netdev_* Ayush Mukkanwar
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Ayush Mukkanwar @ 2026-04-02 11:42 UTC (permalink / raw)
To: gregkh; +Cc: linux-staging, linux-kernel, Ayush Mukkanwar
Replace pr_err() calls with dev_err() to include device information
in log messages. The device pointer is passed through the interrupt
handler via dev_id, which is changed from &number_spi_ports to
netdev pointer in request_irq and free_irq.
Signed-off-by: Ayush Mukkanwar <ayushmukkanwar@gmail.com>
---
drivers/staging/octeon/ethernet-spi.c | 78 +++++++++++++--------------
1 file changed, 37 insertions(+), 41 deletions(-)
diff --git a/drivers/staging/octeon/ethernet-spi.c b/drivers/staging/octeon/ethernet-spi.c
index 699c98c5ec13..1e33544f74b8 100644
--- a/drivers/staging/octeon/ethernet-spi.c
+++ b/drivers/staging/octeon/ethernet-spi.c
@@ -17,67 +17,62 @@
static int number_spi_ports;
static int need_retrain[2] = { 0, 0 };
-static void cvm_oct_spxx_int_pr(union cvmx_spxx_int_reg spx_int_reg, int index)
+static void cvm_oct_spxx_int_pr(struct net_device *dev, union cvmx_spxx_int_reg spx_int_reg,
+ int index)
{
if (spx_int_reg.s.spf)
- pr_err("SPI%d: SRX Spi4 interface down\n", index);
+ netdev_err(dev, "SPI%d: SRX Spi4 interface down\n", index);
if (spx_int_reg.s.calerr)
- pr_err("SPI%d: SRX Spi4 Calendar table parity error\n", index);
+ netdev_err(dev, "SPI%d: SRX Spi4 Calendar table parity error\n", index);
if (spx_int_reg.s.syncerr)
- pr_err("SPI%d: SRX Consecutive Spi4 DIP4 errors have exceeded SPX_ERR_CTL[ERRCNT]\n",
- index);
+ netdev_err(dev, "SPI%d: SRX Consecutive Spi4 DIP4 errors have exceeded SPX_ERR_CTL[ERRCNT]\n",
+ index);
if (spx_int_reg.s.diperr)
- pr_err("SPI%d: SRX Spi4 DIP4 error\n", index);
+ netdev_err(dev, "SPI%d: SRX Spi4 DIP4 error\n", index);
if (spx_int_reg.s.tpaovr)
- pr_err("SPI%d: SRX Selected port has hit TPA overflow\n",
- index);
+ netdev_err(dev, "SPI%d: SRX Selected port has hit TPA overflow\n", index);
if (spx_int_reg.s.rsverr)
- pr_err("SPI%d: SRX Spi4 reserved control word detected\n",
- index);
+ netdev_err(dev, "SPI%d: SRX Spi4 reserved control word detected\n", index);
if (spx_int_reg.s.drwnng)
- pr_err("SPI%d: SRX Spi4 receive FIFO drowning/overflow\n",
- index);
+ netdev_err(dev, "SPI%d: SRX Spi4 receive FIFO drowning/overflow\n", index);
if (spx_int_reg.s.clserr)
- pr_err("SPI%d: SRX Spi4 packet closed on non-16B alignment without EOP\n",
- index);
+ netdev_err(dev, "SPI%d: SRX Spi4 packet closed on non-16B alignment without EOP\n",
+ index);
if (spx_int_reg.s.spiovr)
- pr_err("SPI%d: SRX Spi4 async FIFO overflow\n", index);
+ netdev_err(dev, "SPI%d: SRX Spi4 async FIFO overflow\n", index);
if (spx_int_reg.s.abnorm)
- pr_err("SPI%d: SRX Abnormal packet termination (ERR bit)\n",
- index);
+ netdev_err(dev, "SPI%d: SRX Abnormal packet termination (ERR bit)\n", index);
if (spx_int_reg.s.prtnxa)
- pr_err("SPI%d: SRX Port out of range\n", index);
+ netdev_err(dev, "SPI%d: SRX Port out of range\n", index);
}
-static void cvm_oct_stxx_int_pr(union cvmx_stxx_int_reg stx_int_reg, int index)
+static void cvm_oct_stxx_int_pr(struct net_device *dev,
+ union cvmx_stxx_int_reg stx_int_reg, int index)
{
if (stx_int_reg.s.syncerr)
- pr_err("SPI%d: STX Interface encountered a fatal error\n",
- index);
+ netdev_err(dev, "SPI%d: STX Interface encountered a fatal error\n", index);
if (stx_int_reg.s.frmerr)
- pr_err("SPI%d: STX FRMCNT has exceeded STX_DIP_CNT[MAXFRM]\n",
- index);
+ netdev_err(dev, "SPI%d: STX FRMCNT has exceeded STX_DIP_CNT[MAXFRM]\n",
+ index);
if (stx_int_reg.s.unxfrm)
- pr_err("SPI%d: STX Unexpected framing sequence\n", index);
+ netdev_err(dev, "SPI%d: STX Unexpected framing sequence\n", index);
if (stx_int_reg.s.nosync)
- pr_err("SPI%d: STX ERRCNT has exceeded STX_DIP_CNT[MAXDIP]\n",
- index);
+ netdev_err(dev, "SPI%d: STX ERRCNT has exceeded STX_DIP_CNT[MAXDIP]\n",
+ index);
if (stx_int_reg.s.diperr)
- pr_err("SPI%d: STX DIP2 error on the Spi4 Status channel\n",
- index);
+ netdev_err(dev, "SPI%d: STX DIP2 error on the Spi4 Status channel\n", index);
if (stx_int_reg.s.datovr)
- pr_err("SPI%d: STX Spi4 FIFO overflow error\n", index);
+ netdev_err(dev, "SPI%d: STX Spi4 FIFO overflow error\n", index);
if (stx_int_reg.s.ovrbst)
- pr_err("SPI%d: STX Transmit packet burst too big\n", index);
+ netdev_err(dev, "SPI%d: STX Transmit packet burst too big\n", index);
if (stx_int_reg.s.calpar1)
- pr_err("SPI%d: STX Calendar Table Parity Error Bank%d\n",
- index, 1);
+ netdev_err(dev, "SPI%d: STX Calendar Table Parity Error Bank%d\n",
+ index, 1);
if (stx_int_reg.s.calpar0)
- pr_err("SPI%d: STX Calendar Table Parity Error Bank%d\n",
- index, 0);
+ netdev_err(dev, "SPI%d: STX Calendar Table Parity Error Bank%d\n", index, 0);
}
-static irqreturn_t cvm_oct_spi_spx_int(int index)
+static irqreturn_t cvm_oct_spi_spx_int(struct net_device *dev, int index)
{
union cvmx_spxx_int_reg spx_int_reg;
union cvmx_stxx_int_reg stx_int_reg;
@@ -86,14 +81,14 @@ static irqreturn_t cvm_oct_spi_spx_int(int index)
cvmx_write_csr(CVMX_SPXX_INT_REG(index), spx_int_reg.u64);
if (!need_retrain[index]) {
spx_int_reg.u64 &= cvmx_read_csr(CVMX_SPXX_INT_MSK(index));
- cvm_oct_spxx_int_pr(spx_int_reg, index);
+ cvm_oct_spxx_int_pr(dev, spx_int_reg, index);
}
stx_int_reg.u64 = cvmx_read_csr(CVMX_STXX_INT_REG(index));
cvmx_write_csr(CVMX_STXX_INT_REG(index), stx_int_reg.u64);
if (!need_retrain[index]) {
stx_int_reg.u64 &= cvmx_read_csr(CVMX_STXX_INT_MSK(index));
- cvm_oct_stxx_int_pr(stx_int_reg, index);
+ cvm_oct_stxx_int_pr(dev, stx_int_reg, index);
}
cvmx_write_csr(CVMX_SPXX_INT_MSK(index), 0);
@@ -107,14 +102,15 @@ static irqreturn_t cvm_oct_spi_rml_interrupt(int cpl, void *dev_id)
{
irqreturn_t return_status = IRQ_NONE;
union cvmx_npi_rsl_int_blocks rsl_int_blocks;
+ struct net_device *dev = dev_id;
/* Check and see if this interrupt was caused by the GMX block */
rsl_int_blocks.u64 = cvmx_read_csr(CVMX_NPI_RSL_INT_BLOCKS);
if (rsl_int_blocks.s.spx1) /* 19 - SPX1_INT_REG & STX1_INT_REG */
- return_status = cvm_oct_spi_spx_int(1);
+ return_status = cvm_oct_spi_spx_int(dev, 1);
if (rsl_int_blocks.s.spx0) /* 18 - SPX0_INT_REG & STX0_INT_REG */
- return_status = cvm_oct_spi_spx_int(0);
+ return_status = cvm_oct_spi_spx_int(dev, 0);
return return_status;
}
@@ -196,7 +192,7 @@ int cvm_oct_spi_init(struct net_device *dev)
if (number_spi_ports == 0) {
r = request_irq(OCTEON_IRQ_RML, cvm_oct_spi_rml_interrupt,
- IRQF_SHARED, "SPI", &number_spi_ports);
+ IRQF_SHARED, "SPI", dev);
if (r)
return r;
}
@@ -221,6 +217,6 @@ void cvm_oct_spi_uninit(struct net_device *dev)
cvmx_write_csr(CVMX_SPXX_INT_MSK(interface), 0);
cvmx_write_csr(CVMX_STXX_INT_MSK(interface), 0);
}
- free_irq(OCTEON_IRQ_RML, &number_spi_ports);
+ free_irq(OCTEON_IRQ_RML, dev);
}
}
--
2.53.0
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH v3 2/2] staging: octeon: ethernet: replace pr_* with dev_* and netdev_*
2026-04-02 11:42 [PATCH v3 0/2] staging: octeon: replace pr_* with dev_* and netdev_* Ayush Mukkanwar
2026-04-02 11:42 ` [PATCH v3 1/2] staging: octeon: ethernet-spi: replace pr_err with dev_err Ayush Mukkanwar
@ 2026-04-02 11:42 ` Ayush Mukkanwar
2026-04-02 11:50 ` [PATCH v3 0/2] staging: octeon: " Greg KH
2026-04-02 13:17 ` Dan Carpenter
3 siblings, 0 replies; 5+ messages in thread
From: Ayush Mukkanwar @ 2026-04-02 11:42 UTC (permalink / raw)
To: gregkh; +Cc: linux-staging, linux-kernel, Ayush Mukkanwar
Replace pr_*() calls with dev_*() and netdev_*() to include device
information in log messages. A per-device struct
octeon_ethernet_platform is introduced to pass the device pointer
through work queue callbacks via container_of. The device pointer
is also stored in oct_rx_group to make it available in the NAPI
poll function and propagated through the memory pool functions by
adding a struct device * parameter.
Signed-off-by: Ayush Mukkanwar <ayushmukkanwar@gmail.com>
---
drivers/staging/octeon/ethernet-mem.c | 39 +++++++++--------
drivers/staging/octeon/ethernet-mem.h | 4 +-
drivers/staging/octeon/ethernet-rx.c | 6 ++-
drivers/staging/octeon/ethernet-rx.h | 6 +--
drivers/staging/octeon/ethernet.c | 63 ++++++++++++++++-----------
5 files changed, 68 insertions(+), 50 deletions(-)
diff --git a/drivers/staging/octeon/ethernet-mem.c b/drivers/staging/octeon/ethernet-mem.c
index 532594957ebc..d5caefe68608 100644
--- a/drivers/staging/octeon/ethernet-mem.c
+++ b/drivers/staging/octeon/ethernet-mem.c
@@ -43,8 +43,9 @@ static int cvm_oct_fill_hw_skbuff(int pool, int size, int elements)
* @pool: Pool to allocate an skbuff for
* @size: Size of the buffer needed for the pool
* @elements: Number of buffers to allocate
+ * @dev: Device to pass to dev_warn()
*/
-static void cvm_oct_free_hw_skbuff(int pool, int size, int elements)
+static void cvm_oct_free_hw_skbuff(int pool, int size, int elements, struct device *dev)
{
char *memory;
@@ -59,11 +60,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);
}
/**
@@ -71,10 +72,11 @@ static void cvm_oct_free_hw_skbuff(int pool, int size, int elements)
* @pool: Pool to populate
* @size: Size of each buffer in the pool
* @elements: Number of buffers to allocate
+ * @dev: Device to pass to dev_warn()
*
* 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(int pool, int size, int elements, struct device *dev)
{
char *memory;
char *fpa;
@@ -93,8 +95,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);
@@ -110,8 +112,9 @@ static int cvm_oct_fill_hw_memory(int pool, int size, int elements)
* @pool: FPA pool to free
* @size: Size of each buffer in the pool
* @elements: Number of buffers that should be in the pool
+ * @dev: Device to pass to dev_warn()
*/
-static void cvm_oct_free_hw_memory(int pool, int size, int elements)
+static void cvm_oct_free_hw_memory(int pool, int size, int elements, struct device *dev)
{
char *memory;
char *fpa;
@@ -127,28 +130,28 @@ 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, "Warning: Freeing of pool %u is missing %d buffers\n",
+ pool, elements);
}
-int cvm_oct_mem_fill_fpa(int pool, int size, int elements)
+int cvm_oct_mem_fill_fpa(int pool, int size, int elements, struct device *dev)
{
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(pool, size, elements, dev);
return freed;
}
-void cvm_oct_mem_empty_fpa(int pool, int size, int elements)
+void cvm_oct_mem_empty_fpa(int pool, int size, int elements, struct device *dev)
{
if (pool == CVMX_FPA_PACKET_POOL)
- cvm_oct_free_hw_skbuff(pool, size, elements);
+ cvm_oct_free_hw_skbuff(pool, size, elements, dev);
else
- cvm_oct_free_hw_memory(pool, size, elements);
+ cvm_oct_free_hw_memory(pool, size, elements, dev);
}
diff --git a/drivers/staging/octeon/ethernet-mem.h b/drivers/staging/octeon/ethernet-mem.h
index 692dcdb7154d..22a38846c751 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);
-void cvm_oct_mem_empty_fpa(int pool, int size, int elements);
+int cvm_oct_mem_fill_fpa(int pool, int size, int elements, struct device *dev);
+void cvm_oct_mem_empty_fpa(int pool, int size, int elements, struct device *dev);
diff --git a/drivers/staging/octeon/ethernet-rx.c b/drivers/staging/octeon/ethernet-rx.c
index d0b43d50b83c..461f9077742e 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(0, rx_group->dev);
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..443c6208d09d 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(int fill_threshold, struct device *dev)
{
int number_to_free;
int num_freed;
@@ -22,7 +22,7 @@ static inline void cvm_oct_rx_refill_pool(int fill_threshold)
-number_to_free);
num_freed = cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL,
CVMX_FPA_PACKET_POOL_SIZE,
- number_to_free);
+ number_to_free, dev);
if (num_freed != number_to_free) {
cvmx_fau_atomic_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE,
number_to_free - num_freed);
diff --git a/drivers/staging/octeon/ethernet.c b/drivers/staging/octeon/ethernet.c
index eadb74fc14c8..89df2a691a0d 100644
--- a/drivers/staging/octeon/ethernet.c
+++ b/drivers/staging/octeon/ethernet.c
@@ -104,11 +104,18 @@ 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 struct octeon_ethernet_platform *oct_plt;
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 +123,11 @@ 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(num_packet_buffers / 2, plt->dev);
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,17 +146,17 @@ 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,
- num_packet_buffers);
+ num_packet_buffers, dev);
cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
- num_packet_buffers);
+ num_packet_buffers, dev);
if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
- CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 1024);
+ CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 1024, dev);
#ifdef __LITTLE_ENDIAN
{
@@ -685,11 +693,17 @@ 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, "Error: No 'pip' in /aliases\n");
return -EINVAL;
}
- cvm_oct_configure_common_hw();
+ oct_plt = devm_kzalloc(&pdev->dev, sizeof(*oct_plt), GFP_KERNEL);
+ if (!oct_plt)
+ return -ENOMEM;
+ oct_plt->dev = &pdev->dev;
+ INIT_DELAYED_WORK(&oct_plt->rx_refill_work, cvm_oct_rx_refill_worker);
+
+ cvm_oct_configure_common_hw(&pdev->dev);
cvmx_helper_initialize_packet_io_global();
@@ -783,16 +797,15 @@ 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");
}
}
@@ -812,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;
}
@@ -897,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;
@@ -912,14 +925,14 @@ 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(&oct_plt->rx_refill_work, HZ);
return 0;
}
@@ -931,7 +944,7 @@ static void cvm_oct_remove(struct platform_device *pdev)
cvmx_ipd_disable();
atomic_inc_return(&cvm_oct_poll_queue_stopping);
- cancel_delayed_work_sync(&cvm_oct_rx_refill_work);
+ cancel_delayed_work_sync(&oct_plt->rx_refill_work);
cvm_oct_rx_shutdown();
cvm_oct_tx_shutdown();
@@ -959,12 +972,12 @@ static void cvm_oct_remove(struct platform_device *pdev)
/* Free the HW pools */
cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
- num_packet_buffers);
+ num_packet_buffers, &pdev->dev);
cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
- num_packet_buffers);
+ num_packet_buffers, &pdev->dev);
if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
- CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
+ CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128, &pdev->dev);
}
static const struct of_device_id cvm_oct_match[] = {
--
2.53.0
^ permalink raw reply related [flat|nested] 5+ messages in thread