[PATCH v1 net-next 00/11] ENA driver changes

[PATCH v1 net-next 00/11] ENA driver changes

[darinzon]

From: David Arinzon <darinzon@amazon.com>

This patchset contains a set of minor and cosmetic
changes to the ENA driver.

David Arinzon (11):
  net: ena: Remove an unused field
  net: ena: Add more documentation for RX copybreak
  net: ena: Minor cosmetic changes
  net: ena: Enable DIM by default
  net: ena: Remove CQ tail pointer update
  net: ena: Change error print during ena_device_init()
  net: ena: Add more information on TX timeouts
  net: ena: Relocate skb_tx_timestamp() to improve time stamping
    accuracy
  net: ena: Change default print level for netif_ prints
  net: ena: handle ena_calc_io_queue_size() possible errors
  net: ena: Reduce lines with longer column width boundary

 .../device_drivers/ethernet/amazon/ena.rst    |   6 +
 drivers/net/ethernet/amazon/ena/ena_com.c     | 323 ++++++------------
 drivers/net/ethernet/amazon/ena/ena_com.h     |   6 +-
 drivers/net/ethernet/amazon/ena/ena_eth_com.c |  49 ++-
 drivers/net/ethernet/amazon/ena/ena_eth_com.h |  39 +--
 drivers/net/ethernet/amazon/ena/ena_netdev.c  | 161 ++++++---
 .../net/ethernet/amazon/ena/ena_regs_defs.h   |   1 +
 drivers/net/ethernet/amazon/ena/ena_xdp.c     |   1 -
 8 files changed, 258 insertions(+), 328 deletions(-)

-- 
2.40.1

[PATCH v1 net-next 01/11] net: ena: Remove an unused field

[darinzon]

From: David Arinzon <darinzon@amazon.com>

Remove io_sq->header_addr field because it is no longer
in use.
LLQ was updated to support a bounce buffer so there is
no need in saving the header address of the sq.

Signed-off-by: Nati Koler <nkoler@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_com.c | 3 ---
 drivers/net/ethernet/amazon/ena/ena_com.h | 1 -
 2 files changed, 4 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
index 633b321..9a8a43b 100644
--- a/drivers/net/ethernet/amazon/ena/ena_com.c
+++ b/drivers/net/ethernet/amazon/ena/ena_com.c
@@ -1284,9 +1284,6 @@ static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
 		(uintptr_t)cmd_completion.sq_doorbell_offset);
 
 	if (io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV) {
-		io_sq->header_addr = (u8 __iomem *)((uintptr_t)ena_dev->mem_bar
-				+ cmd_completion.llq_headers_offset);
-
 		io_sq->desc_addr.pbuf_dev_addr =
 			(u8 __iomem *)((uintptr_t)ena_dev->mem_bar +
 			cmd_completion.llq_descriptors_offset);
diff --git a/drivers/net/ethernet/amazon/ena/ena_com.h b/drivers/net/ethernet/amazon/ena/ena_com.h
index 3c5081d..f3176fc 100644
--- a/drivers/net/ethernet/amazon/ena/ena_com.h
+++ b/drivers/net/ethernet/amazon/ena/ena_com.h
@@ -158,7 +158,6 @@ struct ena_com_io_sq {
 	struct ena_com_io_desc_addr desc_addr;
 
 	u32 __iomem *db_addr;
-	u8 __iomem *header_addr;
 
 	enum queue_direction direction;
 	enum ena_admin_placement_policy_type mem_queue_type;
-- 
2.40.1

[PATCH v1 net-next 02/11] net: ena: Add more documentation for RX copybreak

[darinzon]

From: David Arinzon <darinzon@amazon.com>

This patch contains more details about the functionality
of RX copybreak.

Signed-off-by: Shay Agroskin <shayagr@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 .../networking/device_drivers/ethernet/amazon/ena.rst       | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Documentation/networking/device_drivers/ethernet/amazon/ena.rst b/Documentation/networking/device_drivers/ethernet/amazon/ena.rst
index b842bcb..a4c7d0c 100644
--- a/Documentation/networking/device_drivers/ethernet/amazon/ena.rst
+++ b/Documentation/networking/device_drivers/ethernet/amazon/ena.rst
@@ -211,10 +211,16 @@ Documentation/networking/net_dim.rst
 
 RX copybreak
 ============
+
 The rx_copybreak is initialized by default to ENA_DEFAULT_RX_COPYBREAK
 and can be configured by the ETHTOOL_STUNABLE command of the
 SIOCETHTOOL ioctl.
 
+This option controls the maximum packet length for which the RX
+descriptor it was received on would be recycled. When a packet smaller
+than RX copybreak bytes is received, it is copied into a new memory
+buffer and the RX descriptor is returned to HW.
+
 Statistics
 ==========
 
-- 
2.40.1

[PATCH v1 net-next 03/11] net: ena: Minor cosmetic changes

[darinzon]

From: David Arinzon <darinzon@amazon.com>

A few changes for better readability and style

1. Adding / Removing newlines
2. Removing an unnecessary and confusing comment
3. Using an existing variable rather than re-checking a field

Signed-off-by: Shay Agroskin <shayagr@amazon.com>
Signed-off-by: Arthur Kiyanovski <akiyano@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_netdev.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index 1c0a782..d68d081 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -2197,8 +2197,6 @@ void ena_down(struct ena_adapter *adapter)
 	/* After this point the napi handler won't enable the tx queue */
 	ena_napi_disable_in_range(adapter, 0, io_queue_count);
 
-	/* After destroy the queue there won't be any new interrupts */
-
 	if (test_bit(ENA_FLAG_TRIGGER_RESET, &adapter->flags)) {
 		int rc;
 
@@ -3226,7 +3224,7 @@ static void ena_destroy_device(struct ena_adapter *adapter, bool graceful)
 	if (!graceful)
 		ena_com_set_admin_running_state(ena_dev, false);
 
-	if (test_bit(ENA_FLAG_DEV_UP, &adapter->flags))
+	if (dev_up)
 		ena_down(adapter);
 
 	/* Stop the device from sending AENQ events (in case reset flag is set
@@ -4040,8 +4038,8 @@ static void __ena_shutoff(struct pci_dev *pdev, bool shutdown)
 		free_irq_cpu_rmap(netdev->rx_cpu_rmap);
 		netdev->rx_cpu_rmap = NULL;
 	}
-#endif /* CONFIG_RFS_ACCEL */
 
+#endif /* CONFIG_RFS_ACCEL */
 	/* Make sure timer and reset routine won't be called after
 	 * freeing device resources.
 	 */
-- 
2.40.1

[PATCH v1 net-next 04/11] net: ena: Enable DIM by default

[darinzon]

From: David Arinzon <darinzon@amazon.com>

Dynamic Interrupt Moderation (DIM) is a technique
designed to balance the need for timely data processing
with the desire to minimize CPU overhead.
Instead of generating an interrupt for every received
packet, the system can dynamically adjust the rate at
which interrupts are generated based on the incoming
traffic patterns.

Enabling DIM by default to improve the user experience.

DIM can be turned on/off through ethtool:
`ethtool -C <interface> adaptive-rx <on/off>`

Signed-off-by: Arthur Kiyanovski <akiyano@amazon.com>
Signed-off-by: Osama Abboud <osamaabb@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_netdev.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index d68d081..0b7f94f 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -2134,6 +2134,12 @@ int ena_up(struct ena_adapter *adapter)
 	 */
 	ena_init_napi_in_range(adapter, 0, io_queue_count);
 
+	/* Enabling DIM needs to happen before enabling IRQs since DIM
+	 * is run from napi routine
+	 */
+	if (ena_com_interrupt_moderation_supported(adapter->ena_dev))
+		ena_com_enable_adaptive_moderation(adapter->ena_dev);
+
 	rc = ena_request_io_irq(adapter);
 	if (rc)
 		goto err_req_irq;
-- 
2.40.1

[PATCH v1 net-next 05/11] net: ena: Remove CQ tail pointer update

[darinzon]

From: David Arinzon <darinzon@amazon.com>

The functionality was added to allow the drivers to create an
SQ and CQ of different sizes.
When the RX/TX SQ and CQ have the same size, such update isn't
necessary as the device can safely assume it doesn't override
unprocessed completions. However, if the SQ is larger than the CQ,
the device might "have" more completions it wants to update about
than there's room in the CQ.

There's no support for different SQ and CQ sizes, therefore,
removing the API and its usage.

'____cacheline_aligned' compiler attribute was added to
'struct ena_com_io_cq' to ensure that the removal of the
'cq_head_db_reg' field doesn't change the cache-line layout
of this struct.

Signed-off-by: Shay Agroskin <shayagr@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_com.c     |  5 ----
 drivers/net/ethernet/amazon/ena/ena_com.h     |  5 +---
 drivers/net/ethernet/amazon/ena/ena_eth_com.h | 24 -------------------
 drivers/net/ethernet/amazon/ena/ena_netdev.c  |  5 +---
 drivers/net/ethernet/amazon/ena/ena_xdp.c     |  1 -
 5 files changed, 2 insertions(+), 38 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
index 9a8a43b..675ee72 100644
--- a/drivers/net/ethernet/amazon/ena/ena_com.c
+++ b/drivers/net/ethernet/amazon/ena/ena_com.c
@@ -1427,11 +1427,6 @@ int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
 	io_cq->unmask_reg = (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
 		cmd_completion.cq_interrupt_unmask_register_offset);
 
-	if (cmd_completion.cq_head_db_register_offset)
-		io_cq->cq_head_db_reg =
-			(u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
-			cmd_completion.cq_head_db_register_offset);
-
 	if (cmd_completion.numa_node_register_offset)
 		io_cq->numa_node_cfg_reg =
 			(u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
diff --git a/drivers/net/ethernet/amazon/ena/ena_com.h b/drivers/net/ethernet/amazon/ena/ena_com.h
index f3176fc..8f90c3c 100644
--- a/drivers/net/ethernet/amazon/ena/ena_com.h
+++ b/drivers/net/ethernet/amazon/ena/ena_com.h
@@ -109,8 +109,6 @@ struct ena_com_io_cq {
 	/* Interrupt unmask register */
 	u32 __iomem *unmask_reg;
 
-	/* The completion queue head doorbell register */
-	u32 __iomem *cq_head_db_reg;
 
 	/* numa configuration register (for TPH) */
 	u32 __iomem *numa_node_cfg_reg;
@@ -118,7 +116,7 @@ struct ena_com_io_cq {
 	/* The value to write to the above register to unmask
 	 * the interrupt of this queue
 	 */
-	u32 msix_vector;
+	u32 msix_vector ____cacheline_aligned;
 
 	enum queue_direction direction;
 
@@ -134,7 +132,6 @@ struct ena_com_io_cq {
 	/* Device queue index */
 	u16 idx;
 	u16 head;
-	u16 last_head_update;
 	u8 phase;
 	u8 cdesc_entry_size_in_bytes;
 
diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.h b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
index 372b259..4d65d82 100644
--- a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
+++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
@@ -8,8 +8,6 @@
 
 #include "ena_com.h"
 
-/* head update threshold in units of (queue size / ENA_COMP_HEAD_THRESH) */
-#define ENA_COMP_HEAD_THRESH 4
 /* we allow 2 DMA descriptors per LLQ entry */
 #define ENA_LLQ_ENTRY_DESC_CHUNK_SIZE	(2 * sizeof(struct ena_eth_io_tx_desc))
 #define ENA_LLQ_HEADER		(128UL - ENA_LLQ_ENTRY_DESC_CHUNK_SIZE)
@@ -172,28 +170,6 @@ static inline int ena_com_write_sq_doorbell(struct ena_com_io_sq *io_sq)
 	return 0;
 }
 
-static inline int ena_com_update_dev_comp_head(struct ena_com_io_cq *io_cq)
-{
-	u16 unreported_comp, head;
-	bool need_update;
-
-	if (unlikely(io_cq->cq_head_db_reg)) {
-		head = io_cq->head;
-		unreported_comp = head - io_cq->last_head_update;
-		need_update = unreported_comp > (io_cq->q_depth / ENA_COMP_HEAD_THRESH);
-
-		if (unlikely(need_update)) {
-			netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
-				   "Write completion queue doorbell for queue %d: head: %d\n",
-				   io_cq->qid, head);
-			writel(head, io_cq->cq_head_db_reg);
-			io_cq->last_head_update = head;
-		}
-	}
-
-	return 0;
-}
-
 static inline void ena_com_update_numa_node(struct ena_com_io_cq *io_cq,
 					    u8 numa_node)
 {
diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index 0b7f94f..cd75e5a 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -856,7 +856,6 @@ static int ena_clean_tx_irq(struct ena_ring *tx_ring, u32 budget)
 
 	tx_ring->next_to_clean = next_to_clean;
 	ena_com_comp_ack(tx_ring->ena_com_io_sq, total_done);
-	ena_com_update_dev_comp_head(tx_ring->ena_com_io_cq);
 
 	netdev_tx_completed_queue(txq, tx_pkts, tx_bytes);
 
@@ -1303,10 +1302,8 @@ static int ena_clean_rx_irq(struct ena_ring *rx_ring, struct napi_struct *napi,
 		      ENA_RX_REFILL_THRESH_PACKET);
 
 	/* Optimization, try to batch new rx buffers */
-	if (refill_required > refill_threshold) {
-		ena_com_update_dev_comp_head(rx_ring->ena_com_io_cq);
+	if (refill_required > refill_threshold)
 		ena_refill_rx_bufs(rx_ring, refill_required);
-	}
 
 	if (xdp_flags & ENA_XDP_REDIRECT)
 		xdp_do_flush();
diff --git a/drivers/net/ethernet/amazon/ena/ena_xdp.c b/drivers/net/ethernet/amazon/ena/ena_xdp.c
index fc1c4ef..337c435 100644
--- a/drivers/net/ethernet/amazon/ena/ena_xdp.c
+++ b/drivers/net/ethernet/amazon/ena/ena_xdp.c
@@ -412,7 +412,6 @@ static int ena_clean_xdp_irq(struct ena_ring *tx_ring, u32 budget)
 
 	tx_ring->next_to_clean = next_to_clean;
 	ena_com_comp_ack(tx_ring->ena_com_io_sq, total_done);
-	ena_com_update_dev_comp_head(tx_ring->ena_com_io_cq);
 
 	netif_dbg(tx_ring->adapter, tx_done, tx_ring->netdev,
 		  "tx_poll: q %d done. total pkts: %d\n",
-- 
2.40.1

Re: [PATCH v1 net-next 05/11] net: ena: Remove CQ tail pointer update

[Nelson, Shannon]

On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> 
> From: David Arinzon <darinzon@amazon.com>
> 
> The functionality was added to allow the drivers to create an
> SQ and CQ of different sizes.
> When the RX/TX SQ and CQ have the same size, such update isn't
> necessary as the device can safely assume it doesn't override
> unprocessed completions. However, if the SQ is larger than the CQ,
> the device might "have" more completions it wants to update about
> than there's room in the CQ.
> 
> There's no support for different SQ and CQ sizes, therefore,
> removing the API and its usage.
> 
> '____cacheline_aligned' compiler attribute was added to
> 'struct ena_com_io_cq' to ensure that the removal of the
> 'cq_head_db_reg' field doesn't change the cache-line layout
> of this struct.
> 
> Signed-off-by: Shay Agroskin <shayagr@amazon.com>
> Signed-off-by: David Arinzon <darinzon@amazon.com>
> ---
>   drivers/net/ethernet/amazon/ena/ena_com.c     |  5 ----
>   drivers/net/ethernet/amazon/ena/ena_com.h     |  5 +---
>   drivers/net/ethernet/amazon/ena/ena_eth_com.h | 24 -------------------
>   drivers/net/ethernet/amazon/ena/ena_netdev.c  |  5 +---
>   drivers/net/ethernet/amazon/ena/ena_xdp.c     |  1 -
>   5 files changed, 2 insertions(+), 38 deletions(-)
> 
> diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
> index 9a8a43b..675ee72 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_com.c
> +++ b/drivers/net/ethernet/amazon/ena/ena_com.c
> @@ -1427,11 +1427,6 @@ int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
>          io_cq->unmask_reg = (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
>                  cmd_completion.cq_interrupt_unmask_register_offset);
> 
> -       if (cmd_completion.cq_head_db_register_offset)
> -               io_cq->cq_head_db_reg =
> -                       (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
> -                       cmd_completion.cq_head_db_register_offset);
> -
>          if (cmd_completion.numa_node_register_offset)
>                  io_cq->numa_node_cfg_reg =
>                          (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
> diff --git a/drivers/net/ethernet/amazon/ena/ena_com.h b/drivers/net/ethernet/amazon/ena/ena_com.h
> index f3176fc..8f90c3c 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_com.h
> +++ b/drivers/net/ethernet/amazon/ena/ena_com.h
> @@ -109,8 +109,6 @@ struct ena_com_io_cq {
>          /* Interrupt unmask register */
>          u32 __iomem *unmask_reg;
> 
> -       /* The completion queue head doorbell register */
> -       u32 __iomem *cq_head_db_reg;

You'll want to remove one of the surrounding blank lines as well so as 
to not end up with multiple blanks in a row.

sln

> 
>          /* numa configuration register (for TPH) */
>          u32 __iomem *numa_node_cfg_reg;
> @@ -118,7 +116,7 @@ struct ena_com_io_cq {
>          /* The value to write to the above register to unmask
>           * the interrupt of this queue
>           */
> -       u32 msix_vector;
> +       u32 msix_vector ____cacheline_aligned;
> 
>          enum queue_direction direction;
> 
> @@ -134,7 +132,6 @@ struct ena_com_io_cq {
>          /* Device queue index */
>          u16 idx;
>          u16 head;
> -       u16 last_head_update;
>          u8 phase;
>          u8 cdesc_entry_size_in_bytes;
> 
> diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.h b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> index 372b259..4d65d82 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> +++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> @@ -8,8 +8,6 @@
> 
>   #include "ena_com.h"
> 
> -/* head update threshold in units of (queue size / ENA_COMP_HEAD_THRESH) */
> -#define ENA_COMP_HEAD_THRESH 4
>   /* we allow 2 DMA descriptors per LLQ entry */
>   #define ENA_LLQ_ENTRY_DESC_CHUNK_SIZE  (2 * sizeof(struct ena_eth_io_tx_desc))
>   #define ENA_LLQ_HEADER         (128UL - ENA_LLQ_ENTRY_DESC_CHUNK_SIZE)
> @@ -172,28 +170,6 @@ static inline int ena_com_write_sq_doorbell(struct ena_com_io_sq *io_sq)
>          return 0;
>   }
> 
> -static inline int ena_com_update_dev_comp_head(struct ena_com_io_cq *io_cq)
> -{
> -       u16 unreported_comp, head;
> -       bool need_update;
> -
> -       if (unlikely(io_cq->cq_head_db_reg)) {
> -               head = io_cq->head;
> -               unreported_comp = head - io_cq->last_head_update;
> -               need_update = unreported_comp > (io_cq->q_depth / ENA_COMP_HEAD_THRESH);
> -
> -               if (unlikely(need_update)) {
> -                       netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> -                                  "Write completion queue doorbell for queue %d: head: %d\n",
> -                                  io_cq->qid, head);
> -                       writel(head, io_cq->cq_head_db_reg);
> -                       io_cq->last_head_update = head;
> -               }
> -       }
> -
> -       return 0;
> -}
> -
>   static inline void ena_com_update_numa_node(struct ena_com_io_cq *io_cq,
>                                              u8 numa_node)
>   {
> diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> index 0b7f94f..cd75e5a 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> +++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> @@ -856,7 +856,6 @@ static int ena_clean_tx_irq(struct ena_ring *tx_ring, u32 budget)
> 
>          tx_ring->next_to_clean = next_to_clean;
>          ena_com_comp_ack(tx_ring->ena_com_io_sq, total_done);
> -       ena_com_update_dev_comp_head(tx_ring->ena_com_io_cq);
> 
>          netdev_tx_completed_queue(txq, tx_pkts, tx_bytes);
> 
> @@ -1303,10 +1302,8 @@ static int ena_clean_rx_irq(struct ena_ring *rx_ring, struct napi_struct *napi,
>                        ENA_RX_REFILL_THRESH_PACKET);
> 
>          /* Optimization, try to batch new rx buffers */
> -       if (refill_required > refill_threshold) {
> -               ena_com_update_dev_comp_head(rx_ring->ena_com_io_cq);
> +       if (refill_required > refill_threshold)
>                  ena_refill_rx_bufs(rx_ring, refill_required);
> -       }
> 
>          if (xdp_flags & ENA_XDP_REDIRECT)
>                  xdp_do_flush();
> diff --git a/drivers/net/ethernet/amazon/ena/ena_xdp.c b/drivers/net/ethernet/amazon/ena/ena_xdp.c
> index fc1c4ef..337c435 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_xdp.c
> +++ b/drivers/net/ethernet/amazon/ena/ena_xdp.c
> @@ -412,7 +412,6 @@ static int ena_clean_xdp_irq(struct ena_ring *tx_ring, u32 budget)
> 
>          tx_ring->next_to_clean = next_to_clean;
>          ena_com_comp_ack(tx_ring->ena_com_io_sq, total_done);
> -       ena_com_update_dev_comp_head(tx_ring->ena_com_io_cq);
> 
>          netif_dbg(tx_ring->adapter, tx_done, tx_ring->netdev,
>                    "tx_poll: q %d done. total pkts: %d\n",
> --
> 2.40.1
> 
> 

RE: [PATCH v1 net-next 05/11] net: ena: Remove CQ tail pointer update

[Arinzon, David]

> On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> >
> > From: David Arinzon <darinzon@amazon.com>
> >
> > The functionality was added to allow the drivers to create an SQ and
> > CQ of different sizes.
> > When the RX/TX SQ and CQ have the same size, such update isn't
> > necessary as the device can safely assume it doesn't override
> > unprocessed completions. However, if the SQ is larger than the CQ, the
> > device might "have" more completions it wants to update about than
> > there's room in the CQ.
> >
> > There's no support for different SQ and CQ sizes, therefore, removing
> > the API and its usage.
> >
> > '____cacheline_aligned' compiler attribute was added to 'struct
> > ena_com_io_cq' to ensure that the removal of the 'cq_head_db_reg'
> > field doesn't change the cache-line layout of this struct.
> >
> > Signed-off-by: Shay Agroskin <shayagr@amazon.com>
> > Signed-off-by: David Arinzon <darinzon@amazon.com>
> > ---
> >   drivers/net/ethernet/amazon/ena/ena_com.c     |  5 ----
> >   drivers/net/ethernet/amazon/ena/ena_com.h     |  5 +---
> >   drivers/net/ethernet/amazon/ena/ena_eth_com.h | 24 -------------------
> >   drivers/net/ethernet/amazon/ena/ena_netdev.c  |  5 +---
> >   drivers/net/ethernet/amazon/ena/ena_xdp.c     |  1 -
> >   5 files changed, 2 insertions(+), 38 deletions(-)
> >
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c
> > b/drivers/net/ethernet/amazon/ena/ena_com.c
> > index 9a8a43b..675ee72 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_com.c
> > +++ b/drivers/net/ethernet/amazon/ena/ena_com.c
> > @@ -1427,11 +1427,6 @@ int ena_com_create_io_cq(struct ena_com_dev
> *ena_dev,
> >          io_cq->unmask_reg = (u32 __iomem *)((uintptr_t)ena_dev->reg_bar
> +
> >                  cmd_completion.cq_interrupt_unmask_register_offset);
> >
> > -       if (cmd_completion.cq_head_db_register_offset)
> > -               io_cq->cq_head_db_reg =
> > -                       (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
> > -                       cmd_completion.cq_head_db_register_offset);
> > -
> >          if (cmd_completion.numa_node_register_offset)
> >                  io_cq->numa_node_cfg_reg =
> >                          (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_com.h
> > b/drivers/net/ethernet/amazon/ena/ena_com.h
> > index f3176fc..8f90c3c 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_com.h
> > +++ b/drivers/net/ethernet/amazon/ena/ena_com.h
> > @@ -109,8 +109,6 @@ struct ena_com_io_cq {
> >          /* Interrupt unmask register */
> >          u32 __iomem *unmask_reg;
> >
> > -       /* The completion queue head doorbell register */
> > -       u32 __iomem *cq_head_db_reg;
> 
> You'll want to remove one of the surrounding blank lines as well so as to not
> end up with multiple blanks in a row.
> 
> sln
> 

Good catch! Thanks for noticing it. Will fix it in the next patchset.

David

> >
> >          /* numa configuration register (for TPH) */
> >          u32 __iomem *numa_node_cfg_reg; @@ -118,7 +116,7 @@ struct
> > ena_com_io_cq {
> >          /* The value to write to the above register to unmask
> >           * the interrupt of this queue
> >           */
> > -       u32 msix_vector;
> > +       u32 msix_vector ____cacheline_aligned;
> >
> >          enum queue_direction direction;
> >
> > @@ -134,7 +132,6 @@ struct ena_com_io_cq {
> >          /* Device queue index */
> >          u16 idx;
> >          u16 head;
> > -       u16 last_head_update;
> >          u8 phase;
> >          u8 cdesc_entry_size_in_bytes;
> >
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> > b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> > index 372b259..4d65d82 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> > +++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> > @@ -8,8 +8,6 @@
> >
> >   #include "ena_com.h"
> >
> > -/* head update threshold in units of (queue size /
> > ENA_COMP_HEAD_THRESH) */ -#define ENA_COMP_HEAD_THRESH 4
> >   /* we allow 2 DMA descriptors per LLQ entry */
> >   #define ENA_LLQ_ENTRY_DESC_CHUNK_SIZE  (2 * sizeof(struct
> ena_eth_io_tx_desc))
> >   #define ENA_LLQ_HEADER         (128UL -
> ENA_LLQ_ENTRY_DESC_CHUNK_SIZE)
> > @@ -172,28 +170,6 @@ static inline int ena_com_write_sq_doorbell(struct
> ena_com_io_sq *io_sq)
> >          return 0;
> >   }
> >
> > -static inline int ena_com_update_dev_comp_head(struct ena_com_io_cq
> > *io_cq) -{
> > -       u16 unreported_comp, head;
> > -       bool need_update;
> > -
> > -       if (unlikely(io_cq->cq_head_db_reg)) {
> > -               head = io_cq->head;
> > -               unreported_comp = head - io_cq->last_head_update;
> > -               need_update = unreported_comp > (io_cq->q_depth /
> ENA_COMP_HEAD_THRESH);
> > -
> > -               if (unlikely(need_update)) {
> > -                       netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)-
> >net_device,
> > -                                  "Write completion queue doorbell for queue %d: head:
> %d\n",
> > -                                  io_cq->qid, head);
> > -                       writel(head, io_cq->cq_head_db_reg);
> > -                       io_cq->last_head_update = head;
> > -               }
> > -       }
> > -
> > -       return 0;
> > -}
> > -
> >   static inline void ena_com_update_numa_node(struct ena_com_io_cq
> *io_cq,
> >                                              u8 numa_node)
> >   {
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > index 0b7f94f..cd75e5a 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > +++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > @@ -856,7 +856,6 @@ static int ena_clean_tx_irq(struct ena_ring
> > *tx_ring, u32 budget)
> >
> >          tx_ring->next_to_clean = next_to_clean;
> >          ena_com_comp_ack(tx_ring->ena_com_io_sq, total_done);
> > -       ena_com_update_dev_comp_head(tx_ring->ena_com_io_cq);
> >
> >          netdev_tx_completed_queue(txq, tx_pkts, tx_bytes);
> >
> > @@ -1303,10 +1302,8 @@ static int ena_clean_rx_irq(struct ena_ring
> *rx_ring, struct napi_struct *napi,
> >                        ENA_RX_REFILL_THRESH_PACKET);
> >
> >          /* Optimization, try to batch new rx buffers */
> > -       if (refill_required > refill_threshold) {
> > -               ena_com_update_dev_comp_head(rx_ring->ena_com_io_cq);
> > +       if (refill_required > refill_threshold)
> >                  ena_refill_rx_bufs(rx_ring, refill_required);
> > -       }
> >
> >          if (xdp_flags & ENA_XDP_REDIRECT)
> >                  xdp_do_flush();
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_xdp.c
> > b/drivers/net/ethernet/amazon/ena/ena_xdp.c
> > index fc1c4ef..337c435 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_xdp.c
> > +++ b/drivers/net/ethernet/amazon/ena/ena_xdp.c
> > @@ -412,7 +412,6 @@ static int ena_clean_xdp_irq(struct ena_ring
> > *tx_ring, u32 budget)
> >
> >          tx_ring->next_to_clean = next_to_clean;
> >          ena_com_comp_ack(tx_ring->ena_com_io_sq, total_done);
> > -       ena_com_update_dev_comp_head(tx_ring->ena_com_io_cq);
> >
> >          netif_dbg(tx_ring->adapter, tx_done, tx_ring->netdev,
> >                    "tx_poll: q %d done. total pkts: %d\n",
> > --
> > 2.40.1
> >
> >

[PATCH v1 net-next 06/11] net: ena: Change error print during ena_device_init()

[darinzon]

From: David Arinzon <darinzon@amazon.com>

The print was re-worded to a more informative one.

Signed-off-by: Shahar Itzko <itzko@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_netdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index cd75e5a..18acb76 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -3071,6 +3071,7 @@ static int ena_device_init(struct ena_adapter *adapter, struct pci_dev *pdev,
 			   bool *wd_state)
 {
 	struct ena_com_dev *ena_dev = adapter->ena_dev;
+	struct net_device *netdev = adapter->netdev;
 	struct ena_llq_configurations llq_config;
 	struct device *dev = &pdev->dev;
 	bool readless_supported;
@@ -3160,7 +3161,7 @@ static int ena_device_init(struct ena_adapter *adapter, struct pci_dev *pdev,
 	rc = ena_set_queues_placement_policy(pdev, ena_dev, &get_feat_ctx->llq,
 					     &llq_config);
 	if (rc) {
-		dev_err(dev, "ENA device init failed\n");
+		netdev_err(netdev, "Cannot set queues placement policy rc= %d\n", rc);
 		goto err_admin_init;
 	}
 
-- 
2.40.1

[PATCH v1 net-next 07/11] net: ena: Add more information on TX timeouts

[darinzon]

From: David Arinzon <darinzon@amazon.com>

The function responsible for polling TX completions might not receive
the CPU resources it needs due to higher priority tasks running on the
requested core.

The driver might not be able to recognize such cases, but it can use its
state to suspect that they happened. If both conditions are met:

- napi hasn't been executed more than the TX completion timeout value
- napi is scheduled (meaning that we've received an interrupt)

Then it's more likely that the napi handler isn't scheduled because of
an overloaded CPU.
It was decided that for this case, the driver would wait twice as long
as the regular timeout before scheduling a reset.
The driver uses ENA_REGS_RESET_SUSPECTED_POLL_STARVATION reset reason to
indicate this case to the device.

This patch also adds more information to the ena_tx_timeout() callback.
This function is called by the kernel when it detects that a specific TX
queue has been closed for too long.

Signed-off-by: Shay Agroskin <shayagr@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_netdev.c  | 77 +++++++++++++++----
 .../net/ethernet/amazon/ena/ena_regs_defs.h   |  1 +
 2 files changed, 64 insertions(+), 14 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index 18acb76..ae9291b 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -47,19 +47,44 @@ static int ena_restore_device(struct ena_adapter *adapter);
 
 static void ena_tx_timeout(struct net_device *dev, unsigned int txqueue)
 {
+	enum ena_regs_reset_reason_types reset_reason = ENA_REGS_RESET_OS_NETDEV_WD;
 	struct ena_adapter *adapter = netdev_priv(dev);
+	unsigned int time_since_last_napi, threshold;
+	struct ena_ring *tx_ring;
+	int napi_scheduled;
+
+	if (txqueue >= adapter->num_io_queues) {
+		netdev_err(dev, "TX timeout on invalid queue %u\n", txqueue);
+		goto schedule_reset;
+	}
+
+	threshold = jiffies_to_usecs(dev->watchdog_timeo);
+	tx_ring = &adapter->tx_ring[txqueue];
+
+	time_since_last_napi = jiffies_to_usecs(jiffies - tx_ring->tx_stats.last_napi_jiffies);
+	napi_scheduled = !!(tx_ring->napi->state & NAPIF_STATE_SCHED);
 
+	netdev_err(dev,
+		   "TX q %d is paused for too long (threshold %u). Time since last napi %u usec. napi scheduled: %d\n",
+		   txqueue,
+		   threshold,
+		   time_since_last_napi,
+		   napi_scheduled);
+
+	if (threshold < time_since_last_napi && napi_scheduled) {
+		netdev_err(dev,
+			   "napi handler hasn't been called for a long time but is scheduled\n");
+			   reset_reason = ENA_REGS_RESET_SUSPECTED_POLL_STARVATION;
+	}
+schedule_reset:
 	/* Change the state of the device to trigger reset
 	 * Check that we are not in the middle or a trigger already
 	 */
-
 	if (test_and_set_bit(ENA_FLAG_TRIGGER_RESET, &adapter->flags))
 		return;
 
-	ena_reset_device(adapter, ENA_REGS_RESET_OS_NETDEV_WD);
+	ena_reset_device(adapter, reset_reason);
 	ena_increase_stat(&adapter->dev_stats.tx_timeout, 1, &adapter->syncp);
-
-	netif_err(adapter, tx_err, dev, "Transmit time out\n");
 }
 
 static void update_rx_ring_mtu(struct ena_adapter *adapter, int mtu)
@@ -3374,14 +3399,18 @@ static int check_missing_comp_in_tx_queue(struct ena_adapter *adapter,
 					  struct ena_ring *tx_ring)
 {
 	struct ena_napi *ena_napi = container_of(tx_ring->napi, struct ena_napi, napi);
+	enum ena_regs_reset_reason_types reset_reason = ENA_REGS_RESET_MISS_TX_CMPL;
 	unsigned int time_since_last_napi;
 	unsigned int missing_tx_comp_to;
 	bool is_tx_comp_time_expired;
 	struct ena_tx_buffer *tx_buf;
 	unsigned long last_jiffies;
+	int napi_scheduled;
 	u32 missed_tx = 0;
 	int i, rc = 0;
 
+	missing_tx_comp_to = jiffies_to_msecs(adapter->missing_tx_completion_to);
+
 	for (i = 0; i < tx_ring->ring_size; i++) {
 		tx_buf = &tx_ring->tx_buffer_info[i];
 		last_jiffies = tx_buf->last_jiffies;
@@ -3408,25 +3437,45 @@ static int check_missing_comp_in_tx_queue(struct ena_adapter *adapter,
 			adapter->missing_tx_completion_to);
 
 		if (unlikely(is_tx_comp_time_expired)) {
-			if (!tx_buf->print_once) {
-				time_since_last_napi = jiffies_to_usecs(jiffies - tx_ring->tx_stats.last_napi_jiffies);
-				missing_tx_comp_to = jiffies_to_msecs(adapter->missing_tx_completion_to);
-				netif_notice(adapter, tx_err, adapter->netdev,
-					     "Found a Tx that wasn't completed on time, qid %d, index %d. %u usecs have passed since last napi execution. Missing Tx timeout value %u msecs\n",
-					     tx_ring->qid, i, time_since_last_napi, missing_tx_comp_to);
+			time_since_last_napi =
+				jiffies_to_usecs(jiffies - tx_ring->tx_stats.last_napi_jiffies);
+			napi_scheduled = !!(ena_napi->napi.state & NAPIF_STATE_SCHED);
+
+			if (missing_tx_comp_to < time_since_last_napi && napi_scheduled) {
+				/* We suspect napi isn't called because the
+				 * bottom half is not run. Require a bigger
+				 * timeout for these cases
+				 */
+				if (!time_is_before_jiffies(last_jiffies +
+					2 * adapter->missing_tx_completion_to))
+					continue;
+
+				reset_reason = ENA_REGS_RESET_SUSPECTED_POLL_STARVATION;
 			}
 
-			tx_buf->print_once = 1;
 			missed_tx++;
+
+			if (tx_buf->print_once)
+				continue;
+
+			netif_notice(adapter, tx_err, adapter->netdev,
+				     "TX hasn't completed, qid %d, index %d. %u usecs from last napi execution, napi scheduled: %d\n",
+				     tx_ring->qid, i, time_since_last_napi, napi_scheduled);
+
+			tx_buf->print_once = 1;
 		}
 	}
 
 	if (unlikely(missed_tx > adapter->missing_tx_completion_threshold)) {
 		netif_err(adapter, tx_err, adapter->netdev,
-			  "The number of lost tx completions is above the threshold (%d > %d). Reset the device\n",
+			  "Lost TX completions are above the threshold (%d > %d). Completion transmission timeout: %u.\n",
 			  missed_tx,
-			  adapter->missing_tx_completion_threshold);
-		ena_reset_device(adapter, ENA_REGS_RESET_MISS_TX_CMPL);
+			  adapter->missing_tx_completion_threshold,
+			  missing_tx_comp_to);
+		netif_err(adapter, tx_err, adapter->netdev,
+			  "Resetting the device\n");
+
+		ena_reset_device(adapter, reset_reason);
 		rc = -EIO;
 	}
 
diff --git a/drivers/net/ethernet/amazon/ena/ena_regs_defs.h b/drivers/net/ethernet/amazon/ena/ena_regs_defs.h
index 1e007a4..2c3d6a7 100644
--- a/drivers/net/ethernet/amazon/ena/ena_regs_defs.h
+++ b/drivers/net/ethernet/amazon/ena/ena_regs_defs.h
@@ -21,6 +21,7 @@ enum ena_regs_reset_reason_types {
 	ENA_REGS_RESET_USER_TRIGGER                 = 12,
 	ENA_REGS_RESET_GENERIC                      = 13,
 	ENA_REGS_RESET_MISS_INTERRUPT               = 14,
+	ENA_REGS_RESET_SUSPECTED_POLL_STARVATION    = 15,
 };
 
 /* ena_registers offsets */
-- 
2.40.1

[PATCH v1 net-next 08/11] net: ena: Relocate skb_tx_timestamp() to improve time stamping accuracy

[darinzon]

From: David Arinzon <darinzon@amazon.com>

Move skb_tx_timestamp() closer to the actual time the driver sends the
packets to the device.

Signed-off-by: Osama Abboud <osamaabb@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_netdev.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index ae9291b..d4ca406 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -2614,8 +2614,6 @@ static netdev_tx_t ena_start_xmit(struct sk_buff *skb, struct net_device *dev)
 	if (unlikely(rc))
 		goto error_drop_packet;
 
-	skb_tx_timestamp(skb);
-
 	next_to_use = tx_ring->next_to_use;
 	req_id = tx_ring->free_ids[next_to_use];
 	tx_info = &tx_ring->tx_buffer_info[req_id];
@@ -2679,6 +2677,8 @@ static netdev_tx_t ena_start_xmit(struct sk_buff *skb, struct net_device *dev)
 		}
 	}
 
+	skb_tx_timestamp(skb);
+
 	if (netif_xmit_stopped(txq) || !netdev_xmit_more())
 		/* trigger the dma engine. ena_ring_tx_doorbell()
 		 * calls a memory barrier inside it.
-- 
2.40.1

[PATCH v1 net-next 09/11] net: ena: Change default print level for netif_ prints

[darinzon]

From: David Arinzon <darinzon@amazon.com>

The netif_* functions are used by the driver to log events into the
kernel ring (dmesg) similar to the netdev_* ones. Unlike the latter,
the netif_* function family allow the user to choose what events get
logged using ethtool:
	sudo ethtool -s [interface] msglvl [msg_type] on

By default the events which get logged are slow-path related and aren't
printed often (e.g. interface up related prints). This patch removes the
NETIF_MSG_TX_DONE type (called every TX completion polling) from the
defaults and adds NETIF_MSG_IFDOWN instead as it makes more sensible
defaults.

This patch also transforms ena_down() print from netif_info into
netif_dbg (same as the analogue print in ena_up()) as it suits it
better.

Signed-off-by: Shay Agroskin <shayagr@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_netdev.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index d4ca406..8d99904 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -32,7 +32,7 @@ MODULE_LICENSE("GPL");
 #define ENA_MAX_RINGS min_t(unsigned int, ENA_MAX_NUM_IO_QUEUES, num_possible_cpus())
 
 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_IFUP | \
-		NETIF_MSG_TX_DONE | NETIF_MSG_TX_ERR | NETIF_MSG_RX_ERR)
+		NETIF_MSG_IFDOWN | NETIF_MSG_TX_ERR | NETIF_MSG_RX_ERR)
 
 static struct ena_aenq_handlers aenq_handlers;
 
@@ -2212,7 +2212,7 @@ void ena_down(struct ena_adapter *adapter)
 {
 	int io_queue_count = adapter->num_io_queues + adapter->xdp_num_queues;
 
-	netif_info(adapter, ifdown, adapter->netdev, "%s\n", __func__);
+	netif_dbg(adapter, ifdown, adapter->netdev, "%s\n", __func__);
 
 	clear_bit(ENA_FLAG_DEV_UP, &adapter->flags);
 
-- 
2.40.1

[PATCH v1 net-next 10/11] net: ena: handle ena_calc_io_queue_size() possible errors

[darinzon]

From: David Arinzon <darinzon@amazon.com>

Fail queue size calculation when the device returns maximum
TX/RX queue sizes that are smaller than the allowed minimum.

Signed-off-by: Osama Abboud <osamaabb@amazon.com>
Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_netdev.c | 24 +++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index 8d99904..ca56dff 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -2899,8 +2899,8 @@ static const struct net_device_ops ena_netdev_ops = {
 	.ndo_xdp_xmit		= ena_xdp_xmit,
 };
 
-static void ena_calc_io_queue_size(struct ena_adapter *adapter,
-				   struct ena_com_dev_get_features_ctx *get_feat_ctx)
+static int ena_calc_io_queue_size(struct ena_adapter *adapter,
+				  struct ena_com_dev_get_features_ctx *get_feat_ctx)
 {
 	struct ena_admin_feature_llq_desc *llq = &get_feat_ctx->llq;
 	struct ena_com_dev *ena_dev = adapter->ena_dev;
@@ -2959,6 +2959,18 @@ static void ena_calc_io_queue_size(struct ena_adapter *adapter,
 	max_tx_queue_size = rounddown_pow_of_two(max_tx_queue_size);
 	max_rx_queue_size = rounddown_pow_of_two(max_rx_queue_size);
 
+	if (max_tx_queue_size < ENA_MIN_RING_SIZE) {
+		netdev_err(adapter->netdev, "Device max TX queue size: %d < minimum: %d\n",
+			   max_tx_queue_size, ENA_MIN_RING_SIZE);
+		return -EFAULT;
+	}
+
+	if (max_rx_queue_size < ENA_MIN_RING_SIZE) {
+		netdev_err(adapter->netdev, "Device max RX queue size: %d < minimum: %d\n",
+			   max_rx_queue_size, ENA_MIN_RING_SIZE);
+		return -EFAULT;
+	}
+
 	/* When forcing large headers, we multiply the entry size by 2, and therefore divide
 	 * the queue size by 2, leaving the amount of memory used by the queues unchanged.
 	 */
@@ -2989,6 +3001,8 @@ static void ena_calc_io_queue_size(struct ena_adapter *adapter,
 	adapter->max_rx_ring_size = max_rx_queue_size;
 	adapter->requested_tx_ring_size = tx_queue_size;
 	adapter->requested_rx_ring_size = rx_queue_size;
+
+	return 0;
 }
 
 static int ena_device_validate_params(struct ena_adapter *adapter,
@@ -3190,11 +3204,15 @@ static int ena_device_init(struct ena_adapter *adapter, struct pci_dev *pdev,
 		goto err_admin_init;
 	}
 
-	ena_calc_io_queue_size(adapter, get_feat_ctx);
+	rc = ena_calc_io_queue_size(adapter, get_feat_ctx);
+	if (unlikely(rc))
+		goto err_admin_init;
 
 	return 0;
 
 err_admin_init:
+	ena_com_abort_admin_commands(ena_dev);
+	ena_com_wait_for_abort_completion(ena_dev);
 	ena_com_delete_host_info(ena_dev);
 	ena_com_admin_destroy(ena_dev);
 err_mmio_read_less:
-- 
2.40.1

Re: [PATCH v1 net-next 10/11] net: ena: handle ena_calc_io_queue_size() possible errors

[Nelson, Shannon]

On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> 
> From: David Arinzon <darinzon@amazon.com>
> 
> Fail queue size calculation when the device returns maximum
> TX/RX queue sizes that are smaller than the allowed minimum.
> 
> Signed-off-by: Osama Abboud <osamaabb@amazon.com>
> Signed-off-by: David Arinzon <darinzon@amazon.com>
> ---
>   drivers/net/ethernet/amazon/ena/ena_netdev.c | 24 +++++++++++++++++---
>   1 file changed, 21 insertions(+), 3 deletions(-)
> 
> diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> index 8d99904..ca56dff 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> +++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> @@ -2899,8 +2899,8 @@ static const struct net_device_ops ena_netdev_ops = {
>          .ndo_xdp_xmit           = ena_xdp_xmit,
>   };
> 
> -static void ena_calc_io_queue_size(struct ena_adapter *adapter,
> -                                  struct ena_com_dev_get_features_ctx *get_feat_ctx)
> +static int ena_calc_io_queue_size(struct ena_adapter *adapter,
> +                                 struct ena_com_dev_get_features_ctx *get_feat_ctx)
>   {
>          struct ena_admin_feature_llq_desc *llq = &get_feat_ctx->llq;
>          struct ena_com_dev *ena_dev = adapter->ena_dev;
> @@ -2959,6 +2959,18 @@ static void ena_calc_io_queue_size(struct ena_adapter *adapter,
>          max_tx_queue_size = rounddown_pow_of_two(max_tx_queue_size);
>          max_rx_queue_size = rounddown_pow_of_two(max_rx_queue_size);
> 
> +       if (max_tx_queue_size < ENA_MIN_RING_SIZE) {
> +               netdev_err(adapter->netdev, "Device max TX queue size: %d < minimum: %d\n",
> +                          max_tx_queue_size, ENA_MIN_RING_SIZE);
> +               return -EFAULT;
> +       }
> +
> +       if (max_rx_queue_size < ENA_MIN_RING_SIZE) {
> +               netdev_err(adapter->netdev, "Device max RX queue size: %d < minimum: %d\n",
> +                          max_rx_queue_size, ENA_MIN_RING_SIZE);
> +               return -EFAULT;

Maybe EINVAL for these two?

sln

> +       }
> +
>          /* When forcing large headers, we multiply the entry size by 2, and therefore divide
>           * the queue size by 2, leaving the amount of memory used by the queues unchanged.
>           */
> @@ -2989,6 +3001,8 @@ static void ena_calc_io_queue_size(struct ena_adapter *adapter,
>          adapter->max_rx_ring_size = max_rx_queue_size;
>          adapter->requested_tx_ring_size = tx_queue_size;
>          adapter->requested_rx_ring_size = rx_queue_size;
> +
> +       return 0;
>   }
> 
>   static int ena_device_validate_params(struct ena_adapter *adapter,
> @@ -3190,11 +3204,15 @@ static int ena_device_init(struct ena_adapter *adapter, struct pci_dev *pdev,
>                  goto err_admin_init;
>          }
> 
> -       ena_calc_io_queue_size(adapter, get_feat_ctx);
> +       rc = ena_calc_io_queue_size(adapter, get_feat_ctx);
> +       if (unlikely(rc))
> +               goto err_admin_init;
> 
>          return 0;
> 
>   err_admin_init:
> +       ena_com_abort_admin_commands(ena_dev);
> +       ena_com_wait_for_abort_completion(ena_dev);
>          ena_com_delete_host_info(ena_dev);
>          ena_com_admin_destroy(ena_dev);
>   err_mmio_read_less:
> --
> 2.40.1
> 
> 

RE: [PATCH v1 net-next 10/11] net: ena: handle ena_calc_io_queue_size() possible errors

[Arinzon, David]

> On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> >
> > From: David Arinzon <darinzon@amazon.com>
> >
> > Fail queue size calculation when the device returns maximum TX/RX
> > queue sizes that are smaller than the allowed minimum.
> >
> > Signed-off-by: Osama Abboud <osamaabb@amazon.com>
> > Signed-off-by: David Arinzon <darinzon@amazon.com>
> > ---
> >   drivers/net/ethernet/amazon/ena/ena_netdev.c | 24
> +++++++++++++++++---
> >   1 file changed, 21 insertions(+), 3 deletions(-)
> >
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > index 8d99904..ca56dff 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > +++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > @@ -2899,8 +2899,8 @@ static const struct net_device_ops
> ena_netdev_ops = {
> >          .ndo_xdp_xmit           = ena_xdp_xmit,
> >   };
> >
> > -static void ena_calc_io_queue_size(struct ena_adapter *adapter,
> > -                                  struct ena_com_dev_get_features_ctx *get_feat_ctx)
> > +static int ena_calc_io_queue_size(struct ena_adapter *adapter,
> > +                                 struct ena_com_dev_get_features_ctx
> > +*get_feat_ctx)
> >   {
> >          struct ena_admin_feature_llq_desc *llq = &get_feat_ctx->llq;
> >          struct ena_com_dev *ena_dev = adapter->ena_dev; @@ -2959,6
> > +2959,18 @@ static void ena_calc_io_queue_size(struct ena_adapter
> *adapter,
> >          max_tx_queue_size =
> rounddown_pow_of_two(max_tx_queue_size);
> >          max_rx_queue_size =
> rounddown_pow_of_two(max_rx_queue_size);
> >
> > +       if (max_tx_queue_size < ENA_MIN_RING_SIZE) {
> > +               netdev_err(adapter->netdev, "Device max TX queue size: %d <
> minimum: %d\n",
> > +                          max_tx_queue_size, ENA_MIN_RING_SIZE);
> > +               return -EFAULT;
> > +       }
> > +
> > +       if (max_rx_queue_size < ENA_MIN_RING_SIZE) {
> > +               netdev_err(adapter->netdev, "Device max RX queue size: %d <
> minimum: %d\n",
> > +                          max_rx_queue_size, ENA_MIN_RING_SIZE);
> > +               return -EFAULT;
> 
> Maybe EINVAL for these two?
> 
> sln
> 

I agree with you, EINVAL represents this error much better than EFAULT.
Will change in the next patchset.

Thanks!
David

> > +       }
> > +
> >          /* When forcing large headers, we multiply the entry size by 2, and
> therefore divide
> >           * the queue size by 2, leaving the amount of memory used by the
> queues unchanged.
> >           */
> > @@ -2989,6 +3001,8 @@ static void ena_calc_io_queue_size(struct
> ena_adapter *adapter,
> >          adapter->max_rx_ring_size = max_rx_queue_size;
> >          adapter->requested_tx_ring_size = tx_queue_size;
> >          adapter->requested_rx_ring_size = rx_queue_size;
> > +
> > +       return 0;
> >   }
> >
> >   static int ena_device_validate_params(struct ena_adapter *adapter,
> > @@ -3190,11 +3204,15 @@ static int ena_device_init(struct ena_adapter
> *adapter, struct pci_dev *pdev,
> >                  goto err_admin_init;
> >          }
> >
> > -       ena_calc_io_queue_size(adapter, get_feat_ctx);
> > +       rc = ena_calc_io_queue_size(adapter, get_feat_ctx);
> > +       if (unlikely(rc))
> > +               goto err_admin_init;
> >
> >          return 0;
> >
> >   err_admin_init:
> > +       ena_com_abort_admin_commands(ena_dev);
> > +       ena_com_wait_for_abort_completion(ena_dev);
> >          ena_com_delete_host_info(ena_dev);
> >          ena_com_admin_destroy(ena_dev);
> >   err_mmio_read_less:
> > --
> > 2.40.1
> >
> >

[PATCH v1 net-next 11/11] net: ena: Reduce lines with longer column width boundary

[darinzon]

From: David Arinzon <darinzon@amazon.com>

This patch reduces some of the lines by removing newlines
where more variables or print strings can be pushed back
to the previous line while still adhering to the styling
guidelines.

Signed-off-by: David Arinzon <darinzon@amazon.com>
---
 drivers/net/ethernet/amazon/ena/ena_com.c     | 315 +++++++-----------
 drivers/net/ethernet/amazon/ena/ena_eth_com.c |  49 ++-
 drivers/net/ethernet/amazon/ena/ena_eth_com.h |  15 +-
 drivers/net/ethernet/amazon/ena/ena_netdev.c  |  32 +-
 4 files changed, 151 insertions(+), 260 deletions(-)

diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
index 675ee72..9e9e4a0 100644
--- a/drivers/net/ethernet/amazon/ena/ena_com.c
+++ b/drivers/net/ethernet/amazon/ena/ena_com.c
@@ -90,8 +90,7 @@ static int ena_com_admin_init_sq(struct ena_com_admin_queue *admin_queue)
 	struct ena_com_admin_sq *sq = &admin_queue->sq;
 	u16 size = ADMIN_SQ_SIZE(admin_queue->q_depth);
 
-	sq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
-					 &sq->dma_addr, GFP_KERNEL);
+	sq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size, &sq->dma_addr, GFP_KERNEL);
 
 	if (!sq->entries) {
 		netdev_err(ena_dev->net_device, "Memory allocation failed\n");
@@ -113,8 +112,7 @@ static int ena_com_admin_init_cq(struct ena_com_admin_queue *admin_queue)
 	struct ena_com_admin_cq *cq = &admin_queue->cq;
 	u16 size = ADMIN_CQ_SIZE(admin_queue->q_depth);
 
-	cq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
-					 &cq->dma_addr, GFP_KERNEL);
+	cq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size, &cq->dma_addr, GFP_KERNEL);
 
 	if (!cq->entries) {
 		netdev_err(ena_dev->net_device, "Memory allocation failed\n");
@@ -136,8 +134,7 @@ static int ena_com_admin_init_aenq(struct ena_com_dev *ena_dev,
 
 	ena_dev->aenq.q_depth = ENA_ASYNC_QUEUE_DEPTH;
 	size = ADMIN_AENQ_SIZE(ENA_ASYNC_QUEUE_DEPTH);
-	aenq->entries = dma_alloc_coherent(ena_dev->dmadev, size,
-					   &aenq->dma_addr, GFP_KERNEL);
+	aenq->entries = dma_alloc_coherent(ena_dev->dmadev, size, &aenq->dma_addr, GFP_KERNEL);
 
 	if (!aenq->entries) {
 		netdev_err(ena_dev->net_device, "Memory allocation failed\n");
@@ -155,14 +152,13 @@ static int ena_com_admin_init_aenq(struct ena_com_dev *ena_dev,
 
 	aenq_caps = 0;
 	aenq_caps |= ena_dev->aenq.q_depth & ENA_REGS_AENQ_CAPS_AENQ_DEPTH_MASK;
-	aenq_caps |= (sizeof(struct ena_admin_aenq_entry)
-		      << ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_SHIFT) &
-		     ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_MASK;
+	aenq_caps |=
+		(sizeof(struct ena_admin_aenq_entry) << ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_SHIFT) &
+		ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_MASK;
 	writel(aenq_caps, ena_dev->reg_bar + ENA_REGS_AENQ_CAPS_OFF);
 
 	if (unlikely(!aenq_handlers)) {
-		netdev_err(ena_dev->net_device,
-			   "AENQ handlers pointer is NULL\n");
+		netdev_err(ena_dev->net_device, "AENQ handlers pointer is NULL\n");
 		return -EINVAL;
 	}
 
@@ -189,14 +185,12 @@ static struct ena_comp_ctx *get_comp_ctxt(struct ena_com_admin_queue *admin_queu
 	}
 
 	if (unlikely(!admin_queue->comp_ctx)) {
-		netdev_err(admin_queue->ena_dev->net_device,
-			   "Completion context is NULL\n");
+		netdev_err(admin_queue->ena_dev->net_device, "Completion context is NULL\n");
 		return NULL;
 	}
 
 	if (unlikely(admin_queue->comp_ctx[command_id].occupied && capture)) {
-		netdev_err(admin_queue->ena_dev->net_device,
-			   "Completion context is occupied\n");
+		netdev_err(admin_queue->ena_dev->net_device, "Completion context is occupied\n");
 		return NULL;
 	}
 
@@ -226,8 +220,7 @@ static struct ena_comp_ctx *__ena_com_submit_admin_cmd(struct ena_com_admin_queu
 	/* In case of queue FULL */
 	cnt = (u16)atomic_read(&admin_queue->outstanding_cmds);
 	if (cnt >= admin_queue->q_depth) {
-		netdev_dbg(admin_queue->ena_dev->net_device,
-			   "Admin queue is full.\n");
+		netdev_dbg(admin_queue->ena_dev->net_device, "Admin queue is full.\n");
 		admin_queue->stats.out_of_space++;
 		return ERR_PTR(-ENOSPC);
 	}
@@ -274,8 +267,7 @@ static int ena_com_init_comp_ctxt(struct ena_com_admin_queue *admin_queue)
 	struct ena_comp_ctx *comp_ctx;
 	u16 i;
 
-	admin_queue->comp_ctx =
-		devm_kzalloc(admin_queue->q_dmadev, size, GFP_KERNEL);
+	admin_queue->comp_ctx = devm_kzalloc(admin_queue->q_dmadev, size, GFP_KERNEL);
 	if (unlikely(!admin_queue->comp_ctx)) {
 		netdev_err(ena_dev->net_device, "Memory allocation failed\n");
 		return -ENOMEM;
@@ -336,20 +328,17 @@ static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
 		dev_node = dev_to_node(ena_dev->dmadev);
 		set_dev_node(ena_dev->dmadev, ctx->numa_node);
 		io_sq->desc_addr.virt_addr =
-			dma_alloc_coherent(ena_dev->dmadev, size,
-					   &io_sq->desc_addr.phys_addr,
+			dma_alloc_coherent(ena_dev->dmadev, size, &io_sq->desc_addr.phys_addr,
 					   GFP_KERNEL);
 		set_dev_node(ena_dev->dmadev, dev_node);
 		if (!io_sq->desc_addr.virt_addr) {
 			io_sq->desc_addr.virt_addr =
 				dma_alloc_coherent(ena_dev->dmadev, size,
-						   &io_sq->desc_addr.phys_addr,
-						   GFP_KERNEL);
+						   &io_sq->desc_addr.phys_addr, GFP_KERNEL);
 		}
 
 		if (!io_sq->desc_addr.virt_addr) {
-			netdev_err(ena_dev->net_device,
-				   "Memory allocation failed\n");
+			netdev_err(ena_dev->net_device, "Memory allocation failed\n");
 			return -ENOMEM;
 		}
 	}
@@ -367,16 +356,14 @@ static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
 
 		dev_node = dev_to_node(ena_dev->dmadev);
 		set_dev_node(ena_dev->dmadev, ctx->numa_node);
-		io_sq->bounce_buf_ctrl.base_buffer =
-			devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
+		io_sq->bounce_buf_ctrl.base_buffer = devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
 		set_dev_node(ena_dev->dmadev, dev_node);
 		if (!io_sq->bounce_buf_ctrl.base_buffer)
 			io_sq->bounce_buf_ctrl.base_buffer =
 				devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
 
 		if (!io_sq->bounce_buf_ctrl.base_buffer) {
-			netdev_err(ena_dev->net_device,
-				   "Bounce buffer memory allocation failed\n");
+			netdev_err(ena_dev->net_device, "Bounce buffer memory allocation failed\n");
 			return -ENOMEM;
 		}
 
@@ -425,13 +412,11 @@ static int ena_com_init_io_cq(struct ena_com_dev *ena_dev,
 	prev_node = dev_to_node(ena_dev->dmadev);
 	set_dev_node(ena_dev->dmadev, ctx->numa_node);
 	io_cq->cdesc_addr.virt_addr =
-		dma_alloc_coherent(ena_dev->dmadev, size,
-				   &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
+		dma_alloc_coherent(ena_dev->dmadev, size, &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
 	set_dev_node(ena_dev->dmadev, prev_node);
 	if (!io_cq->cdesc_addr.virt_addr) {
 		io_cq->cdesc_addr.virt_addr =
-			dma_alloc_coherent(ena_dev->dmadev, size,
-					   &io_cq->cdesc_addr.phys_addr,
+			dma_alloc_coherent(ena_dev->dmadev, size, &io_cq->cdesc_addr.phys_addr,
 					   GFP_KERNEL);
 	}
 
@@ -514,8 +499,8 @@ static int ena_com_comp_status_to_errno(struct ena_com_admin_queue *admin_queue,
 					u8 comp_status)
 {
 	if (unlikely(comp_status != 0))
-		netdev_err(admin_queue->ena_dev->net_device,
-			   "Admin command failed[%u]\n", comp_status);
+		netdev_err(admin_queue->ena_dev->net_device, "Admin command failed[%u]\n",
+			   comp_status);
 
 	switch (comp_status) {
 	case ENA_ADMIN_SUCCESS:
@@ -580,8 +565,7 @@ static int ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx *comp_c
 	}
 
 	if (unlikely(comp_ctx->status == ENA_CMD_ABORTED)) {
-		netdev_err(admin_queue->ena_dev->net_device,
-			   "Command was aborted\n");
+		netdev_err(admin_queue->ena_dev->net_device, "Command was aborted\n");
 		spin_lock_irqsave(&admin_queue->q_lock, flags);
 		admin_queue->stats.aborted_cmd++;
 		spin_unlock_irqrestore(&admin_queue->q_lock, flags);
@@ -589,8 +573,7 @@ static int ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx *comp_c
 		goto err;
 	}
 
-	WARN(comp_ctx->status != ENA_CMD_COMPLETED, "Invalid comp status %d\n",
-	     comp_ctx->status);
+	WARN(comp_ctx->status != ENA_CMD_COMPLETED, "Invalid comp status %d\n", comp_ctx->status);
 
 	ret = ena_com_comp_status_to_errno(admin_queue, comp_ctx->comp_status);
 err:
@@ -634,8 +617,7 @@ static int ena_com_set_llq(struct ena_com_dev *ena_dev)
 					    sizeof(resp));
 
 	if (unlikely(ret))
-		netdev_err(ena_dev->net_device,
-			   "Failed to set LLQ configurations: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to set LLQ configurations: %d\n", ret);
 
 	return ret;
 }
@@ -658,8 +640,7 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
 			llq_default_cfg->llq_header_location;
 	} else {
 		netdev_err(ena_dev->net_device,
-			   "Invalid header location control, supported: 0x%x\n",
-			   supported_feat);
+			   "Invalid header location control, supported: 0x%x\n", supported_feat);
 		return -EINVAL;
 	}
 
@@ -681,8 +662,8 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
 
 			netdev_err(ena_dev->net_device,
 				   "Default llq stride ctrl is not supported, performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
-				   llq_default_cfg->llq_stride_ctrl,
-				   supported_feat, llq_info->desc_stride_ctrl);
+				   llq_default_cfg->llq_stride_ctrl, supported_feat,
+				   llq_info->desc_stride_ctrl);
 		}
 	} else {
 		llq_info->desc_stride_ctrl = 0;
@@ -704,8 +685,7 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
 			llq_info->desc_list_entry_size = 256;
 		} else {
 			netdev_err(ena_dev->net_device,
-				   "Invalid entry_size_ctrl, supported: 0x%x\n",
-				   supported_feat);
+				   "Invalid entry_size_ctrl, supported: 0x%x\n", supported_feat);
 			return -EINVAL;
 		}
 
@@ -750,8 +730,8 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
 
 		netdev_err(ena_dev->net_device,
 			   "Default llq num descs before header is not supported, performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
-			   llq_default_cfg->llq_num_decs_before_header,
-			   supported_feat, llq_info->descs_num_before_header);
+			   llq_default_cfg->llq_num_decs_before_header, supported_feat,
+			   llq_info->descs_num_before_header);
 	}
 	/* Check for accelerated queue supported */
 	llq_accel_mode_get = llq_features->accel_mode.u.get;
@@ -767,8 +747,7 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
 
 	rc = ena_com_set_llq(ena_dev);
 	if (rc)
-		netdev_err(ena_dev->net_device,
-			   "Cannot set LLQ configuration: %d\n", rc);
+		netdev_err(ena_dev->net_device, "Cannot set LLQ configuration: %d\n", rc);
 
 	return rc;
 }
@@ -780,8 +759,7 @@ static int ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx *com
 	int ret;
 
 	wait_for_completion_timeout(&comp_ctx->wait_event,
-				    usecs_to_jiffies(
-					    admin_queue->completion_timeout));
+				    usecs_to_jiffies(admin_queue->completion_timeout));
 
 	/* In case the command wasn't completed find out the root cause.
 	 * There might be 2 kinds of errors
@@ -797,8 +775,7 @@ static int ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx *com
 		if (comp_ctx->status == ENA_CMD_COMPLETED) {
 			netdev_err(admin_queue->ena_dev->net_device,
 				   "The ena device sent a completion but the driver didn't receive a MSI-X interrupt (cmd %d), autopolling mode is %s\n",
-				   comp_ctx->cmd_opcode,
-				   admin_queue->auto_polling ? "ON" : "OFF");
+				   comp_ctx->cmd_opcode, admin_queue->auto_polling ? "ON" : "OFF");
 			/* Check if fallback to polling is enabled */
 			if (admin_queue->auto_polling)
 				admin_queue->polling = true;
@@ -867,15 +844,13 @@ static u32 ena_com_reg_bar_read32(struct ena_com_dev *ena_dev, u16 offset)
 	if (unlikely(i == timeout)) {
 		netdev_err(ena_dev->net_device,
 			   "Reading reg failed for timeout. expected: req id[%u] offset[%u] actual: req id[%u] offset[%u]\n",
-			   mmio_read->seq_num, offset, read_resp->req_id,
-			   read_resp->reg_off);
+			   mmio_read->seq_num, offset, read_resp->req_id, read_resp->reg_off);
 		ret = ENA_MMIO_READ_TIMEOUT;
 		goto err;
 	}
 
 	if (read_resp->reg_off != offset) {
-		netdev_err(ena_dev->net_device,
-			   "Read failure: wrong offset provided\n");
+		netdev_err(ena_dev->net_device, "Read failure: wrong offset provided\n");
 		ret = ENA_MMIO_READ_TIMEOUT;
 	} else {
 		ret = read_resp->reg_val;
@@ -934,8 +909,7 @@ static int ena_com_destroy_io_sq(struct ena_com_dev *ena_dev,
 					    sizeof(destroy_resp));
 
 	if (unlikely(ret && (ret != -ENODEV)))
-		netdev_err(ena_dev->net_device,
-			   "Failed to destroy io sq error: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to destroy io sq error: %d\n", ret);
 
 	return ret;
 }
@@ -949,8 +923,7 @@ static void ena_com_io_queue_free(struct ena_com_dev *ena_dev,
 	if (io_cq->cdesc_addr.virt_addr) {
 		size = io_cq->cdesc_entry_size_in_bytes * io_cq->q_depth;
 
-		dma_free_coherent(ena_dev->dmadev, size,
-				  io_cq->cdesc_addr.virt_addr,
+		dma_free_coherent(ena_dev->dmadev, size, io_cq->cdesc_addr.virt_addr,
 				  io_cq->cdesc_addr.phys_addr);
 
 		io_cq->cdesc_addr.virt_addr = NULL;
@@ -959,8 +932,7 @@ static void ena_com_io_queue_free(struct ena_com_dev *ena_dev,
 	if (io_sq->desc_addr.virt_addr) {
 		size = io_sq->desc_entry_size * io_sq->q_depth;
 
-		dma_free_coherent(ena_dev->dmadev, size,
-				  io_sq->desc_addr.virt_addr,
+		dma_free_coherent(ena_dev->dmadev, size, io_sq->desc_addr.virt_addr,
 				  io_sq->desc_addr.phys_addr);
 
 		io_sq->desc_addr.virt_addr = NULL;
@@ -985,8 +957,7 @@ static int wait_for_reset_state(struct ena_com_dev *ena_dev, u32 timeout,
 		val = ena_com_reg_bar_read32(ena_dev, ENA_REGS_DEV_STS_OFF);
 
 		if (unlikely(val == ENA_MMIO_READ_TIMEOUT)) {
-			netdev_err(ena_dev->net_device,
-				   "Reg read timeout occurred\n");
+			netdev_err(ena_dev->net_device, "Reg read timeout occurred\n");
 			return -ETIME;
 		}
 
@@ -1026,8 +997,7 @@ static int ena_com_get_feature_ex(struct ena_com_dev *ena_dev,
 	int ret;
 
 	if (!ena_com_check_supported_feature_id(ena_dev, feature_id)) {
-		netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
-			   feature_id);
+		netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n", feature_id);
 		return -EOPNOTSUPP;
 	}
 
@@ -1064,8 +1034,7 @@ static int ena_com_get_feature_ex(struct ena_com_dev *ena_dev,
 
 	if (unlikely(ret))
 		netdev_err(ena_dev->net_device,
-			   "Failed to submit get_feature command %d error: %d\n",
-			   feature_id, ret);
+			   "Failed to submit get_feature command %d error: %d\n", feature_id, ret);
 
 	return ret;
 }
@@ -1104,13 +1073,11 @@ static int ena_com_hash_key_allocate(struct ena_com_dev *ena_dev)
 {
 	struct ena_rss *rss = &ena_dev->rss;
 
-	if (!ena_com_check_supported_feature_id(ena_dev,
-						ENA_ADMIN_RSS_HASH_FUNCTION))
+	if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_HASH_FUNCTION))
 		return -EOPNOTSUPP;
 
-	rss->hash_key =
-		dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
-				   &rss->hash_key_dma_addr, GFP_KERNEL);
+	rss->hash_key = dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
+					   &rss->hash_key_dma_addr, GFP_KERNEL);
 
 	if (unlikely(!rss->hash_key))
 		return -ENOMEM;
@@ -1123,8 +1090,8 @@ static void ena_com_hash_key_destroy(struct ena_com_dev *ena_dev)
 	struct ena_rss *rss = &ena_dev->rss;
 
 	if (rss->hash_key)
-		dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
-				  rss->hash_key, rss->hash_key_dma_addr);
+		dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_key), rss->hash_key,
+				  rss->hash_key_dma_addr);
 	rss->hash_key = NULL;
 }
 
@@ -1132,9 +1099,8 @@ static int ena_com_hash_ctrl_init(struct ena_com_dev *ena_dev)
 {
 	struct ena_rss *rss = &ena_dev->rss;
 
-	rss->hash_ctrl =
-		dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
-				   &rss->hash_ctrl_dma_addr, GFP_KERNEL);
+	rss->hash_ctrl = dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
+					    &rss->hash_ctrl_dma_addr, GFP_KERNEL);
 
 	if (unlikely(!rss->hash_ctrl))
 		return -ENOMEM;
@@ -1147,8 +1113,8 @@ static void ena_com_hash_ctrl_destroy(struct ena_com_dev *ena_dev)
 	struct ena_rss *rss = &ena_dev->rss;
 
 	if (rss->hash_ctrl)
-		dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
-				  rss->hash_ctrl, rss->hash_ctrl_dma_addr);
+		dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl), rss->hash_ctrl,
+				  rss->hash_ctrl_dma_addr);
 	rss->hash_ctrl = NULL;
 }
 
@@ -1177,15 +1143,13 @@ static int ena_com_indirect_table_allocate(struct ena_com_dev *ena_dev,
 	tbl_size = (1ULL << log_size) *
 		sizeof(struct ena_admin_rss_ind_table_entry);
 
-	rss->rss_ind_tbl =
-		dma_alloc_coherent(ena_dev->dmadev, tbl_size,
-				   &rss->rss_ind_tbl_dma_addr, GFP_KERNEL);
+	rss->rss_ind_tbl = dma_alloc_coherent(ena_dev->dmadev, tbl_size, &rss->rss_ind_tbl_dma_addr,
+					      GFP_KERNEL);
 	if (unlikely(!rss->rss_ind_tbl))
 		goto mem_err1;
 
 	tbl_size = (1ULL << log_size) * sizeof(u16);
-	rss->host_rss_ind_tbl =
-		devm_kzalloc(ena_dev->dmadev, tbl_size, GFP_KERNEL);
+	rss->host_rss_ind_tbl = devm_kzalloc(ena_dev->dmadev, tbl_size, GFP_KERNEL);
 	if (unlikely(!rss->host_rss_ind_tbl))
 		goto mem_err2;
 
@@ -1197,8 +1161,7 @@ mem_err2:
 	tbl_size = (1ULL << log_size) *
 		sizeof(struct ena_admin_rss_ind_table_entry);
 
-	dma_free_coherent(ena_dev->dmadev, tbl_size, rss->rss_ind_tbl,
-			  rss->rss_ind_tbl_dma_addr);
+	dma_free_coherent(ena_dev->dmadev, tbl_size, rss->rss_ind_tbl, rss->rss_ind_tbl_dma_addr);
 	rss->rss_ind_tbl = NULL;
 mem_err1:
 	rss->tbl_log_size = 0;
@@ -1261,8 +1224,7 @@ static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
 					   &create_cmd.sq_ba,
 					   io_sq->desc_addr.phys_addr);
 		if (unlikely(ret)) {
-			netdev_err(ena_dev->net_device,
-				   "Memory address set failed\n");
+			netdev_err(ena_dev->net_device, "Memory address set failed\n");
 			return ret;
 		}
 	}
@@ -1273,8 +1235,7 @@ static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
 					    (struct ena_admin_acq_entry *)&cmd_completion,
 					    sizeof(cmd_completion));
 	if (unlikely(ret)) {
-		netdev_err(ena_dev->net_device,
-			   "Failed to create IO SQ. error: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to create IO SQ. error: %d\n", ret);
 		return ret;
 	}
 
@@ -1289,8 +1250,7 @@ static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
 			cmd_completion.llq_descriptors_offset);
 	}
 
-	netdev_dbg(ena_dev->net_device, "Created sq[%u], depth[%u]\n",
-		   io_sq->idx, io_sq->q_depth);
+	netdev_dbg(ena_dev->net_device, "Created sq[%u], depth[%u]\n", io_sq->idx, io_sq->q_depth);
 
 	return ret;
 }
@@ -1417,8 +1377,7 @@ int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
 					    (struct ena_admin_acq_entry *)&cmd_completion,
 					    sizeof(cmd_completion));
 	if (unlikely(ret)) {
-		netdev_err(ena_dev->net_device,
-			   "Failed to create IO CQ. error: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to create IO CQ. error: %d\n", ret);
 		return ret;
 	}
 
@@ -1432,8 +1391,7 @@ int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
 			(u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
 			cmd_completion.numa_node_register_offset);
 
-	netdev_dbg(ena_dev->net_device, "Created cq[%u], depth[%u]\n",
-		   io_cq->idx, io_cq->q_depth);
+	netdev_dbg(ena_dev->net_device, "Created cq[%u], depth[%u]\n", io_cq->idx, io_cq->q_depth);
 
 	return ret;
 }
@@ -1443,8 +1401,7 @@ int ena_com_get_io_handlers(struct ena_com_dev *ena_dev, u16 qid,
 			    struct ena_com_io_cq **io_cq)
 {
 	if (qid >= ENA_TOTAL_NUM_QUEUES) {
-		netdev_err(ena_dev->net_device,
-			   "Invalid queue number %d but the max is %d\n", qid,
+		netdev_err(ena_dev->net_device, "Invalid queue number %d but the max is %d\n", qid,
 			   ENA_TOTAL_NUM_QUEUES);
 		return -EINVAL;
 	}
@@ -1484,8 +1441,7 @@ void ena_com_wait_for_abort_completion(struct ena_com_dev *ena_dev)
 	spin_lock_irqsave(&admin_queue->q_lock, flags);
 	while (atomic_read(&admin_queue->outstanding_cmds) != 0) {
 		spin_unlock_irqrestore(&admin_queue->q_lock, flags);
-		ena_delay_exponential_backoff_us(exp++,
-						 ena_dev->ena_min_poll_delay_us);
+		ena_delay_exponential_backoff_us(exp++, ena_dev->ena_min_poll_delay_us);
 		spin_lock_irqsave(&admin_queue->q_lock, flags);
 	}
 	spin_unlock_irqrestore(&admin_queue->q_lock, flags);
@@ -1511,8 +1467,7 @@ int ena_com_destroy_io_cq(struct ena_com_dev *ena_dev,
 					    sizeof(destroy_resp));
 
 	if (unlikely(ret && (ret != -ENODEV)))
-		netdev_err(ena_dev->net_device,
-			   "Failed to destroy IO CQ. error: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to destroy IO CQ. error: %d\n", ret);
 
 	return ret;
 }
@@ -1580,8 +1535,7 @@ int ena_com_set_aenq_config(struct ena_com_dev *ena_dev, u32 groups_flag)
 					    sizeof(resp));
 
 	if (unlikely(ret))
-		netdev_err(ena_dev->net_device,
-			   "Failed to config AENQ ret: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to config AENQ ret: %d\n", ret);
 
 	return ret;
 }
@@ -1602,8 +1556,7 @@ int ena_com_get_dma_width(struct ena_com_dev *ena_dev)
 	netdev_dbg(ena_dev->net_device, "ENA dma width: %d\n", width);
 
 	if ((width < 32) || width > ENA_MAX_PHYS_ADDR_SIZE_BITS) {
-		netdev_err(ena_dev->net_device, "DMA width illegal value: %d\n",
-			   width);
+		netdev_err(ena_dev->net_device, "DMA width illegal value: %d\n", width);
 		return -EINVAL;
 	}
 
@@ -1625,19 +1578,16 @@ int ena_com_validate_version(struct ena_com_dev *ena_dev)
 	ctrl_ver = ena_com_reg_bar_read32(ena_dev,
 					  ENA_REGS_CONTROLLER_VERSION_OFF);
 
-	if (unlikely((ver == ENA_MMIO_READ_TIMEOUT) ||
-		     (ctrl_ver == ENA_MMIO_READ_TIMEOUT))) {
+	if (unlikely((ver == ENA_MMIO_READ_TIMEOUT) || (ctrl_ver == ENA_MMIO_READ_TIMEOUT))) {
 		netdev_err(ena_dev->net_device, "Reg read timeout occurred\n");
 		return -ETIME;
 	}
 
 	dev_info(ena_dev->dmadev, "ENA device version: %d.%d\n",
-		 (ver & ENA_REGS_VERSION_MAJOR_VERSION_MASK) >>
-			 ENA_REGS_VERSION_MAJOR_VERSION_SHIFT,
+		 (ver & ENA_REGS_VERSION_MAJOR_VERSION_MASK) >> ENA_REGS_VERSION_MAJOR_VERSION_SHIFT,
 		 ver & ENA_REGS_VERSION_MINOR_VERSION_MASK);
 
-	dev_info(ena_dev->dmadev,
-		 "ENA controller version: %d.%d.%d implementation version %d\n",
+	dev_info(ena_dev->dmadev, "ENA controller version: %d.%d.%d implementation version %d\n",
 		 (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_MASK) >>
 			 ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_SHIFT,
 		 (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MINOR_VERSION_MASK) >>
@@ -1686,20 +1636,17 @@ void ena_com_admin_destroy(struct ena_com_dev *ena_dev)
 
 	size = ADMIN_SQ_SIZE(admin_queue->q_depth);
 	if (sq->entries)
-		dma_free_coherent(ena_dev->dmadev, size, sq->entries,
-				  sq->dma_addr);
+		dma_free_coherent(ena_dev->dmadev, size, sq->entries, sq->dma_addr);
 	sq->entries = NULL;
 
 	size = ADMIN_CQ_SIZE(admin_queue->q_depth);
 	if (cq->entries)
-		dma_free_coherent(ena_dev->dmadev, size, cq->entries,
-				  cq->dma_addr);
+		dma_free_coherent(ena_dev->dmadev, size, cq->entries, cq->dma_addr);
 	cq->entries = NULL;
 
 	size = ADMIN_AENQ_SIZE(aenq->q_depth);
 	if (ena_dev->aenq.entries)
-		dma_free_coherent(ena_dev->dmadev, size, aenq->entries,
-				  aenq->dma_addr);
+		dma_free_coherent(ena_dev->dmadev, size, aenq->entries, aenq->dma_addr);
 	aenq->entries = NULL;
 }
 
@@ -1725,10 +1672,8 @@ int ena_com_mmio_reg_read_request_init(struct ena_com_dev *ena_dev)
 	struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
 
 	spin_lock_init(&mmio_read->lock);
-	mmio_read->read_resp =
-		dma_alloc_coherent(ena_dev->dmadev,
-				   sizeof(*mmio_read->read_resp),
-				   &mmio_read->read_resp_dma_addr, GFP_KERNEL);
+	mmio_read->read_resp = dma_alloc_coherent(ena_dev->dmadev, sizeof(*mmio_read->read_resp),
+						  &mmio_read->read_resp_dma_addr, GFP_KERNEL);
 	if (unlikely(!mmio_read->read_resp))
 		goto err;
 
@@ -1759,8 +1704,8 @@ void ena_com_mmio_reg_read_request_destroy(struct ena_com_dev *ena_dev)
 	writel(0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_LO_OFF);
 	writel(0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_HI_OFF);
 
-	dma_free_coherent(ena_dev->dmadev, sizeof(*mmio_read->read_resp),
-			  mmio_read->read_resp, mmio_read->read_resp_dma_addr);
+	dma_free_coherent(ena_dev->dmadev, sizeof(*mmio_read->read_resp), mmio_read->read_resp,
+			  mmio_read->read_resp_dma_addr);
 
 	mmio_read->read_resp = NULL;
 }
@@ -1792,8 +1737,7 @@ int ena_com_admin_init(struct ena_com_dev *ena_dev,
 	}
 
 	if (!(dev_sts & ENA_REGS_DEV_STS_READY_MASK)) {
-		netdev_err(ena_dev->net_device,
-			   "Device isn't ready, abort com init\n");
+		netdev_err(ena_dev->net_device, "Device isn't ready, abort com init\n");
 		return -ENODEV;
 	}
 
@@ -1870,8 +1814,7 @@ int ena_com_create_io_queue(struct ena_com_dev *ena_dev,
 	int ret;
 
 	if (ctx->qid >= ENA_TOTAL_NUM_QUEUES) {
-		netdev_err(ena_dev->net_device,
-			   "Qid (%d) is bigger than max num of queues (%d)\n",
+		netdev_err(ena_dev->net_device, "Qid (%d) is bigger than max num of queues (%d)\n",
 			   ctx->qid, ENA_TOTAL_NUM_QUEUES);
 		return -EINVAL;
 	}
@@ -1897,8 +1840,7 @@ int ena_com_create_io_queue(struct ena_com_dev *ena_dev,
 
 	if (ctx->direction == ENA_COM_IO_QUEUE_DIRECTION_TX)
 		/* header length is limited to 8 bits */
-		io_sq->tx_max_header_size =
-			min_t(u32, ena_dev->tx_max_header_size, SZ_256);
+		io_sq->tx_max_header_size = min_t(u32, ena_dev->tx_max_header_size, SZ_256);
 
 	ret = ena_com_init_io_sq(ena_dev, ctx, io_sq);
 	if (ret)
@@ -1930,8 +1872,7 @@ void ena_com_destroy_io_queue(struct ena_com_dev *ena_dev, u16 qid)
 	struct ena_com_io_cq *io_cq;
 
 	if (qid >= ENA_TOTAL_NUM_QUEUES) {
-		netdev_err(ena_dev->net_device,
-			   "Qid (%d) is bigger than max num of queues (%d)\n",
+		netdev_err(ena_dev->net_device, "Qid (%d) is bigger than max num of queues (%d)\n",
 			   qid, ENA_TOTAL_NUM_QUEUES);
 		return;
 	}
@@ -1975,8 +1916,7 @@ int ena_com_get_dev_attr_feat(struct ena_com_dev *ena_dev,
 		if (rc)
 			return rc;
 
-		if (get_resp.u.max_queue_ext.version !=
-		    ENA_FEATURE_MAX_QUEUE_EXT_VER)
+		if (get_resp.u.max_queue_ext.version != ENA_FEATURE_MAX_QUEUE_EXT_VER)
 			return -EINVAL;
 
 		memcpy(&get_feat_ctx->max_queue_ext, &get_resp.u.max_queue_ext,
@@ -2017,18 +1957,15 @@ int ena_com_get_dev_attr_feat(struct ena_com_dev *ena_dev,
 	rc = ena_com_get_feature(ena_dev, &get_resp, ENA_ADMIN_HW_HINTS, 0);
 
 	if (!rc)
-		memcpy(&get_feat_ctx->hw_hints, &get_resp.u.hw_hints,
-		       sizeof(get_resp.u.hw_hints));
+		memcpy(&get_feat_ctx->hw_hints, &get_resp.u.hw_hints, sizeof(get_resp.u.hw_hints));
 	else if (rc == -EOPNOTSUPP)
-		memset(&get_feat_ctx->hw_hints, 0x0,
-		       sizeof(get_feat_ctx->hw_hints));
+		memset(&get_feat_ctx->hw_hints, 0x0, sizeof(get_feat_ctx->hw_hints));
 	else
 		return rc;
 
 	rc = ena_com_get_feature(ena_dev, &get_resp, ENA_ADMIN_LLQ, 0);
 	if (!rc)
-		memcpy(&get_feat_ctx->llq, &get_resp.u.llq,
-		       sizeof(get_resp.u.llq));
+		memcpy(&get_feat_ctx->llq, &get_resp.u.llq, sizeof(get_resp.u.llq));
 	else if (rc == -EOPNOTSUPP)
 		memset(&get_feat_ctx->llq, 0x0, sizeof(get_feat_ctx->llq));
 	else
@@ -2076,8 +2013,7 @@ void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
 	aenq_common = &aenq_e->aenq_common_desc;
 
 	/* Go over all the events */
-	while ((READ_ONCE(aenq_common->flags) &
-		ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
+	while ((READ_ONCE(aenq_common->flags) & ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
 		/* Make sure the phase bit (ownership) is as expected before
 		 * reading the rest of the descriptor.
 		 */
@@ -2086,8 +2022,7 @@ void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
 		timestamp = (u64)aenq_common->timestamp_low |
 			((u64)aenq_common->timestamp_high << 32);
 
-		netdev_dbg(ena_dev->net_device,
-			   "AENQ! Group[%x] Syndrome[%x] timestamp: [%llus]\n",
+		netdev_dbg(ena_dev->net_device, "AENQ! Group[%x] Syndrome[%x] timestamp: [%llus]\n",
 			   aenq_common->group, aenq_common->syndrome, timestamp);
 
 		/* Handle specific event*/
@@ -2116,8 +2051,7 @@ void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
 
 	/* write the aenq doorbell after all AENQ descriptors were read */
 	mb();
-	writel_relaxed((u32)aenq->head,
-		       ena_dev->reg_bar + ENA_REGS_AENQ_HEAD_DB_OFF);
+	writel_relaxed((u32)aenq->head, ena_dev->reg_bar + ENA_REGS_AENQ_HEAD_DB_OFF);
 }
 
 int ena_com_dev_reset(struct ena_com_dev *ena_dev,
@@ -2129,15 +2063,13 @@ int ena_com_dev_reset(struct ena_com_dev *ena_dev,
 	stat = ena_com_reg_bar_read32(ena_dev, ENA_REGS_DEV_STS_OFF);
 	cap = ena_com_reg_bar_read32(ena_dev, ENA_REGS_CAPS_OFF);
 
-	if (unlikely((stat == ENA_MMIO_READ_TIMEOUT) ||
-		     (cap == ENA_MMIO_READ_TIMEOUT))) {
+	if (unlikely((stat == ENA_MMIO_READ_TIMEOUT) || (cap == ENA_MMIO_READ_TIMEOUT))) {
 		netdev_err(ena_dev->net_device, "Reg read32 timeout occurred\n");
 		return -ETIME;
 	}
 
 	if ((stat & ENA_REGS_DEV_STS_READY_MASK) == 0) {
-		netdev_err(ena_dev->net_device,
-			   "Device isn't ready, can't reset device\n");
+		netdev_err(ena_dev->net_device, "Device isn't ready, can't reset device\n");
 		return -EINVAL;
 	}
 
@@ -2160,8 +2092,7 @@ int ena_com_dev_reset(struct ena_com_dev *ena_dev,
 	rc = wait_for_reset_state(ena_dev, timeout,
 				  ENA_REGS_DEV_STS_RESET_IN_PROGRESS_MASK);
 	if (rc != 0) {
-		netdev_err(ena_dev->net_device,
-			   "Reset indication didn't turn on\n");
+		netdev_err(ena_dev->net_device, "Reset indication didn't turn on\n");
 		return rc;
 	}
 
@@ -2169,8 +2100,7 @@ int ena_com_dev_reset(struct ena_com_dev *ena_dev,
 	writel(0, ena_dev->reg_bar + ENA_REGS_DEV_CTL_OFF);
 	rc = wait_for_reset_state(ena_dev, timeout, 0);
 	if (rc != 0) {
-		netdev_err(ena_dev->net_device,
-			   "Reset indication didn't turn off\n");
+		netdev_err(ena_dev->net_device, "Reset indication didn't turn off\n");
 		return rc;
 	}
 
@@ -2207,8 +2137,7 @@ static int ena_get_dev_stats(struct ena_com_dev *ena_dev,
 					     sizeof(*get_resp));
 
 	if (unlikely(ret))
-		netdev_err(ena_dev->net_device,
-			   "Failed to get stats. error: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to get stats. error: %d\n", ret);
 
 	return ret;
 }
@@ -2220,8 +2149,7 @@ int ena_com_get_eni_stats(struct ena_com_dev *ena_dev,
 	int ret;
 
 	if (!ena_com_get_cap(ena_dev, ENA_ADMIN_ENI_STATS)) {
-		netdev_err(ena_dev->net_device,
-			   "Capability %d isn't supported\n",
+		netdev_err(ena_dev->net_device, "Capability %d isn't supported\n",
 			   ENA_ADMIN_ENI_STATS);
 		return -EOPNOTSUPP;
 	}
@@ -2258,8 +2186,7 @@ int ena_com_set_dev_mtu(struct ena_com_dev *ena_dev, u32 mtu)
 	int ret;
 
 	if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_MTU)) {
-		netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
-			   ENA_ADMIN_MTU);
+		netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n", ENA_ADMIN_MTU);
 		return -EOPNOTSUPP;
 	}
 
@@ -2278,8 +2205,7 @@ int ena_com_set_dev_mtu(struct ena_com_dev *ena_dev, u32 mtu)
 					    sizeof(resp));
 
 	if (unlikely(ret))
-		netdev_err(ena_dev->net_device,
-			   "Failed to set mtu %d. error: %d\n", mtu, ret);
+		netdev_err(ena_dev->net_device, "Failed to set mtu %d. error: %d\n", mtu, ret);
 
 	return ret;
 }
@@ -2293,8 +2219,7 @@ int ena_com_get_offload_settings(struct ena_com_dev *ena_dev,
 	ret = ena_com_get_feature(ena_dev, &resp,
 				  ENA_ADMIN_STATELESS_OFFLOAD_CONFIG, 0);
 	if (unlikely(ret)) {
-		netdev_err(ena_dev->net_device,
-			   "Failed to get offload capabilities %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to get offload capabilities %d\n", ret);
 		return ret;
 	}
 
@@ -2312,8 +2237,7 @@ int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
 	struct ena_admin_get_feat_resp get_resp;
 	int ret;
 
-	if (!ena_com_check_supported_feature_id(ena_dev,
-						ENA_ADMIN_RSS_HASH_FUNCTION)) {
+	if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_HASH_FUNCTION)) {
 		netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
 			   ENA_ADMIN_RSS_HASH_FUNCTION);
 		return -EOPNOTSUPP;
@@ -2326,8 +2250,7 @@ int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
 		return ret;
 
 	if (!(get_resp.u.flow_hash_func.supported_func & BIT(rss->hash_func))) {
-		netdev_err(ena_dev->net_device,
-			   "Func hash %d isn't supported by device, abort\n",
+		netdev_err(ena_dev->net_device, "Func hash %d isn't supported by device, abort\n",
 			   rss->hash_func);
 		return -EOPNOTSUPP;
 	}
@@ -2357,8 +2280,7 @@ int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
 					    (struct ena_admin_acq_entry *)&resp,
 					    sizeof(resp));
 	if (unlikely(ret)) {
-		netdev_err(ena_dev->net_device,
-			   "Failed to set hash function %d. error: %d\n",
+		netdev_err(ena_dev->net_device, "Failed to set hash function %d. error: %d\n",
 			   rss->hash_func, ret);
 		return -EINVAL;
 	}
@@ -2390,16 +2312,15 @@ int ena_com_fill_hash_function(struct ena_com_dev *ena_dev,
 		return rc;
 
 	if (!(BIT(func) & get_resp.u.flow_hash_func.supported_func)) {
-		netdev_err(ena_dev->net_device,
-			   "Flow hash function %d isn't supported\n", func);
+		netdev_err(ena_dev->net_device, "Flow hash function %d isn't supported\n", func);
 		return -EOPNOTSUPP;
 	}
 
 	if ((func == ENA_ADMIN_TOEPLITZ) && key) {
 		if (key_len != sizeof(hash_key->key)) {
 			netdev_err(ena_dev->net_device,
-				   "key len (%u) doesn't equal the supported size (%zu)\n",
-				   key_len, sizeof(hash_key->key));
+				   "key len (%u) doesn't equal the supported size (%zu)\n", key_len,
+				   sizeof(hash_key->key));
 			return -EINVAL;
 		}
 		memcpy(hash_key->key, key, key_len);
@@ -2487,8 +2408,7 @@ int ena_com_set_hash_ctrl(struct ena_com_dev *ena_dev)
 	struct ena_admin_set_feat_resp resp;
 	int ret;
 
-	if (!ena_com_check_supported_feature_id(ena_dev,
-						ENA_ADMIN_RSS_HASH_INPUT)) {
+	if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_HASH_INPUT)) {
 		netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
 			   ENA_ADMIN_RSS_HASH_INPUT);
 		return -EOPNOTSUPP;
@@ -2519,8 +2439,7 @@ int ena_com_set_hash_ctrl(struct ena_com_dev *ena_dev)
 					    (struct ena_admin_acq_entry *)&resp,
 					    sizeof(resp));
 	if (unlikely(ret))
-		netdev_err(ena_dev->net_device,
-			   "Failed to set hash input. error: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to set hash input. error: %d\n", ret);
 
 	return ret;
 }
@@ -2597,8 +2516,7 @@ int ena_com_fill_hash_ctrl(struct ena_com_dev *ena_dev,
 	int rc;
 
 	if (proto >= ENA_ADMIN_RSS_PROTO_NUM) {
-		netdev_err(ena_dev->net_device, "Invalid proto num (%u)\n",
-			   proto);
+		netdev_err(ena_dev->net_device, "Invalid proto num (%u)\n", proto);
 		return -EINVAL;
 	}
 
@@ -2650,8 +2568,7 @@ int ena_com_indirect_table_set(struct ena_com_dev *ena_dev)
 	struct ena_admin_set_feat_resp resp;
 	int ret;
 
-	if (!ena_com_check_supported_feature_id(
-		    ena_dev, ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG)) {
+	if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG)) {
 		netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
 			   ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG);
 		return -EOPNOTSUPP;
@@ -2691,8 +2608,7 @@ int ena_com_indirect_table_set(struct ena_com_dev *ena_dev)
 					    sizeof(resp));
 
 	if (unlikely(ret))
-		netdev_err(ena_dev->net_device,
-			   "Failed to set indirect table. error: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to set indirect table. error: %d\n", ret);
 
 	return ret;
 }
@@ -2771,9 +2687,8 @@ int ena_com_allocate_host_info(struct ena_com_dev *ena_dev)
 {
 	struct ena_host_attribute *host_attr = &ena_dev->host_attr;
 
-	host_attr->host_info =
-		dma_alloc_coherent(ena_dev->dmadev, SZ_4K,
-				   &host_attr->host_info_dma_addr, GFP_KERNEL);
+	host_attr->host_info = dma_alloc_coherent(ena_dev->dmadev, SZ_4K,
+						  &host_attr->host_info_dma_addr, GFP_KERNEL);
 	if (unlikely(!host_attr->host_info))
 		return -ENOMEM;
 
@@ -2819,8 +2734,7 @@ void ena_com_delete_debug_area(struct ena_com_dev *ena_dev)
 
 	if (host_attr->debug_area_virt_addr) {
 		dma_free_coherent(ena_dev->dmadev, host_attr->debug_area_size,
-				  host_attr->debug_area_virt_addr,
-				  host_attr->debug_area_dma_addr);
+				  host_attr->debug_area_virt_addr, host_attr->debug_area_dma_addr);
 		host_attr->debug_area_virt_addr = NULL;
 	}
 }
@@ -2869,8 +2783,7 @@ int ena_com_set_host_attributes(struct ena_com_dev *ena_dev)
 					    sizeof(resp));
 
 	if (unlikely(ret))
-		netdev_err(ena_dev->net_device,
-			   "Failed to set host attributes: %d\n", ret);
+		netdev_err(ena_dev->net_device, "Failed to set host attributes: %d\n", ret);
 
 	return ret;
 }
@@ -2888,8 +2801,7 @@ static int ena_com_update_nonadaptive_moderation_interval(struct ena_com_dev *en
 							  u32 *intr_moder_interval)
 {
 	if (!intr_delay_resolution) {
-		netdev_err(ena_dev->net_device,
-			   "Illegal interrupt delay granularity value\n");
+		netdev_err(ena_dev->net_device, "Illegal interrupt delay granularity value\n");
 		return -EFAULT;
 	}
 
@@ -2927,14 +2839,12 @@ int ena_com_init_interrupt_moderation(struct ena_com_dev *ena_dev)
 
 	if (rc) {
 		if (rc == -EOPNOTSUPP) {
-			netdev_dbg(ena_dev->net_device,
-				   "Feature %d isn't supported\n",
+			netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
 				   ENA_ADMIN_INTERRUPT_MODERATION);
 			rc = 0;
 		} else {
 			netdev_err(ena_dev->net_device,
-				   "Failed to get interrupt moderation admin cmd. rc: %d\n",
-				   rc);
+				   "Failed to get interrupt moderation admin cmd. rc: %d\n", rc);
 		}
 
 		/* no moderation supported, disable adaptive support */
@@ -2982,8 +2892,7 @@ int ena_com_config_dev_mode(struct ena_com_dev *ena_dev,
 		(llq_info->descs_num_before_header * sizeof(struct ena_eth_io_tx_desc));
 
 	if (unlikely(ena_dev->tx_max_header_size == 0)) {
-		netdev_err(ena_dev->net_device,
-			   "The size of the LLQ entry is smaller than needed\n");
+		netdev_err(ena_dev->net_device, "The size of the LLQ entry is smaller than needed\n");
 		return -EINVAL;
 	}
 
diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.c b/drivers/net/ethernet/amazon/ena/ena_eth_com.c
index f9f8862..933e619 100644
--- a/drivers/net/ethernet/amazon/ena/ena_eth_com.c
+++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.c
@@ -18,8 +18,7 @@ static struct ena_eth_io_rx_cdesc_base *ena_com_get_next_rx_cdesc(
 	cdesc = (struct ena_eth_io_rx_cdesc_base *)(io_cq->cdesc_addr.virt_addr
 			+ (head_masked * io_cq->cdesc_entry_size_in_bytes));
 
-	desc_phase = (READ_ONCE(cdesc->status) &
-		      ENA_ETH_IO_RX_CDESC_BASE_PHASE_MASK) >>
+	desc_phase = (READ_ONCE(cdesc->status) & ENA_ETH_IO_RX_CDESC_BASE_PHASE_MASK) >>
 		     ENA_ETH_IO_RX_CDESC_BASE_PHASE_SHIFT;
 
 	if (desc_phase != expected_phase)
@@ -65,8 +64,8 @@ static int ena_com_write_bounce_buffer_to_dev(struct ena_com_io_sq *io_sq,
 
 		io_sq->entries_in_tx_burst_left--;
 		netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-			   "Decreasing entries_in_tx_burst_left of queue %d to %d\n",
-			   io_sq->qid, io_sq->entries_in_tx_burst_left);
+			   "Decreasing entries_in_tx_burst_left of queue %d to %d\n", io_sq->qid,
+			   io_sq->entries_in_tx_burst_left);
 	}
 
 	/* Make sure everything was written into the bounce buffer before
@@ -75,8 +74,8 @@ static int ena_com_write_bounce_buffer_to_dev(struct ena_com_io_sq *io_sq,
 	wmb();
 
 	/* The line is completed. Copy it to dev */
-	__iowrite64_copy(io_sq->desc_addr.pbuf_dev_addr + dst_offset,
-			 bounce_buffer, (llq_info->desc_list_entry_size) / 8);
+	__iowrite64_copy(io_sq->desc_addr.pbuf_dev_addr + dst_offset, bounce_buffer,
+			 (llq_info->desc_list_entry_size) / 8);
 
 	io_sq->tail++;
 
@@ -102,16 +101,14 @@ static int ena_com_write_header_to_bounce(struct ena_com_io_sq *io_sq,
 	header_offset =
 		llq_info->descs_num_before_header * io_sq->desc_entry_size;
 
-	if (unlikely((header_offset + header_len) >
-		     llq_info->desc_list_entry_size)) {
+	if (unlikely((header_offset + header_len) > llq_info->desc_list_entry_size)) {
 		netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
 			   "Trying to write header larger than llq entry can accommodate\n");
 		return -EFAULT;
 	}
 
 	if (unlikely(!bounce_buffer)) {
-		netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-			   "Bounce buffer is NULL\n");
+		netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device, "Bounce buffer is NULL\n");
 		return -EFAULT;
 	}
 
@@ -129,8 +126,7 @@ static void *get_sq_desc_llq(struct ena_com_io_sq *io_sq)
 	bounce_buffer = pkt_ctrl->curr_bounce_buf;
 
 	if (unlikely(!bounce_buffer)) {
-		netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-			   "Bounce buffer is NULL\n");
+		netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device, "Bounce buffer is NULL\n");
 		return NULL;
 	}
 
@@ -247,8 +243,7 @@ static u16 ena_com_cdesc_rx_pkt_get(struct ena_com_io_cq *io_cq,
 
 		ena_com_cq_inc_head(io_cq);
 		count++;
-		last = (READ_ONCE(cdesc->status) &
-			ENA_ETH_IO_RX_CDESC_BASE_LAST_MASK) >>
+		last = (READ_ONCE(cdesc->status) & ENA_ETH_IO_RX_CDESC_BASE_LAST_MASK) >>
 		       ENA_ETH_IO_RX_CDESC_BASE_LAST_SHIFT;
 	} while (!last);
 
@@ -369,9 +364,8 @@ static void ena_com_rx_set_flags(struct ena_com_io_cq *io_cq,
 
 	netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
 		   "l3_proto %d l4_proto %d l3_csum_err %d l4_csum_err %d hash %d frag %d cdesc_status %x\n",
-		   ena_rx_ctx->l3_proto, ena_rx_ctx->l4_proto,
-		   ena_rx_ctx->l3_csum_err, ena_rx_ctx->l4_csum_err,
-		   ena_rx_ctx->hash, ena_rx_ctx->frag, cdesc->status);
+		   ena_rx_ctx->l3_proto, ena_rx_ctx->l4_proto, ena_rx_ctx->l3_csum_err,
+		   ena_rx_ctx->l4_csum_err, ena_rx_ctx->hash, ena_rx_ctx->frag, cdesc->status);
 }
 
 /*****************************************************************************/
@@ -403,13 +397,12 @@ int ena_com_prepare_tx(struct ena_com_io_sq *io_sq,
 
 	if (unlikely(header_len > io_sq->tx_max_header_size)) {
 		netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-			   "Header size is too large %d max header: %d\n",
-			   header_len, io_sq->tx_max_header_size);
+			   "Header size is too large %d max header: %d\n", header_len,
+			   io_sq->tx_max_header_size);
 		return -EINVAL;
 	}
 
-	if (unlikely(io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV &&
-		     !buffer_to_push)) {
+	if (unlikely(io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV && !buffer_to_push)) {
 		netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
 			   "Push header wasn't provided in LLQ mode\n");
 		return -EINVAL;
@@ -556,13 +549,11 @@ int ena_com_rx_pkt(struct ena_com_io_cq *io_cq,
 	}
 
 	netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
-		   "Fetch rx packet: queue %d completed desc: %d\n", io_cq->qid,
-		   nb_hw_desc);
+		   "Fetch rx packet: queue %d completed desc: %d\n", io_cq->qid, nb_hw_desc);
 
 	if (unlikely(nb_hw_desc > ena_rx_ctx->max_bufs)) {
 		netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
-			   "Too many RX cdescs (%d) > MAX(%d)\n", nb_hw_desc,
-			   ena_rx_ctx->max_bufs);
+			   "Too many RX cdescs (%d) > MAX(%d)\n", nb_hw_desc, ena_rx_ctx->max_bufs);
 		return -ENOSPC;
 	}
 
@@ -586,8 +577,8 @@ int ena_com_rx_pkt(struct ena_com_io_cq *io_cq,
 	io_sq->next_to_comp += nb_hw_desc;
 
 	netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
-		   "[%s][QID#%d] Updating SQ head to: %d\n", __func__,
-		   io_sq->qid, io_sq->next_to_comp);
+		   "[%s][QID#%d] Updating SQ head to: %d\n", __func__, io_sq->qid,
+		   io_sq->next_to_comp);
 
 	/* Get rx flags from the last pkt */
 	ena_com_rx_set_flags(io_cq, ena_rx_ctx, cdesc);
@@ -624,8 +615,8 @@ int ena_com_add_single_rx_desc(struct ena_com_io_sq *io_sq,
 	desc->req_id = req_id;
 
 	netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-		   "[%s] Adding single RX desc, Queue: %u, req_id: %u\n",
-		   __func__, io_sq->qid, req_id);
+		   "[%s] Adding single RX desc, Queue: %u, req_id: %u\n", __func__, io_sq->qid,
+		   req_id);
 
 	desc->buff_addr_lo = (u32)ena_buf->paddr;
 	desc->buff_addr_hi =
diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.h b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
index 4d65d82..72b0197 100644
--- a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
+++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
@@ -143,8 +143,8 @@ static inline bool ena_com_is_doorbell_needed(struct ena_com_io_sq *io_sq,
 	}
 
 	netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-		   "Queue: %d num_descs: %d num_entries_needed: %d\n",
-		   io_sq->qid, num_descs, num_entries_needed);
+		   "Queue: %d num_descs: %d num_entries_needed: %d\n", io_sq->qid, num_descs,
+		   num_entries_needed);
 
 	return num_entries_needed > io_sq->entries_in_tx_burst_left;
 }
@@ -155,15 +155,14 @@ static inline int ena_com_write_sq_doorbell(struct ena_com_io_sq *io_sq)
 	u16 tail = io_sq->tail;
 
 	netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-		   "Write submission queue doorbell for queue: %d tail: %d\n",
-		   io_sq->qid, tail);
+		   "Write submission queue doorbell for queue: %d tail: %d\n", io_sq->qid, tail);
 
 	writel(tail, io_sq->db_addr);
 
 	if (is_llq_max_tx_burst_exists(io_sq)) {
 		netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
-			   "Reset available entries in tx burst for queue %d to %d\n",
-			   io_sq->qid, max_entries_in_tx_burst);
+			   "Reset available entries in tx burst for queue %d to %d\n", io_sq->qid,
+			   max_entries_in_tx_burst);
 		io_sq->entries_in_tx_burst_left = max_entries_in_tx_burst;
 	}
 
@@ -224,8 +223,8 @@ static inline int ena_com_tx_comp_req_id_get(struct ena_com_io_cq *io_cq,
 
 	*req_id = READ_ONCE(cdesc->req_id);
 	if (unlikely(*req_id >= io_cq->q_depth)) {
-		netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
-			   "Invalid req id %d\n", cdesc->req_id);
+		netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device, "Invalid req id %d\n",
+			   cdesc->req_id);
 		return -EINVAL;
 	}
 
diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index ca56dff..526ab3e 100644
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -141,11 +141,9 @@ int ena_xmit_common(struct ena_adapter *adapter,
 	if (unlikely(rc)) {
 		netif_err(adapter, tx_queued, adapter->netdev,
 			  "Failed to prepare tx bufs\n");
-		ena_increase_stat(&ring->tx_stats.prepare_ctx_err, 1,
-				  &ring->syncp);
+		ena_increase_stat(&ring->tx_stats.prepare_ctx_err, 1, &ring->syncp);
 		if (rc != -ENOMEM)
-			ena_reset_device(adapter,
-					 ENA_REGS_RESET_DRIVER_INVALID_STATE);
+			ena_reset_device(adapter, ENA_REGS_RESET_DRIVER_INVALID_STATE);
 		return rc;
 	}
 
@@ -510,8 +508,7 @@ static struct page *ena_alloc_map_page(struct ena_ring *rx_ring,
 	 */
 	page = dev_alloc_page();
 	if (!page) {
-		ena_increase_stat(&rx_ring->rx_stats.page_alloc_fail, 1,
-				  &rx_ring->syncp);
+		ena_increase_stat(&rx_ring->rx_stats.page_alloc_fail, 1, &rx_ring->syncp);
 		return ERR_PTR(-ENOSPC);
 	}
 
@@ -570,8 +567,8 @@ static void ena_unmap_rx_buff_attrs(struct ena_ring *rx_ring,
 				    struct ena_rx_buffer *rx_info,
 				    unsigned long attrs)
 {
-	dma_unmap_page_attrs(rx_ring->dev, rx_info->dma_addr, ENA_PAGE_SIZE,
-			     DMA_BIDIRECTIONAL, attrs);
+	dma_unmap_page_attrs(rx_ring->dev, rx_info->dma_addr, ENA_PAGE_SIZE, DMA_BIDIRECTIONAL,
+			     attrs);
 }
 
 static void ena_free_rx_page(struct ena_ring *rx_ring,
@@ -844,8 +841,7 @@ static int ena_clean_tx_irq(struct ena_ring *tx_ring, u32 budget)
 						&req_id);
 		if (rc) {
 			if (unlikely(rc == -EINVAL))
-				handle_invalid_req_id(tx_ring, req_id, NULL,
-						      false);
+				handle_invalid_req_id(tx_ring, req_id, NULL, false);
 			break;
 		}
 
@@ -1070,8 +1066,7 @@ static struct sk_buff *ena_rx_skb(struct ena_ring *rx_ring,
 					DMA_FROM_DEVICE);
 
 		if (!reuse_rx_buf_page)
-			ena_unmap_rx_buff_attrs(rx_ring, rx_info,
-						DMA_ATTR_SKIP_CPU_SYNC);
+			ena_unmap_rx_buff_attrs(rx_ring, rx_info, DMA_ATTR_SKIP_CPU_SYNC);
 
 		skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, rx_info->page,
 				page_offset + buf_offset, len, buf_len);
@@ -1342,8 +1337,7 @@ error:
 	adapter = netdev_priv(rx_ring->netdev);
 
 	if (rc == -ENOSPC) {
-		ena_increase_stat(&rx_ring->rx_stats.bad_desc_num, 1,
-				  &rx_ring->syncp);
+		ena_increase_stat(&rx_ring->rx_stats.bad_desc_num, 1, &rx_ring->syncp);
 		ena_reset_device(adapter, ENA_REGS_RESET_TOO_MANY_RX_DESCS);
 	} else {
 		ena_increase_stat(&rx_ring->rx_stats.bad_req_id, 1,
@@ -1833,8 +1827,7 @@ static int ena_rss_configure(struct ena_adapter *adapter)
 	if (!ena_dev->rss.tbl_log_size) {
 		rc = ena_rss_init_default(adapter);
 		if (rc && (rc != -EOPNOTSUPP)) {
-			netif_err(adapter, ifup, adapter->netdev,
-				  "Failed to init RSS rc: %d\n", rc);
+			netif_err(adapter, ifup, adapter->netdev, "Failed to init RSS rc: %d\n", rc);
 			return rc;
 		}
 	}
@@ -2790,8 +2783,7 @@ static void ena_config_debug_area(struct ena_adapter *adapter)
 	rc = ena_com_set_host_attributes(adapter->ena_dev);
 	if (rc) {
 		if (rc == -EOPNOTSUPP)
-			netif_warn(adapter, drv, adapter->netdev,
-				   "Cannot set host attributes\n");
+			netif_warn(adapter, drv, adapter->netdev, "Cannot set host attributes\n");
 		else
 			netif_err(adapter, drv, adapter->netdev,
 				  "Cannot set host attributes\n");
@@ -3831,8 +3823,8 @@ static int ena_rss_init_default(struct ena_adapter *adapter)
 		}
 	}
 
-	rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ, NULL,
-					ENA_HASH_KEY_SIZE, 0xFFFFFFFF);
+	rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ, NULL, ENA_HASH_KEY_SIZE,
+					0xFFFFFFFF);
 	if (unlikely(rc && (rc != -EOPNOTSUPP))) {
 		dev_err(dev, "Cannot fill hash function\n");
 		goto err_fill_indir;
-- 
2.40.1

Re: [PATCH v1 net-next 11/11] net: ena: Reduce lines with longer column width boundary

[Nelson, Shannon]

On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> 
> From: David Arinzon <darinzon@amazon.com>
> 
> This patch reduces some of the lines by removing newlines
> where more variables or print strings can be pushed back
> to the previous line while still adhering to the styling
> guidelines.
> 
> Signed-off-by: David Arinzon <darinzon@amazon.com>
> ---
>   drivers/net/ethernet/amazon/ena/ena_com.c     | 315 +++++++-----------
>   drivers/net/ethernet/amazon/ena/ena_eth_com.c |  49 ++-
>   drivers/net/ethernet/amazon/ena/ena_eth_com.h |  15 +-
>   drivers/net/ethernet/amazon/ena/ena_netdev.c  |  32 +-
>   4 files changed, 151 insertions(+), 260 deletions(-)
> 
> diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
> index 675ee72..9e9e4a0 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_com.c
> +++ b/drivers/net/ethernet/amazon/ena/ena_com.c
> @@ -90,8 +90,7 @@ static int ena_com_admin_init_sq(struct ena_com_admin_queue *admin_queue)
>          struct ena_com_admin_sq *sq = &admin_queue->sq;
>          u16 size = ADMIN_SQ_SIZE(admin_queue->q_depth);
> 
> -       sq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
> -                                        &sq->dma_addr, GFP_KERNEL);
> +       sq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size, &sq->dma_addr, GFP_KERNEL);
> 
>          if (!sq->entries) {
>                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
> @@ -113,8 +112,7 @@ static int ena_com_admin_init_cq(struct ena_com_admin_queue *admin_queue)
>          struct ena_com_admin_cq *cq = &admin_queue->cq;
>          u16 size = ADMIN_CQ_SIZE(admin_queue->q_depth);
> 
> -       cq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
> -                                        &cq->dma_addr, GFP_KERNEL);
> +       cq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size, &cq->dma_addr, GFP_KERNEL);
> 
>          if (!cq->entries) {
>                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
> @@ -136,8 +134,7 @@ static int ena_com_admin_init_aenq(struct ena_com_dev *ena_dev,
> 
>          ena_dev->aenq.q_depth = ENA_ASYNC_QUEUE_DEPTH;
>          size = ADMIN_AENQ_SIZE(ENA_ASYNC_QUEUE_DEPTH);
> -       aenq->entries = dma_alloc_coherent(ena_dev->dmadev, size,
> -                                          &aenq->dma_addr, GFP_KERNEL);
> +       aenq->entries = dma_alloc_coherent(ena_dev->dmadev, size, &aenq->dma_addr, GFP_KERNEL);
> 
>          if (!aenq->entries) {
>                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
> @@ -155,14 +152,13 @@ static int ena_com_admin_init_aenq(struct ena_com_dev *ena_dev,
> 
>          aenq_caps = 0;
>          aenq_caps |= ena_dev->aenq.q_depth & ENA_REGS_AENQ_CAPS_AENQ_DEPTH_MASK;
> -       aenq_caps |= (sizeof(struct ena_admin_aenq_entry)
> -                     << ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_SHIFT) &
> -                    ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_MASK;
> +       aenq_caps |=
> +               (sizeof(struct ena_admin_aenq_entry) << ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_SHIFT) &
> +               ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_MASK;

This might be better served by using the FIELD_PREP macro

>          writel(aenq_caps, ena_dev->reg_bar + ENA_REGS_AENQ_CAPS_OFF);
> 
>          if (unlikely(!aenq_handlers)) {
> -               netdev_err(ena_dev->net_device,
> -                          "AENQ handlers pointer is NULL\n");
> +               netdev_err(ena_dev->net_device, "AENQ handlers pointer is NULL\n");
>                  return -EINVAL;
>          }
> 
> @@ -189,14 +185,12 @@ static struct ena_comp_ctx *get_comp_ctxt(struct ena_com_admin_queue *admin_queu
>          }
> 
>          if (unlikely(!admin_queue->comp_ctx)) {
> -               netdev_err(admin_queue->ena_dev->net_device,
> -                          "Completion context is NULL\n");
> +               netdev_err(admin_queue->ena_dev->net_device, "Completion context is NULL\n");
>                  return NULL;
>          }
> 
>          if (unlikely(admin_queue->comp_ctx[command_id].occupied && capture)) {
> -               netdev_err(admin_queue->ena_dev->net_device,
> -                          "Completion context is occupied\n");
> +               netdev_err(admin_queue->ena_dev->net_device, "Completion context is occupied\n");
>                  return NULL;
>          }
> 
> @@ -226,8 +220,7 @@ static struct ena_comp_ctx *__ena_com_submit_admin_cmd(struct ena_com_admin_queu
>          /* In case of queue FULL */
>          cnt = (u16)atomic_read(&admin_queue->outstanding_cmds);
>          if (cnt >= admin_queue->q_depth) {
> -               netdev_dbg(admin_queue->ena_dev->net_device,
> -                          "Admin queue is full.\n");
> +               netdev_dbg(admin_queue->ena_dev->net_device, "Admin queue is full.\n");
>                  admin_queue->stats.out_of_space++;
>                  return ERR_PTR(-ENOSPC);
>          }
> @@ -274,8 +267,7 @@ static int ena_com_init_comp_ctxt(struct ena_com_admin_queue *admin_queue)
>          struct ena_comp_ctx *comp_ctx;
>          u16 i;
> 
> -       admin_queue->comp_ctx =
> -               devm_kzalloc(admin_queue->q_dmadev, size, GFP_KERNEL);
> +       admin_queue->comp_ctx = devm_kzalloc(admin_queue->q_dmadev, size, GFP_KERNEL);
>          if (unlikely(!admin_queue->comp_ctx)) {
>                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
>                  return -ENOMEM;
> @@ -336,20 +328,17 @@ static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
>                  dev_node = dev_to_node(ena_dev->dmadev);
>                  set_dev_node(ena_dev->dmadev, ctx->numa_node);
>                  io_sq->desc_addr.virt_addr =
> -                       dma_alloc_coherent(ena_dev->dmadev, size,
> -                                          &io_sq->desc_addr.phys_addr,
> +                       dma_alloc_coherent(ena_dev->dmadev, size, &io_sq->desc_addr.phys_addr,
>                                             GFP_KERNEL);
>                  set_dev_node(ena_dev->dmadev, dev_node);
>                  if (!io_sq->desc_addr.virt_addr) {
>                          io_sq->desc_addr.virt_addr =
>                                  dma_alloc_coherent(ena_dev->dmadev, size,
> -                                                  &io_sq->desc_addr.phys_addr,
> -                                                  GFP_KERNEL);
> +                                                  &io_sq->desc_addr.phys_addr, GFP_KERNEL);
>                  }
> 
>                  if (!io_sq->desc_addr.virt_addr) {
> -                       netdev_err(ena_dev->net_device,
> -                                  "Memory allocation failed\n");
> +                       netdev_err(ena_dev->net_device, "Memory allocation failed\n");
>                          return -ENOMEM;
>                  }
>          }
> @@ -367,16 +356,14 @@ static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
> 
>                  dev_node = dev_to_node(ena_dev->dmadev);
>                  set_dev_node(ena_dev->dmadev, ctx->numa_node);
> -               io_sq->bounce_buf_ctrl.base_buffer =
> -                       devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
> +               io_sq->bounce_buf_ctrl.base_buffer = devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
>                  set_dev_node(ena_dev->dmadev, dev_node);
>                  if (!io_sq->bounce_buf_ctrl.base_buffer)
>                          io_sq->bounce_buf_ctrl.base_buffer =
>                                  devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
> 
>                  if (!io_sq->bounce_buf_ctrl.base_buffer) {
> -                       netdev_err(ena_dev->net_device,
> -                                  "Bounce buffer memory allocation failed\n");
> +                       netdev_err(ena_dev->net_device, "Bounce buffer memory allocation failed\n");
>                          return -ENOMEM;
>                  }
> 
> @@ -425,13 +412,11 @@ static int ena_com_init_io_cq(struct ena_com_dev *ena_dev,
>          prev_node = dev_to_node(ena_dev->dmadev);
>          set_dev_node(ena_dev->dmadev, ctx->numa_node);
>          io_cq->cdesc_addr.virt_addr =
> -               dma_alloc_coherent(ena_dev->dmadev, size,
> -                                  &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
> +               dma_alloc_coherent(ena_dev->dmadev, size, &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
>          set_dev_node(ena_dev->dmadev, prev_node);
>          if (!io_cq->cdesc_addr.virt_addr) {
>                  io_cq->cdesc_addr.virt_addr =
> -                       dma_alloc_coherent(ena_dev->dmadev, size,
> -                                          &io_cq->cdesc_addr.phys_addr,
> +                       dma_alloc_coherent(ena_dev->dmadev, size, &io_cq->cdesc_addr.phys_addr,
>                                             GFP_KERNEL);
>          }
> 
> @@ -514,8 +499,8 @@ static int ena_com_comp_status_to_errno(struct ena_com_admin_queue *admin_queue,
>                                          u8 comp_status)
>   {
>          if (unlikely(comp_status != 0))
> -               netdev_err(admin_queue->ena_dev->net_device,
> -                          "Admin command failed[%u]\n", comp_status);
> +               netdev_err(admin_queue->ena_dev->net_device, "Admin command failed[%u]\n",
> +                          comp_status);
> 
>          switch (comp_status) {
>          case ENA_ADMIN_SUCCESS:
> @@ -580,8 +565,7 @@ static int ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx *comp_c
>          }
> 
>          if (unlikely(comp_ctx->status == ENA_CMD_ABORTED)) {
> -               netdev_err(admin_queue->ena_dev->net_device,
> -                          "Command was aborted\n");
> +               netdev_err(admin_queue->ena_dev->net_device, "Command was aborted\n");
>                  spin_lock_irqsave(&admin_queue->q_lock, flags);
>                  admin_queue->stats.aborted_cmd++;
>                  spin_unlock_irqrestore(&admin_queue->q_lock, flags);
> @@ -589,8 +573,7 @@ static int ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx *comp_c
>                  goto err;
>          }
> 
> -       WARN(comp_ctx->status != ENA_CMD_COMPLETED, "Invalid comp status %d\n",
> -            comp_ctx->status);
> +       WARN(comp_ctx->status != ENA_CMD_COMPLETED, "Invalid comp status %d\n", comp_ctx->status);
> 
>          ret = ena_com_comp_status_to_errno(admin_queue, comp_ctx->comp_status);
>   err:
> @@ -634,8 +617,7 @@ static int ena_com_set_llq(struct ena_com_dev *ena_dev)
>                                              sizeof(resp));
> 
>          if (unlikely(ret))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to set LLQ configurations: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to set LLQ configurations: %d\n", ret);
> 
>          return ret;
>   }
> @@ -658,8 +640,7 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
>                          llq_default_cfg->llq_header_location;
>          } else {
>                  netdev_err(ena_dev->net_device,
> -                          "Invalid header location control, supported: 0x%x\n",
> -                          supported_feat);
> +                          "Invalid header location control, supported: 0x%x\n", supported_feat);
>                  return -EINVAL;
>          }
> 
> @@ -681,8 +662,8 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
> 
>                          netdev_err(ena_dev->net_device,
>                                     "Default llq stride ctrl is not supported, performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
> -                                  llq_default_cfg->llq_stride_ctrl,
> -                                  supported_feat, llq_info->desc_stride_ctrl);
> +                                  llq_default_cfg->llq_stride_ctrl, supported_feat,
> +                                  llq_info->desc_stride_ctrl);

Most of these changes make sense, but seem less useful in cases like 
this where the line count doesn't change.

sln

>                  }
>          } else {
>                  llq_info->desc_stride_ctrl = 0;
> @@ -704,8 +685,7 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
>                          llq_info->desc_list_entry_size = 256;
>                  } else {
>                          netdev_err(ena_dev->net_device,
> -                                  "Invalid entry_size_ctrl, supported: 0x%x\n",
> -                                  supported_feat);
> +                                  "Invalid entry_size_ctrl, supported: 0x%x\n", supported_feat);
>                          return -EINVAL;
>                  }
> 
> @@ -750,8 +730,8 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
> 
>                  netdev_err(ena_dev->net_device,
>                             "Default llq num descs before header is not supported, performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
> -                          llq_default_cfg->llq_num_decs_before_header,
> -                          supported_feat, llq_info->descs_num_before_header);
> +                          llq_default_cfg->llq_num_decs_before_header, supported_feat,
> +                          llq_info->descs_num_before_header);
>          }
>          /* Check for accelerated queue supported */
>          llq_accel_mode_get = llq_features->accel_mode.u.get;
> @@ -767,8 +747,7 @@ static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
> 
>          rc = ena_com_set_llq(ena_dev);
>          if (rc)
> -               netdev_err(ena_dev->net_device,
> -                          "Cannot set LLQ configuration: %d\n", rc);
> +               netdev_err(ena_dev->net_device, "Cannot set LLQ configuration: %d\n", rc);
> 
>          return rc;
>   }
> @@ -780,8 +759,7 @@ static int ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx *com
>          int ret;
> 
>          wait_for_completion_timeout(&comp_ctx->wait_event,
> -                                   usecs_to_jiffies(
> -                                           admin_queue->completion_timeout));
> +                                   usecs_to_jiffies(admin_queue->completion_timeout));
> 
>          /* In case the command wasn't completed find out the root cause.
>           * There might be 2 kinds of errors
> @@ -797,8 +775,7 @@ static int ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx *com
>                  if (comp_ctx->status == ENA_CMD_COMPLETED) {
>                          netdev_err(admin_queue->ena_dev->net_device,
>                                     "The ena device sent a completion but the driver didn't receive a MSI-X interrupt (cmd %d), autopolling mode is %s\n",
> -                                  comp_ctx->cmd_opcode,
> -                                  admin_queue->auto_polling ? "ON" : "OFF");
> +                                  comp_ctx->cmd_opcode, admin_queue->auto_polling ? "ON" : "OFF");
>                          /* Check if fallback to polling is enabled */
>                          if (admin_queue->auto_polling)
>                                  admin_queue->polling = true;
> @@ -867,15 +844,13 @@ static u32 ena_com_reg_bar_read32(struct ena_com_dev *ena_dev, u16 offset)
>          if (unlikely(i == timeout)) {
>                  netdev_err(ena_dev->net_device,
>                             "Reading reg failed for timeout. expected: req id[%u] offset[%u] actual: req id[%u] offset[%u]\n",
> -                          mmio_read->seq_num, offset, read_resp->req_id,
> -                          read_resp->reg_off);
> +                          mmio_read->seq_num, offset, read_resp->req_id, read_resp->reg_off);
>                  ret = ENA_MMIO_READ_TIMEOUT;
>                  goto err;
>          }
> 
>          if (read_resp->reg_off != offset) {
> -               netdev_err(ena_dev->net_device,
> -                          "Read failure: wrong offset provided\n");
> +               netdev_err(ena_dev->net_device, "Read failure: wrong offset provided\n");
>                  ret = ENA_MMIO_READ_TIMEOUT;
>          } else {
>                  ret = read_resp->reg_val;
> @@ -934,8 +909,7 @@ static int ena_com_destroy_io_sq(struct ena_com_dev *ena_dev,
>                                              sizeof(destroy_resp));
> 
>          if (unlikely(ret && (ret != -ENODEV)))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to destroy io sq error: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to destroy io sq error: %d\n", ret);
> 
>          return ret;
>   }
> @@ -949,8 +923,7 @@ static void ena_com_io_queue_free(struct ena_com_dev *ena_dev,
>          if (io_cq->cdesc_addr.virt_addr) {
>                  size = io_cq->cdesc_entry_size_in_bytes * io_cq->q_depth;
> 
> -               dma_free_coherent(ena_dev->dmadev, size,
> -                                 io_cq->cdesc_addr.virt_addr,
> +               dma_free_coherent(ena_dev->dmadev, size, io_cq->cdesc_addr.virt_addr,
>                                    io_cq->cdesc_addr.phys_addr);
> 
>                  io_cq->cdesc_addr.virt_addr = NULL;
> @@ -959,8 +932,7 @@ static void ena_com_io_queue_free(struct ena_com_dev *ena_dev,
>          if (io_sq->desc_addr.virt_addr) {
>                  size = io_sq->desc_entry_size * io_sq->q_depth;
> 
> -               dma_free_coherent(ena_dev->dmadev, size,
> -                                 io_sq->desc_addr.virt_addr,
> +               dma_free_coherent(ena_dev->dmadev, size, io_sq->desc_addr.virt_addr,
>                                    io_sq->desc_addr.phys_addr);
> 
>                  io_sq->desc_addr.virt_addr = NULL;
> @@ -985,8 +957,7 @@ static int wait_for_reset_state(struct ena_com_dev *ena_dev, u32 timeout,
>                  val = ena_com_reg_bar_read32(ena_dev, ENA_REGS_DEV_STS_OFF);
> 
>                  if (unlikely(val == ENA_MMIO_READ_TIMEOUT)) {
> -                       netdev_err(ena_dev->net_device,
> -                                  "Reg read timeout occurred\n");
> +                       netdev_err(ena_dev->net_device, "Reg read timeout occurred\n");
>                          return -ETIME;
>                  }
> 
> @@ -1026,8 +997,7 @@ static int ena_com_get_feature_ex(struct ena_com_dev *ena_dev,
>          int ret;
> 
>          if (!ena_com_check_supported_feature_id(ena_dev, feature_id)) {
> -               netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
> -                          feature_id);
> +               netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n", feature_id);
>                  return -EOPNOTSUPP;
>          }
> 
> @@ -1064,8 +1034,7 @@ static int ena_com_get_feature_ex(struct ena_com_dev *ena_dev,
> 
>          if (unlikely(ret))
>                  netdev_err(ena_dev->net_device,
> -                          "Failed to submit get_feature command %d error: %d\n",
> -                          feature_id, ret);
> +                          "Failed to submit get_feature command %d error: %d\n", feature_id, ret);
> 
>          return ret;
>   }
> @@ -1104,13 +1073,11 @@ static int ena_com_hash_key_allocate(struct ena_com_dev *ena_dev)
>   {
>          struct ena_rss *rss = &ena_dev->rss;
> 
> -       if (!ena_com_check_supported_feature_id(ena_dev,
> -                                               ENA_ADMIN_RSS_HASH_FUNCTION))
> +       if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_HASH_FUNCTION))
>                  return -EOPNOTSUPP;
> 
> -       rss->hash_key =
> -               dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
> -                                  &rss->hash_key_dma_addr, GFP_KERNEL);
> +       rss->hash_key = dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
> +                                          &rss->hash_key_dma_addr, GFP_KERNEL);
> 
>          if (unlikely(!rss->hash_key))
>                  return -ENOMEM;
> @@ -1123,8 +1090,8 @@ static void ena_com_hash_key_destroy(struct ena_com_dev *ena_dev)
>          struct ena_rss *rss = &ena_dev->rss;
> 
>          if (rss->hash_key)
> -               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
> -                                 rss->hash_key, rss->hash_key_dma_addr);
> +               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_key), rss->hash_key,
> +                                 rss->hash_key_dma_addr);
>          rss->hash_key = NULL;
>   }
> 
> @@ -1132,9 +1099,8 @@ static int ena_com_hash_ctrl_init(struct ena_com_dev *ena_dev)
>   {
>          struct ena_rss *rss = &ena_dev->rss;
> 
> -       rss->hash_ctrl =
> -               dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
> -                                  &rss->hash_ctrl_dma_addr, GFP_KERNEL);
> +       rss->hash_ctrl = dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
> +                                           &rss->hash_ctrl_dma_addr, GFP_KERNEL);
> 
>          if (unlikely(!rss->hash_ctrl))
>                  return -ENOMEM;
> @@ -1147,8 +1113,8 @@ static void ena_com_hash_ctrl_destroy(struct ena_com_dev *ena_dev)
>          struct ena_rss *rss = &ena_dev->rss;
> 
>          if (rss->hash_ctrl)
> -               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
> -                                 rss->hash_ctrl, rss->hash_ctrl_dma_addr);
> +               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl), rss->hash_ctrl,
> +                                 rss->hash_ctrl_dma_addr);
>          rss->hash_ctrl = NULL;
>   }
> 
> @@ -1177,15 +1143,13 @@ static int ena_com_indirect_table_allocate(struct ena_com_dev *ena_dev,
>          tbl_size = (1ULL << log_size) *
>                  sizeof(struct ena_admin_rss_ind_table_entry);
> 
> -       rss->rss_ind_tbl =
> -               dma_alloc_coherent(ena_dev->dmadev, tbl_size,
> -                                  &rss->rss_ind_tbl_dma_addr, GFP_KERNEL);
> +       rss->rss_ind_tbl = dma_alloc_coherent(ena_dev->dmadev, tbl_size, &rss->rss_ind_tbl_dma_addr,
> +                                             GFP_KERNEL);
>          if (unlikely(!rss->rss_ind_tbl))
>                  goto mem_err1;
> 
>          tbl_size = (1ULL << log_size) * sizeof(u16);
> -       rss->host_rss_ind_tbl =
> -               devm_kzalloc(ena_dev->dmadev, tbl_size, GFP_KERNEL);
> +       rss->host_rss_ind_tbl = devm_kzalloc(ena_dev->dmadev, tbl_size, GFP_KERNEL);
>          if (unlikely(!rss->host_rss_ind_tbl))
>                  goto mem_err2;
> 
> @@ -1197,8 +1161,7 @@ mem_err2:
>          tbl_size = (1ULL << log_size) *
>                  sizeof(struct ena_admin_rss_ind_table_entry);
> 
> -       dma_free_coherent(ena_dev->dmadev, tbl_size, rss->rss_ind_tbl,
> -                         rss->rss_ind_tbl_dma_addr);
> +       dma_free_coherent(ena_dev->dmadev, tbl_size, rss->rss_ind_tbl, rss->rss_ind_tbl_dma_addr);
>          rss->rss_ind_tbl = NULL;
>   mem_err1:
>          rss->tbl_log_size = 0;
> @@ -1261,8 +1224,7 @@ static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
>                                             &create_cmd.sq_ba,
>                                             io_sq->desc_addr.phys_addr);
>                  if (unlikely(ret)) {
> -                       netdev_err(ena_dev->net_device,
> -                                  "Memory address set failed\n");
> +                       netdev_err(ena_dev->net_device, "Memory address set failed\n");
>                          return ret;
>                  }
>          }
> @@ -1273,8 +1235,7 @@ static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
>                                              (struct ena_admin_acq_entry *)&cmd_completion,
>                                              sizeof(cmd_completion));
>          if (unlikely(ret)) {
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to create IO SQ. error: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to create IO SQ. error: %d\n", ret);
>                  return ret;
>          }
> 
> @@ -1289,8 +1250,7 @@ static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
>                          cmd_completion.llq_descriptors_offset);
>          }
> 
> -       netdev_dbg(ena_dev->net_device, "Created sq[%u], depth[%u]\n",
> -                  io_sq->idx, io_sq->q_depth);
> +       netdev_dbg(ena_dev->net_device, "Created sq[%u], depth[%u]\n", io_sq->idx, io_sq->q_depth);
> 
>          return ret;
>   }
> @@ -1417,8 +1377,7 @@ int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
>                                              (struct ena_admin_acq_entry *)&cmd_completion,
>                                              sizeof(cmd_completion));
>          if (unlikely(ret)) {
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to create IO CQ. error: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to create IO CQ. error: %d\n", ret);
>                  return ret;
>          }
> 
> @@ -1432,8 +1391,7 @@ int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
>                          (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
>                          cmd_completion.numa_node_register_offset);
> 
> -       netdev_dbg(ena_dev->net_device, "Created cq[%u], depth[%u]\n",
> -                  io_cq->idx, io_cq->q_depth);
> +       netdev_dbg(ena_dev->net_device, "Created cq[%u], depth[%u]\n", io_cq->idx, io_cq->q_depth);
> 
>          return ret;
>   }
> @@ -1443,8 +1401,7 @@ int ena_com_get_io_handlers(struct ena_com_dev *ena_dev, u16 qid,
>                              struct ena_com_io_cq **io_cq)
>   {
>          if (qid >= ENA_TOTAL_NUM_QUEUES) {
> -               netdev_err(ena_dev->net_device,
> -                          "Invalid queue number %d but the max is %d\n", qid,
> +               netdev_err(ena_dev->net_device, "Invalid queue number %d but the max is %d\n", qid,
>                             ENA_TOTAL_NUM_QUEUES);
>                  return -EINVAL;
>          }
> @@ -1484,8 +1441,7 @@ void ena_com_wait_for_abort_completion(struct ena_com_dev *ena_dev)
>          spin_lock_irqsave(&admin_queue->q_lock, flags);
>          while (atomic_read(&admin_queue->outstanding_cmds) != 0) {
>                  spin_unlock_irqrestore(&admin_queue->q_lock, flags);
> -               ena_delay_exponential_backoff_us(exp++,
> -                                                ena_dev->ena_min_poll_delay_us);
> +               ena_delay_exponential_backoff_us(exp++, ena_dev->ena_min_poll_delay_us);
>                  spin_lock_irqsave(&admin_queue->q_lock, flags);
>          }
>          spin_unlock_irqrestore(&admin_queue->q_lock, flags);
> @@ -1511,8 +1467,7 @@ int ena_com_destroy_io_cq(struct ena_com_dev *ena_dev,
>                                              sizeof(destroy_resp));
> 
>          if (unlikely(ret && (ret != -ENODEV)))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to destroy IO CQ. error: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to destroy IO CQ. error: %d\n", ret);
> 
>          return ret;
>   }
> @@ -1580,8 +1535,7 @@ int ena_com_set_aenq_config(struct ena_com_dev *ena_dev, u32 groups_flag)
>                                              sizeof(resp));
> 
>          if (unlikely(ret))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to config AENQ ret: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to config AENQ ret: %d\n", ret);
> 
>          return ret;
>   }
> @@ -1602,8 +1556,7 @@ int ena_com_get_dma_width(struct ena_com_dev *ena_dev)
>          netdev_dbg(ena_dev->net_device, "ENA dma width: %d\n", width);
> 
>          if ((width < 32) || width > ENA_MAX_PHYS_ADDR_SIZE_BITS) {
> -               netdev_err(ena_dev->net_device, "DMA width illegal value: %d\n",
> -                          width);
> +               netdev_err(ena_dev->net_device, "DMA width illegal value: %d\n", width);
>                  return -EINVAL;
>          }
> 
> @@ -1625,19 +1578,16 @@ int ena_com_validate_version(struct ena_com_dev *ena_dev)
>          ctrl_ver = ena_com_reg_bar_read32(ena_dev,
>                                            ENA_REGS_CONTROLLER_VERSION_OFF);
> 
> -       if (unlikely((ver == ENA_MMIO_READ_TIMEOUT) ||
> -                    (ctrl_ver == ENA_MMIO_READ_TIMEOUT))) {
> +       if (unlikely((ver == ENA_MMIO_READ_TIMEOUT) || (ctrl_ver == ENA_MMIO_READ_TIMEOUT))) {
>                  netdev_err(ena_dev->net_device, "Reg read timeout occurred\n");
>                  return -ETIME;
>          }
> 
>          dev_info(ena_dev->dmadev, "ENA device version: %d.%d\n",
> -                (ver & ENA_REGS_VERSION_MAJOR_VERSION_MASK) >>
> -                        ENA_REGS_VERSION_MAJOR_VERSION_SHIFT,
> +                (ver & ENA_REGS_VERSION_MAJOR_VERSION_MASK) >> ENA_REGS_VERSION_MAJOR_VERSION_SHIFT,
>                   ver & ENA_REGS_VERSION_MINOR_VERSION_MASK);
> 
> -       dev_info(ena_dev->dmadev,
> -                "ENA controller version: %d.%d.%d implementation version %d\n",
> +       dev_info(ena_dev->dmadev, "ENA controller version: %d.%d.%d implementation version %d\n",
>                   (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_MASK) >>
>                           ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_SHIFT,
>                   (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MINOR_VERSION_MASK) >>
> @@ -1686,20 +1636,17 @@ void ena_com_admin_destroy(struct ena_com_dev *ena_dev)
> 
>          size = ADMIN_SQ_SIZE(admin_queue->q_depth);
>          if (sq->entries)
> -               dma_free_coherent(ena_dev->dmadev, size, sq->entries,
> -                                 sq->dma_addr);
> +               dma_free_coherent(ena_dev->dmadev, size, sq->entries, sq->dma_addr);
>          sq->entries = NULL;
> 
>          size = ADMIN_CQ_SIZE(admin_queue->q_depth);
>          if (cq->entries)
> -               dma_free_coherent(ena_dev->dmadev, size, cq->entries,
> -                                 cq->dma_addr);
> +               dma_free_coherent(ena_dev->dmadev, size, cq->entries, cq->dma_addr);
>          cq->entries = NULL;
> 
>          size = ADMIN_AENQ_SIZE(aenq->q_depth);
>          if (ena_dev->aenq.entries)
> -               dma_free_coherent(ena_dev->dmadev, size, aenq->entries,
> -                                 aenq->dma_addr);
> +               dma_free_coherent(ena_dev->dmadev, size, aenq->entries, aenq->dma_addr);
>          aenq->entries = NULL;
>   }
> 
> @@ -1725,10 +1672,8 @@ int ena_com_mmio_reg_read_request_init(struct ena_com_dev *ena_dev)
>          struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
> 
>          spin_lock_init(&mmio_read->lock);
> -       mmio_read->read_resp =
> -               dma_alloc_coherent(ena_dev->dmadev,
> -                                  sizeof(*mmio_read->read_resp),
> -                                  &mmio_read->read_resp_dma_addr, GFP_KERNEL);
> +       mmio_read->read_resp = dma_alloc_coherent(ena_dev->dmadev, sizeof(*mmio_read->read_resp),
> +                                                 &mmio_read->read_resp_dma_addr, GFP_KERNEL);
>          if (unlikely(!mmio_read->read_resp))
>                  goto err;
> 
> @@ -1759,8 +1704,8 @@ void ena_com_mmio_reg_read_request_destroy(struct ena_com_dev *ena_dev)
>          writel(0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_LO_OFF);
>          writel(0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_HI_OFF);
> 
> -       dma_free_coherent(ena_dev->dmadev, sizeof(*mmio_read->read_resp),
> -                         mmio_read->read_resp, mmio_read->read_resp_dma_addr);
> +       dma_free_coherent(ena_dev->dmadev, sizeof(*mmio_read->read_resp), mmio_read->read_resp,
> +                         mmio_read->read_resp_dma_addr);
> 
>          mmio_read->read_resp = NULL;
>   }
> @@ -1792,8 +1737,7 @@ int ena_com_admin_init(struct ena_com_dev *ena_dev,
>          }
> 
>          if (!(dev_sts & ENA_REGS_DEV_STS_READY_MASK)) {
> -               netdev_err(ena_dev->net_device,
> -                          "Device isn't ready, abort com init\n");
> +               netdev_err(ena_dev->net_device, "Device isn't ready, abort com init\n");
>                  return -ENODEV;
>          }
> 
> @@ -1870,8 +1814,7 @@ int ena_com_create_io_queue(struct ena_com_dev *ena_dev,
>          int ret;
> 
>          if (ctx->qid >= ENA_TOTAL_NUM_QUEUES) {
> -               netdev_err(ena_dev->net_device,
> -                          "Qid (%d) is bigger than max num of queues (%d)\n",
> +               netdev_err(ena_dev->net_device, "Qid (%d) is bigger than max num of queues (%d)\n",
>                             ctx->qid, ENA_TOTAL_NUM_QUEUES);
>                  return -EINVAL;
>          }
> @@ -1897,8 +1840,7 @@ int ena_com_create_io_queue(struct ena_com_dev *ena_dev,
> 
>          if (ctx->direction == ENA_COM_IO_QUEUE_DIRECTION_TX)
>                  /* header length is limited to 8 bits */
> -               io_sq->tx_max_header_size =
> -                       min_t(u32, ena_dev->tx_max_header_size, SZ_256);
> +               io_sq->tx_max_header_size = min_t(u32, ena_dev->tx_max_header_size, SZ_256);
> 
>          ret = ena_com_init_io_sq(ena_dev, ctx, io_sq);
>          if (ret)
> @@ -1930,8 +1872,7 @@ void ena_com_destroy_io_queue(struct ena_com_dev *ena_dev, u16 qid)
>          struct ena_com_io_cq *io_cq;
> 
>          if (qid >= ENA_TOTAL_NUM_QUEUES) {
> -               netdev_err(ena_dev->net_device,
> -                          "Qid (%d) is bigger than max num of queues (%d)\n",
> +               netdev_err(ena_dev->net_device, "Qid (%d) is bigger than max num of queues (%d)\n",
>                             qid, ENA_TOTAL_NUM_QUEUES);
>                  return;
>          }
> @@ -1975,8 +1916,7 @@ int ena_com_get_dev_attr_feat(struct ena_com_dev *ena_dev,
>                  if (rc)
>                          return rc;
> 
> -               if (get_resp.u.max_queue_ext.version !=
> -                   ENA_FEATURE_MAX_QUEUE_EXT_VER)
> +               if (get_resp.u.max_queue_ext.version != ENA_FEATURE_MAX_QUEUE_EXT_VER)
>                          return -EINVAL;
> 
>                  memcpy(&get_feat_ctx->max_queue_ext, &get_resp.u.max_queue_ext,
> @@ -2017,18 +1957,15 @@ int ena_com_get_dev_attr_feat(struct ena_com_dev *ena_dev,
>          rc = ena_com_get_feature(ena_dev, &get_resp, ENA_ADMIN_HW_HINTS, 0);
> 
>          if (!rc)
> -               memcpy(&get_feat_ctx->hw_hints, &get_resp.u.hw_hints,
> -                      sizeof(get_resp.u.hw_hints));
> +               memcpy(&get_feat_ctx->hw_hints, &get_resp.u.hw_hints, sizeof(get_resp.u.hw_hints));
>          else if (rc == -EOPNOTSUPP)
> -               memset(&get_feat_ctx->hw_hints, 0x0,
> -                      sizeof(get_feat_ctx->hw_hints));
> +               memset(&get_feat_ctx->hw_hints, 0x0, sizeof(get_feat_ctx->hw_hints));
>          else
>                  return rc;
> 
>          rc = ena_com_get_feature(ena_dev, &get_resp, ENA_ADMIN_LLQ, 0);
>          if (!rc)
> -               memcpy(&get_feat_ctx->llq, &get_resp.u.llq,
> -                      sizeof(get_resp.u.llq));
> +               memcpy(&get_feat_ctx->llq, &get_resp.u.llq, sizeof(get_resp.u.llq));
>          else if (rc == -EOPNOTSUPP)
>                  memset(&get_feat_ctx->llq, 0x0, sizeof(get_feat_ctx->llq));
>          else
> @@ -2076,8 +2013,7 @@ void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
>          aenq_common = &aenq_e->aenq_common_desc;
> 
>          /* Go over all the events */
> -       while ((READ_ONCE(aenq_common->flags) &
> -               ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
> +       while ((READ_ONCE(aenq_common->flags) & ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
>                  /* Make sure the phase bit (ownership) is as expected before
>                   * reading the rest of the descriptor.
>                   */
> @@ -2086,8 +2022,7 @@ void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
>                  timestamp = (u64)aenq_common->timestamp_low |
>                          ((u64)aenq_common->timestamp_high << 32);
> 
> -               netdev_dbg(ena_dev->net_device,
> -                          "AENQ! Group[%x] Syndrome[%x] timestamp: [%llus]\n",
> +               netdev_dbg(ena_dev->net_device, "AENQ! Group[%x] Syndrome[%x] timestamp: [%llus]\n",
>                             aenq_common->group, aenq_common->syndrome, timestamp);
> 
>                  /* Handle specific event*/
> @@ -2116,8 +2051,7 @@ void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
> 
>          /* write the aenq doorbell after all AENQ descriptors were read */
>          mb();
> -       writel_relaxed((u32)aenq->head,
> -                      ena_dev->reg_bar + ENA_REGS_AENQ_HEAD_DB_OFF);
> +       writel_relaxed((u32)aenq->head, ena_dev->reg_bar + ENA_REGS_AENQ_HEAD_DB_OFF);
>   }
> 
>   int ena_com_dev_reset(struct ena_com_dev *ena_dev,
> @@ -2129,15 +2063,13 @@ int ena_com_dev_reset(struct ena_com_dev *ena_dev,
>          stat = ena_com_reg_bar_read32(ena_dev, ENA_REGS_DEV_STS_OFF);
>          cap = ena_com_reg_bar_read32(ena_dev, ENA_REGS_CAPS_OFF);
> 
> -       if (unlikely((stat == ENA_MMIO_READ_TIMEOUT) ||
> -                    (cap == ENA_MMIO_READ_TIMEOUT))) {
> +       if (unlikely((stat == ENA_MMIO_READ_TIMEOUT) || (cap == ENA_MMIO_READ_TIMEOUT))) {
>                  netdev_err(ena_dev->net_device, "Reg read32 timeout occurred\n");
>                  return -ETIME;
>          }
> 
>          if ((stat & ENA_REGS_DEV_STS_READY_MASK) == 0) {
> -               netdev_err(ena_dev->net_device,
> -                          "Device isn't ready, can't reset device\n");
> +               netdev_err(ena_dev->net_device, "Device isn't ready, can't reset device\n");
>                  return -EINVAL;
>          }
> 
> @@ -2160,8 +2092,7 @@ int ena_com_dev_reset(struct ena_com_dev *ena_dev,
>          rc = wait_for_reset_state(ena_dev, timeout,
>                                    ENA_REGS_DEV_STS_RESET_IN_PROGRESS_MASK);
>          if (rc != 0) {
> -               netdev_err(ena_dev->net_device,
> -                          "Reset indication didn't turn on\n");
> +               netdev_err(ena_dev->net_device, "Reset indication didn't turn on\n");
>                  return rc;
>          }
> 
> @@ -2169,8 +2100,7 @@ int ena_com_dev_reset(struct ena_com_dev *ena_dev,
>          writel(0, ena_dev->reg_bar + ENA_REGS_DEV_CTL_OFF);
>          rc = wait_for_reset_state(ena_dev, timeout, 0);
>          if (rc != 0) {
> -               netdev_err(ena_dev->net_device,
> -                          "Reset indication didn't turn off\n");
> +               netdev_err(ena_dev->net_device, "Reset indication didn't turn off\n");
>                  return rc;
>          }
> 
> @@ -2207,8 +2137,7 @@ static int ena_get_dev_stats(struct ena_com_dev *ena_dev,
>                                               sizeof(*get_resp));
> 
>          if (unlikely(ret))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to get stats. error: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to get stats. error: %d\n", ret);
> 
>          return ret;
>   }
> @@ -2220,8 +2149,7 @@ int ena_com_get_eni_stats(struct ena_com_dev *ena_dev,
>          int ret;
> 
>          if (!ena_com_get_cap(ena_dev, ENA_ADMIN_ENI_STATS)) {
> -               netdev_err(ena_dev->net_device,
> -                          "Capability %d isn't supported\n",
> +               netdev_err(ena_dev->net_device, "Capability %d isn't supported\n",
>                             ENA_ADMIN_ENI_STATS);
>                  return -EOPNOTSUPP;
>          }
> @@ -2258,8 +2186,7 @@ int ena_com_set_dev_mtu(struct ena_com_dev *ena_dev, u32 mtu)
>          int ret;
> 
>          if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_MTU)) {
> -               netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
> -                          ENA_ADMIN_MTU);
> +               netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n", ENA_ADMIN_MTU);
>                  return -EOPNOTSUPP;
>          }
> 
> @@ -2278,8 +2205,7 @@ int ena_com_set_dev_mtu(struct ena_com_dev *ena_dev, u32 mtu)
>                                              sizeof(resp));
> 
>          if (unlikely(ret))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to set mtu %d. error: %d\n", mtu, ret);
> +               netdev_err(ena_dev->net_device, "Failed to set mtu %d. error: %d\n", mtu, ret);
> 
>          return ret;
>   }
> @@ -2293,8 +2219,7 @@ int ena_com_get_offload_settings(struct ena_com_dev *ena_dev,
>          ret = ena_com_get_feature(ena_dev, &resp,
>                                    ENA_ADMIN_STATELESS_OFFLOAD_CONFIG, 0);
>          if (unlikely(ret)) {
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to get offload capabilities %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to get offload capabilities %d\n", ret);
>                  return ret;
>          }
> 
> @@ -2312,8 +2237,7 @@ int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
>          struct ena_admin_get_feat_resp get_resp;
>          int ret;
> 
> -       if (!ena_com_check_supported_feature_id(ena_dev,
> -                                               ENA_ADMIN_RSS_HASH_FUNCTION)) {
> +       if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_HASH_FUNCTION)) {
>                  netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
>                             ENA_ADMIN_RSS_HASH_FUNCTION);
>                  return -EOPNOTSUPP;
> @@ -2326,8 +2250,7 @@ int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
>                  return ret;
> 
>          if (!(get_resp.u.flow_hash_func.supported_func & BIT(rss->hash_func))) {
> -               netdev_err(ena_dev->net_device,
> -                          "Func hash %d isn't supported by device, abort\n",
> +               netdev_err(ena_dev->net_device, "Func hash %d isn't supported by device, abort\n",
>                             rss->hash_func);
>                  return -EOPNOTSUPP;
>          }
> @@ -2357,8 +2280,7 @@ int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
>                                              (struct ena_admin_acq_entry *)&resp,
>                                              sizeof(resp));
>          if (unlikely(ret)) {
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to set hash function %d. error: %d\n",
> +               netdev_err(ena_dev->net_device, "Failed to set hash function %d. error: %d\n",
>                             rss->hash_func, ret);
>                  return -EINVAL;
>          }
> @@ -2390,16 +2312,15 @@ int ena_com_fill_hash_function(struct ena_com_dev *ena_dev,
>                  return rc;
> 
>          if (!(BIT(func) & get_resp.u.flow_hash_func.supported_func)) {
> -               netdev_err(ena_dev->net_device,
> -                          "Flow hash function %d isn't supported\n", func);
> +               netdev_err(ena_dev->net_device, "Flow hash function %d isn't supported\n", func);
>                  return -EOPNOTSUPP;
>          }
> 
>          if ((func == ENA_ADMIN_TOEPLITZ) && key) {
>                  if (key_len != sizeof(hash_key->key)) {
>                          netdev_err(ena_dev->net_device,
> -                                  "key len (%u) doesn't equal the supported size (%zu)\n",
> -                                  key_len, sizeof(hash_key->key));
> +                                  "key len (%u) doesn't equal the supported size (%zu)\n", key_len,
> +                                  sizeof(hash_key->key));
>                          return -EINVAL;
>                  }
>                  memcpy(hash_key->key, key, key_len);
> @@ -2487,8 +2408,7 @@ int ena_com_set_hash_ctrl(struct ena_com_dev *ena_dev)
>          struct ena_admin_set_feat_resp resp;
>          int ret;
> 
> -       if (!ena_com_check_supported_feature_id(ena_dev,
> -                                               ENA_ADMIN_RSS_HASH_INPUT)) {
> +       if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_HASH_INPUT)) {
>                  netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
>                             ENA_ADMIN_RSS_HASH_INPUT);
>                  return -EOPNOTSUPP;
> @@ -2519,8 +2439,7 @@ int ena_com_set_hash_ctrl(struct ena_com_dev *ena_dev)
>                                              (struct ena_admin_acq_entry *)&resp,
>                                              sizeof(resp));
>          if (unlikely(ret))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to set hash input. error: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to set hash input. error: %d\n", ret);
> 
>          return ret;
>   }
> @@ -2597,8 +2516,7 @@ int ena_com_fill_hash_ctrl(struct ena_com_dev *ena_dev,
>          int rc;
> 
>          if (proto >= ENA_ADMIN_RSS_PROTO_NUM) {
> -               netdev_err(ena_dev->net_device, "Invalid proto num (%u)\n",
> -                          proto);
> +               netdev_err(ena_dev->net_device, "Invalid proto num (%u)\n", proto);
>                  return -EINVAL;
>          }
> 
> @@ -2650,8 +2568,7 @@ int ena_com_indirect_table_set(struct ena_com_dev *ena_dev)
>          struct ena_admin_set_feat_resp resp;
>          int ret;
> 
> -       if (!ena_com_check_supported_feature_id(
> -                   ena_dev, ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG)) {
> +       if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG)) {
>                  netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
>                             ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG);
>                  return -EOPNOTSUPP;
> @@ -2691,8 +2608,7 @@ int ena_com_indirect_table_set(struct ena_com_dev *ena_dev)
>                                              sizeof(resp));
> 
>          if (unlikely(ret))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to set indirect table. error: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to set indirect table. error: %d\n", ret);
> 
>          return ret;
>   }
> @@ -2771,9 +2687,8 @@ int ena_com_allocate_host_info(struct ena_com_dev *ena_dev)
>   {
>          struct ena_host_attribute *host_attr = &ena_dev->host_attr;
> 
> -       host_attr->host_info =
> -               dma_alloc_coherent(ena_dev->dmadev, SZ_4K,
> -                                  &host_attr->host_info_dma_addr, GFP_KERNEL);
> +       host_attr->host_info = dma_alloc_coherent(ena_dev->dmadev, SZ_4K,
> +                                                 &host_attr->host_info_dma_addr, GFP_KERNEL);
>          if (unlikely(!host_attr->host_info))
>                  return -ENOMEM;
> 
> @@ -2819,8 +2734,7 @@ void ena_com_delete_debug_area(struct ena_com_dev *ena_dev)
> 
>          if (host_attr->debug_area_virt_addr) {
>                  dma_free_coherent(ena_dev->dmadev, host_attr->debug_area_size,
> -                                 host_attr->debug_area_virt_addr,
> -                                 host_attr->debug_area_dma_addr);
> +                                 host_attr->debug_area_virt_addr, host_attr->debug_area_dma_addr);
>                  host_attr->debug_area_virt_addr = NULL;
>          }
>   }
> @@ -2869,8 +2783,7 @@ int ena_com_set_host_attributes(struct ena_com_dev *ena_dev)
>                                              sizeof(resp));
> 
>          if (unlikely(ret))
> -               netdev_err(ena_dev->net_device,
> -                          "Failed to set host attributes: %d\n", ret);
> +               netdev_err(ena_dev->net_device, "Failed to set host attributes: %d\n", ret);
> 
>          return ret;
>   }
> @@ -2888,8 +2801,7 @@ static int ena_com_update_nonadaptive_moderation_interval(struct ena_com_dev *en
>                                                            u32 *intr_moder_interval)
>   {
>          if (!intr_delay_resolution) {
> -               netdev_err(ena_dev->net_device,
> -                          "Illegal interrupt delay granularity value\n");
> +               netdev_err(ena_dev->net_device, "Illegal interrupt delay granularity value\n");
>                  return -EFAULT;
>          }
> 
> @@ -2927,14 +2839,12 @@ int ena_com_init_interrupt_moderation(struct ena_com_dev *ena_dev)
> 
>          if (rc) {
>                  if (rc == -EOPNOTSUPP) {
> -                       netdev_dbg(ena_dev->net_device,
> -                                  "Feature %d isn't supported\n",
> +                       netdev_dbg(ena_dev->net_device, "Feature %d isn't supported\n",
>                                     ENA_ADMIN_INTERRUPT_MODERATION);
>                          rc = 0;
>                  } else {
>                          netdev_err(ena_dev->net_device,
> -                                  "Failed to get interrupt moderation admin cmd. rc: %d\n",
> -                                  rc);
> +                                  "Failed to get interrupt moderation admin cmd. rc: %d\n", rc);
>                  }
> 
>                  /* no moderation supported, disable adaptive support */
> @@ -2982,8 +2892,7 @@ int ena_com_config_dev_mode(struct ena_com_dev *ena_dev,
>                  (llq_info->descs_num_before_header * sizeof(struct ena_eth_io_tx_desc));
> 
>          if (unlikely(ena_dev->tx_max_header_size == 0)) {
> -               netdev_err(ena_dev->net_device,
> -                          "The size of the LLQ entry is smaller than needed\n");
> +               netdev_err(ena_dev->net_device, "The size of the LLQ entry is smaller than needed\n");
>                  return -EINVAL;
>          }
> 
> diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.c b/drivers/net/ethernet/amazon/ena/ena_eth_com.c
> index f9f8862..933e619 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_eth_com.c
> +++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.c
> @@ -18,8 +18,7 @@ static struct ena_eth_io_rx_cdesc_base *ena_com_get_next_rx_cdesc(
>          cdesc = (struct ena_eth_io_rx_cdesc_base *)(io_cq->cdesc_addr.virt_addr
>                          + (head_masked * io_cq->cdesc_entry_size_in_bytes));
> 
> -       desc_phase = (READ_ONCE(cdesc->status) &
> -                     ENA_ETH_IO_RX_CDESC_BASE_PHASE_MASK) >>
> +       desc_phase = (READ_ONCE(cdesc->status) & ENA_ETH_IO_RX_CDESC_BASE_PHASE_MASK) >>
>                       ENA_ETH_IO_RX_CDESC_BASE_PHASE_SHIFT;
> 
>          if (desc_phase != expected_phase)
> @@ -65,8 +64,8 @@ static int ena_com_write_bounce_buffer_to_dev(struct ena_com_io_sq *io_sq,
> 
>                  io_sq->entries_in_tx_burst_left--;
>                  netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                          "Decreasing entries_in_tx_burst_left of queue %d to %d\n",
> -                          io_sq->qid, io_sq->entries_in_tx_burst_left);
> +                          "Decreasing entries_in_tx_burst_left of queue %d to %d\n", io_sq->qid,
> +                          io_sq->entries_in_tx_burst_left);
>          }
> 
>          /* Make sure everything was written into the bounce buffer before
> @@ -75,8 +74,8 @@ static int ena_com_write_bounce_buffer_to_dev(struct ena_com_io_sq *io_sq,
>          wmb();
> 
>          /* The line is completed. Copy it to dev */
> -       __iowrite64_copy(io_sq->desc_addr.pbuf_dev_addr + dst_offset,
> -                        bounce_buffer, (llq_info->desc_list_entry_size) / 8);
> +       __iowrite64_copy(io_sq->desc_addr.pbuf_dev_addr + dst_offset, bounce_buffer,
> +                        (llq_info->desc_list_entry_size) / 8);
> 
>          io_sq->tail++;
> 
> @@ -102,16 +101,14 @@ static int ena_com_write_header_to_bounce(struct ena_com_io_sq *io_sq,
>          header_offset =
>                  llq_info->descs_num_before_header * io_sq->desc_entry_size;
> 
> -       if (unlikely((header_offset + header_len) >
> -                    llq_info->desc_list_entry_size)) {
> +       if (unlikely((header_offset + header_len) > llq_info->desc_list_entry_size)) {
>                  netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
>                             "Trying to write header larger than llq entry can accommodate\n");
>                  return -EFAULT;
>          }
> 
>          if (unlikely(!bounce_buffer)) {
> -               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                          "Bounce buffer is NULL\n");
> +               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device, "Bounce buffer is NULL\n");
>                  return -EFAULT;
>          }
> 
> @@ -129,8 +126,7 @@ static void *get_sq_desc_llq(struct ena_com_io_sq *io_sq)
>          bounce_buffer = pkt_ctrl->curr_bounce_buf;
> 
>          if (unlikely(!bounce_buffer)) {
> -               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                          "Bounce buffer is NULL\n");
> +               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device, "Bounce buffer is NULL\n");
>                  return NULL;
>          }
> 
> @@ -247,8 +243,7 @@ static u16 ena_com_cdesc_rx_pkt_get(struct ena_com_io_cq *io_cq,
> 
>                  ena_com_cq_inc_head(io_cq);
>                  count++;
> -               last = (READ_ONCE(cdesc->status) &
> -                       ENA_ETH_IO_RX_CDESC_BASE_LAST_MASK) >>
> +               last = (READ_ONCE(cdesc->status) & ENA_ETH_IO_RX_CDESC_BASE_LAST_MASK) >>
>                         ENA_ETH_IO_RX_CDESC_BASE_LAST_SHIFT;
>          } while (!last);
> 
> @@ -369,9 +364,8 @@ static void ena_com_rx_set_flags(struct ena_com_io_cq *io_cq,
> 
>          netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
>                     "l3_proto %d l4_proto %d l3_csum_err %d l4_csum_err %d hash %d frag %d cdesc_status %x\n",
> -                  ena_rx_ctx->l3_proto, ena_rx_ctx->l4_proto,
> -                  ena_rx_ctx->l3_csum_err, ena_rx_ctx->l4_csum_err,
> -                  ena_rx_ctx->hash, ena_rx_ctx->frag, cdesc->status);
> +                  ena_rx_ctx->l3_proto, ena_rx_ctx->l4_proto, ena_rx_ctx->l3_csum_err,
> +                  ena_rx_ctx->l4_csum_err, ena_rx_ctx->hash, ena_rx_ctx->frag, cdesc->status);
>   }
> 
>   /*****************************************************************************/
> @@ -403,13 +397,12 @@ int ena_com_prepare_tx(struct ena_com_io_sq *io_sq,
> 
>          if (unlikely(header_len > io_sq->tx_max_header_size)) {
>                  netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                          "Header size is too large %d max header: %d\n",
> -                          header_len, io_sq->tx_max_header_size);
> +                          "Header size is too large %d max header: %d\n", header_len,
> +                          io_sq->tx_max_header_size);
>                  return -EINVAL;
>          }
> 
> -       if (unlikely(io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV &&
> -                    !buffer_to_push)) {
> +       if (unlikely(io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV && !buffer_to_push)) {
>                  netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
>                             "Push header wasn't provided in LLQ mode\n");
>                  return -EINVAL;
> @@ -556,13 +549,11 @@ int ena_com_rx_pkt(struct ena_com_io_cq *io_cq,
>          }
> 
>          netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> -                  "Fetch rx packet: queue %d completed desc: %d\n", io_cq->qid,
> -                  nb_hw_desc);
> +                  "Fetch rx packet: queue %d completed desc: %d\n", io_cq->qid, nb_hw_desc);
> 
>          if (unlikely(nb_hw_desc > ena_rx_ctx->max_bufs)) {
>                  netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> -                          "Too many RX cdescs (%d) > MAX(%d)\n", nb_hw_desc,
> -                          ena_rx_ctx->max_bufs);
> +                          "Too many RX cdescs (%d) > MAX(%d)\n", nb_hw_desc, ena_rx_ctx->max_bufs);
>                  return -ENOSPC;
>          }
> 
> @@ -586,8 +577,8 @@ int ena_com_rx_pkt(struct ena_com_io_cq *io_cq,
>          io_sq->next_to_comp += nb_hw_desc;
> 
>          netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> -                  "[%s][QID#%d] Updating SQ head to: %d\n", __func__,
> -                  io_sq->qid, io_sq->next_to_comp);
> +                  "[%s][QID#%d] Updating SQ head to: %d\n", __func__, io_sq->qid,
> +                  io_sq->next_to_comp);
> 
>          /* Get rx flags from the last pkt */
>          ena_com_rx_set_flags(io_cq, ena_rx_ctx, cdesc);
> @@ -624,8 +615,8 @@ int ena_com_add_single_rx_desc(struct ena_com_io_sq *io_sq,
>          desc->req_id = req_id;
> 
>          netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                  "[%s] Adding single RX desc, Queue: %u, req_id: %u\n",
> -                  __func__, io_sq->qid, req_id);
> +                  "[%s] Adding single RX desc, Queue: %u, req_id: %u\n", __func__, io_sq->qid,
> +                  req_id);
> 
>          desc->buff_addr_lo = (u32)ena_buf->paddr;
>          desc->buff_addr_hi =
> diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.h b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> index 4d65d82..72b0197 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> +++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> @@ -143,8 +143,8 @@ static inline bool ena_com_is_doorbell_needed(struct ena_com_io_sq *io_sq,
>          }
> 
>          netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                  "Queue: %d num_descs: %d num_entries_needed: %d\n",
> -                  io_sq->qid, num_descs, num_entries_needed);
> +                  "Queue: %d num_descs: %d num_entries_needed: %d\n", io_sq->qid, num_descs,
> +                  num_entries_needed);
> 
>          return num_entries_needed > io_sq->entries_in_tx_burst_left;
>   }
> @@ -155,15 +155,14 @@ static inline int ena_com_write_sq_doorbell(struct ena_com_io_sq *io_sq)
>          u16 tail = io_sq->tail;
> 
>          netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                  "Write submission queue doorbell for queue: %d tail: %d\n",
> -                  io_sq->qid, tail);
> +                  "Write submission queue doorbell for queue: %d tail: %d\n", io_sq->qid, tail);
> 
>          writel(tail, io_sq->db_addr);
> 
>          if (is_llq_max_tx_burst_exists(io_sq)) {
>                  netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> -                          "Reset available entries in tx burst for queue %d to %d\n",
> -                          io_sq->qid, max_entries_in_tx_burst);
> +                          "Reset available entries in tx burst for queue %d to %d\n", io_sq->qid,
> +                          max_entries_in_tx_burst);
>                  io_sq->entries_in_tx_burst_left = max_entries_in_tx_burst;
>          }
> 
> @@ -224,8 +223,8 @@ static inline int ena_com_tx_comp_req_id_get(struct ena_com_io_cq *io_cq,
> 
>          *req_id = READ_ONCE(cdesc->req_id);
>          if (unlikely(*req_id >= io_cq->q_depth)) {
> -               netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> -                          "Invalid req id %d\n", cdesc->req_id);
> +               netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device, "Invalid req id %d\n",
> +                          cdesc->req_id);
>                  return -EINVAL;
>          }
> 
> diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> index ca56dff..526ab3e 100644
> --- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> +++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> @@ -141,11 +141,9 @@ int ena_xmit_common(struct ena_adapter *adapter,
>          if (unlikely(rc)) {
>                  netif_err(adapter, tx_queued, adapter->netdev,
>                            "Failed to prepare tx bufs\n");
> -               ena_increase_stat(&ring->tx_stats.prepare_ctx_err, 1,
> -                                 &ring->syncp);
> +               ena_increase_stat(&ring->tx_stats.prepare_ctx_err, 1, &ring->syncp);
>                  if (rc != -ENOMEM)
> -                       ena_reset_device(adapter,
> -                                        ENA_REGS_RESET_DRIVER_INVALID_STATE);
> +                       ena_reset_device(adapter, ENA_REGS_RESET_DRIVER_INVALID_STATE);
>                  return rc;
>          }
> 
> @@ -510,8 +508,7 @@ static struct page *ena_alloc_map_page(struct ena_ring *rx_ring,
>           */
>          page = dev_alloc_page();
>          if (!page) {
> -               ena_increase_stat(&rx_ring->rx_stats.page_alloc_fail, 1,
> -                                 &rx_ring->syncp);
> +               ena_increase_stat(&rx_ring->rx_stats.page_alloc_fail, 1, &rx_ring->syncp);
>                  return ERR_PTR(-ENOSPC);
>          }
> 
> @@ -570,8 +567,8 @@ static void ena_unmap_rx_buff_attrs(struct ena_ring *rx_ring,
>                                      struct ena_rx_buffer *rx_info,
>                                      unsigned long attrs)
>   {
> -       dma_unmap_page_attrs(rx_ring->dev, rx_info->dma_addr, ENA_PAGE_SIZE,
> -                            DMA_BIDIRECTIONAL, attrs);
> +       dma_unmap_page_attrs(rx_ring->dev, rx_info->dma_addr, ENA_PAGE_SIZE, DMA_BIDIRECTIONAL,
> +                            attrs);
>   }
> 
>   static void ena_free_rx_page(struct ena_ring *rx_ring,
> @@ -844,8 +841,7 @@ static int ena_clean_tx_irq(struct ena_ring *tx_ring, u32 budget)
>                                                  &req_id);
>                  if (rc) {
>                          if (unlikely(rc == -EINVAL))
> -                               handle_invalid_req_id(tx_ring, req_id, NULL,
> -                                                     false);
> +                               handle_invalid_req_id(tx_ring, req_id, NULL, false);
>                          break;
>                  }
> 
> @@ -1070,8 +1066,7 @@ static struct sk_buff *ena_rx_skb(struct ena_ring *rx_ring,
>                                          DMA_FROM_DEVICE);
> 
>                  if (!reuse_rx_buf_page)
> -                       ena_unmap_rx_buff_attrs(rx_ring, rx_info,
> -                                               DMA_ATTR_SKIP_CPU_SYNC);
> +                       ena_unmap_rx_buff_attrs(rx_ring, rx_info, DMA_ATTR_SKIP_CPU_SYNC);
> 
>                  skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, rx_info->page,
>                                  page_offset + buf_offset, len, buf_len);
> @@ -1342,8 +1337,7 @@ error:
>          adapter = netdev_priv(rx_ring->netdev);
> 
>          if (rc == -ENOSPC) {
> -               ena_increase_stat(&rx_ring->rx_stats.bad_desc_num, 1,
> -                                 &rx_ring->syncp);
> +               ena_increase_stat(&rx_ring->rx_stats.bad_desc_num, 1, &rx_ring->syncp);
>                  ena_reset_device(adapter, ENA_REGS_RESET_TOO_MANY_RX_DESCS);
>          } else {
>                  ena_increase_stat(&rx_ring->rx_stats.bad_req_id, 1,
> @@ -1833,8 +1827,7 @@ static int ena_rss_configure(struct ena_adapter *adapter)
>          if (!ena_dev->rss.tbl_log_size) {
>                  rc = ena_rss_init_default(adapter);
>                  if (rc && (rc != -EOPNOTSUPP)) {
> -                       netif_err(adapter, ifup, adapter->netdev,
> -                                 "Failed to init RSS rc: %d\n", rc);
> +                       netif_err(adapter, ifup, adapter->netdev, "Failed to init RSS rc: %d\n", rc);
>                          return rc;
>                  }
>          }
> @@ -2790,8 +2783,7 @@ static void ena_config_debug_area(struct ena_adapter *adapter)
>          rc = ena_com_set_host_attributes(adapter->ena_dev);
>          if (rc) {
>                  if (rc == -EOPNOTSUPP)
> -                       netif_warn(adapter, drv, adapter->netdev,
> -                                  "Cannot set host attributes\n");
> +                       netif_warn(adapter, drv, adapter->netdev, "Cannot set host attributes\n");
>                  else
>                          netif_err(adapter, drv, adapter->netdev,
>                                    "Cannot set host attributes\n");
> @@ -3831,8 +3823,8 @@ static int ena_rss_init_default(struct ena_adapter *adapter)
>                  }
>          }
> 
> -       rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ, NULL,
> -                                       ENA_HASH_KEY_SIZE, 0xFFFFFFFF);
> +       rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ, NULL, ENA_HASH_KEY_SIZE,
> +                                       0xFFFFFFFF);
>          if (unlikely(rc && (rc != -EOPNOTSUPP))) {
>                  dev_err(dev, "Cannot fill hash function\n");
>                  goto err_fill_indir;
> --
> 2.40.1
> 
> 

RE: [PATCH v1 net-next 11/11] net: ena: Reduce lines with longer column width boundary

[Arinzon, David]

> On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> >
> > From: David Arinzon <darinzon@amazon.com>
> >
> > This patch reduces some of the lines by removing newlines
> > where more variables or print strings can be pushed back
> > to the previous line while still adhering to the styling
> > guidelines.
> >
> > Signed-off-by: David Arinzon <darinzon@amazon.com>
> > ---
> >   drivers/net/ethernet/amazon/ena/ena_com.c     | 315 +++++++-----------
> >   drivers/net/ethernet/amazon/ena/ena_eth_com.c |  49 ++-
> >   drivers/net/ethernet/amazon/ena/ena_eth_com.h |  15 +-
> >   drivers/net/ethernet/amazon/ena/ena_netdev.c  |  32 +-
> >   4 files changed, 151 insertions(+), 260 deletions(-)
> >
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c
> b/drivers/net/ethernet/amazon/ena/ena_com.c
> > index 675ee72..9e9e4a0 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_com.c
> > +++ b/drivers/net/ethernet/amazon/ena/ena_com.c
> > @@ -90,8 +90,7 @@ static int ena_com_admin_init_sq(struct
> ena_com_admin_queue *admin_queue)
> >          struct ena_com_admin_sq *sq = &admin_queue->sq;
> >          u16 size = ADMIN_SQ_SIZE(admin_queue->q_depth);
> >
> > -       sq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
> > -                                        &sq->dma_addr, GFP_KERNEL);
> > +       sq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
> &sq->dma_addr, GFP_KERNEL);
> >
> >          if (!sq->entries) {
> >                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
> > @@ -113,8 +112,7 @@ static int ena_com_admin_init_cq(struct
> ena_com_admin_queue *admin_queue)
> >          struct ena_com_admin_cq *cq = &admin_queue->cq;
> >          u16 size = ADMIN_CQ_SIZE(admin_queue->q_depth);
> >
> > -       cq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
> > -                                        &cq->dma_addr, GFP_KERNEL);
> > +       cq->entries = dma_alloc_coherent(admin_queue->q_dmadev, size,
> &cq->dma_addr, GFP_KERNEL);
> >
> >          if (!cq->entries) {
> >                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
> > @@ -136,8 +134,7 @@ static int ena_com_admin_init_aenq(struct
> ena_com_dev *ena_dev,
> >
> >          ena_dev->aenq.q_depth = ENA_ASYNC_QUEUE_DEPTH;
> >          size = ADMIN_AENQ_SIZE(ENA_ASYNC_QUEUE_DEPTH);
> > -       aenq->entries = dma_alloc_coherent(ena_dev->dmadev, size,
> > -                                          &aenq->dma_addr, GFP_KERNEL);
> > +       aenq->entries = dma_alloc_coherent(ena_dev->dmadev, size,
> &aenq->dma_addr, GFP_KERNEL);
> >
> >          if (!aenq->entries) {
> >                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
> > @@ -155,14 +152,13 @@ static int ena_com_admin_init_aenq(struct
> ena_com_dev *ena_dev,
> >
> >          aenq_caps = 0;
> >          aenq_caps |= ena_dev->aenq.q_depth &
> ENA_REGS_AENQ_CAPS_AENQ_DEPTH_MASK;
> > -       aenq_caps |= (sizeof(struct ena_admin_aenq_entry)
> > -                     << ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_SHIFT) &
> > -                    ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_MASK;
> > +       aenq_caps |=
> > +               (sizeof(struct ena_admin_aenq_entry) <<
> ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_SHIFT) &
> > +               ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_MASK;
> 
> This might be better served by using the FIELD_PREP macro
> 

I agree with you, we have a plan to utilize FIELD_GET and FIELD_PREP
macros throughout the code, as there are multiple places that 
look similar to this one and would benefit from this change.
I prefer to address it in a separate patchset at a later stage,
if that's OK with you.

> >          writel(aenq_caps, ena_dev->reg_bar +
> ENA_REGS_AENQ_CAPS_OFF);
> >
> >          if (unlikely(!aenq_handlers)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "AENQ handlers pointer is NULL\n");
> > +               netdev_err(ena_dev->net_device, "AENQ handlers pointer is
> NULL\n");
> >                  return -EINVAL;
> >          }
> >
> > @@ -189,14 +185,12 @@ static struct ena_comp_ctx
> *get_comp_ctxt(struct ena_com_admin_queue *admin_queu
> >          }
> >
> >          if (unlikely(!admin_queue->comp_ctx)) {
> > -               netdev_err(admin_queue->ena_dev->net_device,
> > -                          "Completion context is NULL\n");
> > +               netdev_err(admin_queue->ena_dev->net_device, "Completion
> context is NULL\n");
> >                  return NULL;
> >          }
> >
> >          if (unlikely(admin_queue->comp_ctx[command_id].occupied &&
> capture)) {
> > -               netdev_err(admin_queue->ena_dev->net_device,
> > -                          "Completion context is occupied\n");
> > +               netdev_err(admin_queue->ena_dev->net_device, "Completion
> context is occupied\n");
> >                  return NULL;
> >          }
> >
> > @@ -226,8 +220,7 @@ static struct ena_comp_ctx
> *__ena_com_submit_admin_cmd(struct ena_com_admin_queu
> >          /* In case of queue FULL */
> >          cnt = (u16)atomic_read(&admin_queue->outstanding_cmds);
> >          if (cnt >= admin_queue->q_depth) {
> > -               netdev_dbg(admin_queue->ena_dev->net_device,
> > -                          "Admin queue is full.\n");
> > +               netdev_dbg(admin_queue->ena_dev->net_device, "Admin
> queue is full.\n");
> >                  admin_queue->stats.out_of_space++;
> >                  return ERR_PTR(-ENOSPC);
> >          }
> > @@ -274,8 +267,7 @@ static int ena_com_init_comp_ctxt(struct
> ena_com_admin_queue *admin_queue)
> >          struct ena_comp_ctx *comp_ctx;
> >          u16 i;
> >
> > -       admin_queue->comp_ctx =
> > -               devm_kzalloc(admin_queue->q_dmadev, size, GFP_KERNEL);
> > +       admin_queue->comp_ctx = devm_kzalloc(admin_queue->q_dmadev,
> size, GFP_KERNEL);
> >          if (unlikely(!admin_queue->comp_ctx)) {
> >                  netdev_err(ena_dev->net_device, "Memory allocation failed\n");
> >                  return -ENOMEM;
> > @@ -336,20 +328,17 @@ static int ena_com_init_io_sq(struct
> ena_com_dev *ena_dev,
> >                  dev_node = dev_to_node(ena_dev->dmadev);
> >                  set_dev_node(ena_dev->dmadev, ctx->numa_node);
> >                  io_sq->desc_addr.virt_addr =
> > -                       dma_alloc_coherent(ena_dev->dmadev, size,
> > -                                          &io_sq->desc_addr.phys_addr,
> > +                       dma_alloc_coherent(ena_dev->dmadev, size, &io_sq-
> >desc_addr.phys_addr,
> >                                             GFP_KERNEL);
> >                  set_dev_node(ena_dev->dmadev, dev_node);
> >                  if (!io_sq->desc_addr.virt_addr) {
> >                          io_sq->desc_addr.virt_addr =
> >                                  dma_alloc_coherent(ena_dev->dmadev, size,
> > -                                                  &io_sq->desc_addr.phys_addr,
> > -                                                  GFP_KERNEL);
> > +                                                  &io_sq->desc_addr.phys_addr, GFP_KERNEL);
> >                  }
> >
> >                  if (!io_sq->desc_addr.virt_addr) {
> > -                       netdev_err(ena_dev->net_device,
> > -                                  "Memory allocation failed\n");
> > +                       netdev_err(ena_dev->net_device, "Memory allocation
> failed\n");
> >                          return -ENOMEM;
> >                  }
> >          }
> > @@ -367,16 +356,14 @@ static int ena_com_init_io_sq(struct
> ena_com_dev *ena_dev,
> >
> >                  dev_node = dev_to_node(ena_dev->dmadev);
> >                  set_dev_node(ena_dev->dmadev, ctx->numa_node);
> > -               io_sq->bounce_buf_ctrl.base_buffer =
> > -                       devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
> > +               io_sq->bounce_buf_ctrl.base_buffer = devm_kzalloc(ena_dev-
> >dmadev, size, GFP_KERNEL);
> >                  set_dev_node(ena_dev->dmadev, dev_node);
> >                  if (!io_sq->bounce_buf_ctrl.base_buffer)
> >                          io_sq->bounce_buf_ctrl.base_buffer =
> >                                  devm_kzalloc(ena_dev->dmadev, size, GFP_KERNEL);
> >
> >                  if (!io_sq->bounce_buf_ctrl.base_buffer) {
> > -                       netdev_err(ena_dev->net_device,
> > -                                  "Bounce buffer memory allocation failed\n");
> > +                       netdev_err(ena_dev->net_device, "Bounce buffer memory
> allocation failed\n");
> >                          return -ENOMEM;
> >                  }
> >
> > @@ -425,13 +412,11 @@ static int ena_com_init_io_cq(struct
> ena_com_dev *ena_dev,
> >          prev_node = dev_to_node(ena_dev->dmadev);
> >          set_dev_node(ena_dev->dmadev, ctx->numa_node);
> >          io_cq->cdesc_addr.virt_addr =
> > -               dma_alloc_coherent(ena_dev->dmadev, size,
> > -                                  &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
> > +               dma_alloc_coherent(ena_dev->dmadev, size, &io_cq-
> >cdesc_addr.phys_addr, GFP_KERNEL);
> >          set_dev_node(ena_dev->dmadev, prev_node);
> >          if (!io_cq->cdesc_addr.virt_addr) {
> >                  io_cq->cdesc_addr.virt_addr =
> > -                       dma_alloc_coherent(ena_dev->dmadev, size,
> > -                                          &io_cq->cdesc_addr.phys_addr,
> > +                       dma_alloc_coherent(ena_dev->dmadev, size, &io_cq-
> >cdesc_addr.phys_addr,
> >                                             GFP_KERNEL);
> >          }
> >
> > @@ -514,8 +499,8 @@ static int ena_com_comp_status_to_errno(struct
> ena_com_admin_queue *admin_queue,
> >                                          u8 comp_status)
> >   {
> >          if (unlikely(comp_status != 0))
> > -               netdev_err(admin_queue->ena_dev->net_device,
> > -                          "Admin command failed[%u]\n", comp_status);
> > +               netdev_err(admin_queue->ena_dev->net_device, "Admin
> command failed[%u]\n",
> > +                          comp_status);
> >
> >          switch (comp_status) {
> >          case ENA_ADMIN_SUCCESS:
> > @@ -580,8 +565,7 @@ static int
> ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx
> *comp_c
> >          }
> >
> >          if (unlikely(comp_ctx->status == ENA_CMD_ABORTED)) {
> > -               netdev_err(admin_queue->ena_dev->net_device,
> > -                          "Command was aborted\n");
> > +               netdev_err(admin_queue->ena_dev->net_device, "Command
> was aborted\n");
> >                  spin_lock_irqsave(&admin_queue->q_lock, flags);
> >                  admin_queue->stats.aborted_cmd++;
> >                  spin_unlock_irqrestore(&admin_queue->q_lock, flags);
> > @@ -589,8 +573,7 @@ static int
> ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx
> *comp_c
> >                  goto err;
> >          }
> >
> > -       WARN(comp_ctx->status != ENA_CMD_COMPLETED, "Invalid comp
> status %d\n",
> > -            comp_ctx->status);
> > +       WARN(comp_ctx->status != ENA_CMD_COMPLETED, "Invalid comp
> status %d\n", comp_ctx->status);
> >
> >          ret = ena_com_comp_status_to_errno(admin_queue, comp_ctx-
> >comp_status);
> >   err:
> > @@ -634,8 +617,7 @@ static int ena_com_set_llq(struct ena_com_dev
> *ena_dev)
> >                                              sizeof(resp));
> >
> >          if (unlikely(ret))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to set LLQ configurations: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to set LLQ
> configurations: %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -658,8 +640,7 @@ static int ena_com_config_llq_info(struct
> ena_com_dev *ena_dev,
> >                          llq_default_cfg->llq_header_location;
> >          } else {
> >                  netdev_err(ena_dev->net_device,
> > -                          "Invalid header location control, supported: 0x%x\n",
> > -                          supported_feat);
> > +                          "Invalid header location control, supported: 0x%x\n",
> supported_feat);
> >                  return -EINVAL;
> >          }
> >
> > @@ -681,8 +662,8 @@ static int ena_com_config_llq_info(struct
> ena_com_dev *ena_dev,
> >
> >                          netdev_err(ena_dev->net_device,
> >                                     "Default llq stride ctrl is not supported, performing
> fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
> > -                                  llq_default_cfg->llq_stride_ctrl,
> > -                                  supported_feat, llq_info->desc_stride_ctrl);
> > +                                  llq_default_cfg->llq_stride_ctrl, supported_feat,
> > +                                  llq_info->desc_stride_ctrl);
> 
> Most of these changes make sense, but seem less useful in cases like
> this where the line count doesn't change.
> 
> sln
> 

I understand your point, this is a uniform application of the clang formatter
tool and the penalties applied, given some compromises.
Most of the changes make the code better and more readable, but
there are some corner cases which are ok/reasonable, and I preferred to not
make manual changes and override the output. Let me know what you think.

Thanks!
David

> >                  }
> >          } else {
> >                  llq_info->desc_stride_ctrl = 0;
> > @@ -704,8 +685,7 @@ static int ena_com_config_llq_info(struct
> ena_com_dev *ena_dev,
> >                          llq_info->desc_list_entry_size = 256;
> >                  } else {
> >                          netdev_err(ena_dev->net_device,
> > -                                  "Invalid entry_size_ctrl, supported: 0x%x\n",
> > -                                  supported_feat);
> > +                                  "Invalid entry_size_ctrl, supported: 0x%x\n",
> supported_feat);
> >                          return -EINVAL;
> >                  }
> >
> > @@ -750,8 +730,8 @@ static int ena_com_config_llq_info(struct
> ena_com_dev *ena_dev,
> >
> >                  netdev_err(ena_dev->net_device,
> >                             "Default llq num descs before header is not supported,
> performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
> > -                          llq_default_cfg->llq_num_decs_before_header,
> > -                          supported_feat, llq_info->descs_num_before_header);
> > +                          llq_default_cfg->llq_num_decs_before_header,
> supported_feat,
> > +                          llq_info->descs_num_before_header);
> >          }
> >          /* Check for accelerated queue supported */
> >          llq_accel_mode_get = llq_features->accel_mode.u.get;
> > @@ -767,8 +747,7 @@ static int ena_com_config_llq_info(struct
> ena_com_dev *ena_dev,
> >
> >          rc = ena_com_set_llq(ena_dev);
> >          if (rc)
> > -               netdev_err(ena_dev->net_device,
> > -                          "Cannot set LLQ configuration: %d\n", rc);
> > +               netdev_err(ena_dev->net_device, "Cannot set LLQ configuration:
> %d\n", rc);
> >
> >          return rc;
> >   }
> > @@ -780,8 +759,7 @@ static int
> ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx
> *com
> >          int ret;
> >
> >          wait_for_completion_timeout(&comp_ctx->wait_event,
> > -                                   usecs_to_jiffies(
> > -                                           admin_queue->completion_timeout));
> > +                                   usecs_to_jiffies(admin_queue->completion_timeout));
> >
> >          /* In case the command wasn't completed find out the root cause.
> >           * There might be 2 kinds of errors
> > @@ -797,8 +775,7 @@ static int
> ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx
> *com
> >                  if (comp_ctx->status == ENA_CMD_COMPLETED) {
> >                          netdev_err(admin_queue->ena_dev->net_device,
> >                                     "The ena device sent a completion but the driver didn't
> receive a MSI-X interrupt (cmd %d), autopolling mode is %s\n",
> > -                                  comp_ctx->cmd_opcode,
> > -                                  admin_queue->auto_polling ? "ON" : "OFF");
> > +                                  comp_ctx->cmd_opcode, admin_queue->auto_polling ?
> "ON" : "OFF");
> >                          /* Check if fallback to polling is enabled */
> >                          if (admin_queue->auto_polling)
> >                                  admin_queue->polling = true;
> > @@ -867,15 +844,13 @@ static u32 ena_com_reg_bar_read32(struct
> ena_com_dev *ena_dev, u16 offset)
> >          if (unlikely(i == timeout)) {
> >                  netdev_err(ena_dev->net_device,
> >                             "Reading reg failed for timeout. expected: req id[%u]
> offset[%u] actual: req id[%u] offset[%u]\n",
> > -                          mmio_read->seq_num, offset, read_resp->req_id,
> > -                          read_resp->reg_off);
> > +                          mmio_read->seq_num, offset, read_resp->req_id,
> read_resp->reg_off);
> >                  ret = ENA_MMIO_READ_TIMEOUT;
> >                  goto err;
> >          }
> >
> >          if (read_resp->reg_off != offset) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Read failure: wrong offset provided\n");
> > +               netdev_err(ena_dev->net_device, "Read failure: wrong offset
> provided\n");
> >                  ret = ENA_MMIO_READ_TIMEOUT;
> >          } else {
> >                  ret = read_resp->reg_val;
> > @@ -934,8 +909,7 @@ static int ena_com_destroy_io_sq(struct
> ena_com_dev *ena_dev,
> >                                              sizeof(destroy_resp));
> >
> >          if (unlikely(ret && (ret != -ENODEV)))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to destroy io sq error: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to destroy io sq error:
> %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -949,8 +923,7 @@ static void ena_com_io_queue_free(struct
> ena_com_dev *ena_dev,
> >          if (io_cq->cdesc_addr.virt_addr) {
> >                  size = io_cq->cdesc_entry_size_in_bytes * io_cq->q_depth;
> >
> > -               dma_free_coherent(ena_dev->dmadev, size,
> > -                                 io_cq->cdesc_addr.virt_addr,
> > +               dma_free_coherent(ena_dev->dmadev, size, io_cq-
> >cdesc_addr.virt_addr,
> >                                    io_cq->cdesc_addr.phys_addr);
> >
> >                  io_cq->cdesc_addr.virt_addr = NULL;
> > @@ -959,8 +932,7 @@ static void ena_com_io_queue_free(struct
> ena_com_dev *ena_dev,
> >          if (io_sq->desc_addr.virt_addr) {
> >                  size = io_sq->desc_entry_size * io_sq->q_depth;
> >
> > -               dma_free_coherent(ena_dev->dmadev, size,
> > -                                 io_sq->desc_addr.virt_addr,
> > +               dma_free_coherent(ena_dev->dmadev, size, io_sq-
> >desc_addr.virt_addr,
> >                                    io_sq->desc_addr.phys_addr);
> >
> >                  io_sq->desc_addr.virt_addr = NULL;
> > @@ -985,8 +957,7 @@ static int wait_for_reset_state(struct ena_com_dev
> *ena_dev, u32 timeout,
> >                  val = ena_com_reg_bar_read32(ena_dev,
> ENA_REGS_DEV_STS_OFF);
> >
> >                  if (unlikely(val == ENA_MMIO_READ_TIMEOUT)) {
> > -                       netdev_err(ena_dev->net_device,
> > -                                  "Reg read timeout occurred\n");
> > +                       netdev_err(ena_dev->net_device, "Reg read timeout
> occurred\n");
> >                          return -ETIME;
> >                  }
> >
> > @@ -1026,8 +997,7 @@ static int ena_com_get_feature_ex(struct
> ena_com_dev *ena_dev,
> >          int ret;
> >
> >          if (!ena_com_check_supported_feature_id(ena_dev, feature_id)) {
> > -               netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n",
> > -                          feature_id);
> > +               netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n", feature_id);
> >                  return -EOPNOTSUPP;
> >          }
> >
> > @@ -1064,8 +1034,7 @@ static int ena_com_get_feature_ex(struct
> ena_com_dev *ena_dev,
> >
> >          if (unlikely(ret))
> >                  netdev_err(ena_dev->net_device,
> > -                          "Failed to submit get_feature command %d error: %d\n",
> > -                          feature_id, ret);
> > +                          "Failed to submit get_feature command %d error: %d\n",
> feature_id, ret);
> >
> >          return ret;
> >   }
> > @@ -1104,13 +1073,11 @@ static int ena_com_hash_key_allocate(struct
> ena_com_dev *ena_dev)
> >   {
> >          struct ena_rss *rss = &ena_dev->rss;
> >
> > -       if (!ena_com_check_supported_feature_id(ena_dev,
> > -                                               ENA_ADMIN_RSS_HASH_FUNCTION))
> > +       if (!ena_com_check_supported_feature_id(ena_dev,
> ENA_ADMIN_RSS_HASH_FUNCTION))
> >                  return -EOPNOTSUPP;
> >
> > -       rss->hash_key =
> > -               dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
> > -                                  &rss->hash_key_dma_addr, GFP_KERNEL);
> > +       rss->hash_key = dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss-
> >hash_key),
> > +                                          &rss->hash_key_dma_addr, GFP_KERNEL);
> >
> >          if (unlikely(!rss->hash_key))
> >                  return -ENOMEM;
> > @@ -1123,8 +1090,8 @@ static void ena_com_hash_key_destroy(struct
> ena_com_dev *ena_dev)
> >          struct ena_rss *rss = &ena_dev->rss;
> >
> >          if (rss->hash_key)
> > -               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
> > -                                 rss->hash_key, rss->hash_key_dma_addr);
> > +               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
> rss->hash_key,
> > +                                 rss->hash_key_dma_addr);
> >          rss->hash_key = NULL;
> >   }
> >
> > @@ -1132,9 +1099,8 @@ static int ena_com_hash_ctrl_init(struct
> ena_com_dev *ena_dev)
> >   {
> >          struct ena_rss *rss = &ena_dev->rss;
> >
> > -       rss->hash_ctrl =
> > -               dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
> > -                                  &rss->hash_ctrl_dma_addr, GFP_KERNEL);
> > +       rss->hash_ctrl = dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss-
> >hash_ctrl),
> > +                                           &rss->hash_ctrl_dma_addr, GFP_KERNEL);
> >
> >          if (unlikely(!rss->hash_ctrl))
> >                  return -ENOMEM;
> > @@ -1147,8 +1113,8 @@ static void ena_com_hash_ctrl_destroy(struct
> ena_com_dev *ena_dev)
> >          struct ena_rss *rss = &ena_dev->rss;
> >
> >          if (rss->hash_ctrl)
> > -               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
> > -                                 rss->hash_ctrl, rss->hash_ctrl_dma_addr);
> > +               dma_free_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
> rss->hash_ctrl,
> > +                                 rss->hash_ctrl_dma_addr);
> >          rss->hash_ctrl = NULL;
> >   }
> >
> > @@ -1177,15 +1143,13 @@ static int
> ena_com_indirect_table_allocate(struct ena_com_dev *ena_dev,
> >          tbl_size = (1ULL << log_size) *
> >                  sizeof(struct ena_admin_rss_ind_table_entry);
> >
> > -       rss->rss_ind_tbl =
> > -               dma_alloc_coherent(ena_dev->dmadev, tbl_size,
> > -                                  &rss->rss_ind_tbl_dma_addr, GFP_KERNEL);
> > +       rss->rss_ind_tbl = dma_alloc_coherent(ena_dev->dmadev, tbl_size,
> &rss->rss_ind_tbl_dma_addr,
> > +                                             GFP_KERNEL);
> >          if (unlikely(!rss->rss_ind_tbl))
> >                  goto mem_err1;
> >
> >          tbl_size = (1ULL << log_size) * sizeof(u16);
> > -       rss->host_rss_ind_tbl =
> > -               devm_kzalloc(ena_dev->dmadev, tbl_size, GFP_KERNEL);
> > +       rss->host_rss_ind_tbl = devm_kzalloc(ena_dev->dmadev, tbl_size,
> GFP_KERNEL);
> >          if (unlikely(!rss->host_rss_ind_tbl))
> >                  goto mem_err2;
> >
> > @@ -1197,8 +1161,7 @@ mem_err2:
> >          tbl_size = (1ULL << log_size) *
> >                  sizeof(struct ena_admin_rss_ind_table_entry);
> >
> > -       dma_free_coherent(ena_dev->dmadev, tbl_size, rss->rss_ind_tbl,
> > -                         rss->rss_ind_tbl_dma_addr);
> > +       dma_free_coherent(ena_dev->dmadev, tbl_size, rss->rss_ind_tbl,
> rss->rss_ind_tbl_dma_addr);
> >          rss->rss_ind_tbl = NULL;
> >   mem_err1:
> >          rss->tbl_log_size = 0;
> > @@ -1261,8 +1224,7 @@ static int ena_com_create_io_sq(struct
> ena_com_dev *ena_dev,
> >                                             &create_cmd.sq_ba,
> >                                             io_sq->desc_addr.phys_addr);
> >                  if (unlikely(ret)) {
> > -                       netdev_err(ena_dev->net_device,
> > -                                  "Memory address set failed\n");
> > +                       netdev_err(ena_dev->net_device, "Memory address set
> failed\n");
> >                          return ret;
> >                  }
> >          }
> > @@ -1273,8 +1235,7 @@ static int ena_com_create_io_sq(struct
> ena_com_dev *ena_dev,
> >                                              (struct ena_admin_acq_entry *)&cmd_completion,
> >                                              sizeof(cmd_completion));
> >          if (unlikely(ret)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to create IO SQ. error: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to create IO SQ. error:
> %d\n", ret);
> >                  return ret;
> >          }
> >
> > @@ -1289,8 +1250,7 @@ static int ena_com_create_io_sq(struct
> ena_com_dev *ena_dev,
> >                          cmd_completion.llq_descriptors_offset);
> >          }
> >
> > -       netdev_dbg(ena_dev->net_device, "Created sq[%u], depth[%u]\n",
> > -                  io_sq->idx, io_sq->q_depth);
> > +       netdev_dbg(ena_dev->net_device, "Created sq[%u], depth[%u]\n",
> io_sq->idx, io_sq->q_depth);
> >
> >          return ret;
> >   }
> > @@ -1417,8 +1377,7 @@ int ena_com_create_io_cq(struct ena_com_dev
> *ena_dev,
> >                                              (struct ena_admin_acq_entry *)&cmd_completion,
> >                                              sizeof(cmd_completion));
> >          if (unlikely(ret)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to create IO CQ. error: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to create IO CQ. error:
> %d\n", ret);
> >                  return ret;
> >          }
> >
> > @@ -1432,8 +1391,7 @@ int ena_com_create_io_cq(struct ena_com_dev
> *ena_dev,
> >                          (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
> >                          cmd_completion.numa_node_register_offset);
> >
> > -       netdev_dbg(ena_dev->net_device, "Created cq[%u], depth[%u]\n",
> > -                  io_cq->idx, io_cq->q_depth);
> > +       netdev_dbg(ena_dev->net_device, "Created cq[%u], depth[%u]\n",
> io_cq->idx, io_cq->q_depth);
> >
> >          return ret;
> >   }
> > @@ -1443,8 +1401,7 @@ int ena_com_get_io_handlers(struct
> ena_com_dev *ena_dev, u16 qid,
> >                              struct ena_com_io_cq **io_cq)
> >   {
> >          if (qid >= ENA_TOTAL_NUM_QUEUES) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Invalid queue number %d but the max is %d\n", qid,
> > +               netdev_err(ena_dev->net_device, "Invalid queue number %d but
> the max is %d\n", qid,
> >                             ENA_TOTAL_NUM_QUEUES);
> >                  return -EINVAL;
> >          }
> > @@ -1484,8 +1441,7 @@ void ena_com_wait_for_abort_completion(struct
> ena_com_dev *ena_dev)
> >          spin_lock_irqsave(&admin_queue->q_lock, flags);
> >          while (atomic_read(&admin_queue->outstanding_cmds) != 0) {
> >                  spin_unlock_irqrestore(&admin_queue->q_lock, flags);
> > -               ena_delay_exponential_backoff_us(exp++,
> > -                                                ena_dev->ena_min_poll_delay_us);
> > +               ena_delay_exponential_backoff_us(exp++, ena_dev-
> >ena_min_poll_delay_us);
> >                  spin_lock_irqsave(&admin_queue->q_lock, flags);
> >          }
> >          spin_unlock_irqrestore(&admin_queue->q_lock, flags);
> > @@ -1511,8 +1467,7 @@ int ena_com_destroy_io_cq(struct ena_com_dev
> *ena_dev,
> >                                              sizeof(destroy_resp));
> >
> >          if (unlikely(ret && (ret != -ENODEV)))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to destroy IO CQ. error: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to destroy IO CQ. error:
> %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -1580,8 +1535,7 @@ int ena_com_set_aenq_config(struct
> ena_com_dev *ena_dev, u32 groups_flag)
> >                                              sizeof(resp));
> >
> >          if (unlikely(ret))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to config AENQ ret: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to config AENQ ret:
> %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -1602,8 +1556,7 @@ int ena_com_get_dma_width(struct
> ena_com_dev *ena_dev)
> >          netdev_dbg(ena_dev->net_device, "ENA dma width: %d\n", width);
> >
> >          if ((width < 32) || width > ENA_MAX_PHYS_ADDR_SIZE_BITS) {
> > -               netdev_err(ena_dev->net_device, "DMA width illegal value:
> %d\n",
> > -                          width);
> > +               netdev_err(ena_dev->net_device, "DMA width illegal value:
> %d\n", width);
> >                  return -EINVAL;
> >          }
> >
> > @@ -1625,19 +1578,16 @@ int ena_com_validate_version(struct
> ena_com_dev *ena_dev)
> >          ctrl_ver = ena_com_reg_bar_read32(ena_dev,
> >                                            ENA_REGS_CONTROLLER_VERSION_OFF);
> >
> > -       if (unlikely((ver == ENA_MMIO_READ_TIMEOUT) ||
> > -                    (ctrl_ver == ENA_MMIO_READ_TIMEOUT))) {
> > +       if (unlikely((ver == ENA_MMIO_READ_TIMEOUT) || (ctrl_ver ==
> ENA_MMIO_READ_TIMEOUT))) {
> >                  netdev_err(ena_dev->net_device, "Reg read timeout
> occurred\n");
> >                  return -ETIME;
> >          }
> >
> >          dev_info(ena_dev->dmadev, "ENA device version: %d.%d\n",
> > -                (ver & ENA_REGS_VERSION_MAJOR_VERSION_MASK) >>
> > -                        ENA_REGS_VERSION_MAJOR_VERSION_SHIFT,
> > +                (ver & ENA_REGS_VERSION_MAJOR_VERSION_MASK) >>
> ENA_REGS_VERSION_MAJOR_VERSION_SHIFT,
> >                   ver & ENA_REGS_VERSION_MINOR_VERSION_MASK);
> >
> > -       dev_info(ena_dev->dmadev,
> > -                "ENA controller version: %d.%d.%d implementation version
> %d\n",
> > +       dev_info(ena_dev->dmadev, "ENA controller version: %d.%d.%d
> implementation version %d\n",
> >                   (ctrl_ver &
> ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_MASK) >>
> >                           ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_SHIFT,
> >                   (ctrl_ver &
> ENA_REGS_CONTROLLER_VERSION_MINOR_VERSION_MASK) >>
> > @@ -1686,20 +1636,17 @@ void ena_com_admin_destroy(struct
> ena_com_dev *ena_dev)
> >
> >          size = ADMIN_SQ_SIZE(admin_queue->q_depth);
> >          if (sq->entries)
> > -               dma_free_coherent(ena_dev->dmadev, size, sq->entries,
> > -                                 sq->dma_addr);
> > +               dma_free_coherent(ena_dev->dmadev, size, sq->entries, sq-
> >dma_addr);
> >          sq->entries = NULL;
> >
> >          size = ADMIN_CQ_SIZE(admin_queue->q_depth);
> >          if (cq->entries)
> > -               dma_free_coherent(ena_dev->dmadev, size, cq->entries,
> > -                                 cq->dma_addr);
> > +               dma_free_coherent(ena_dev->dmadev, size, cq->entries, cq-
> >dma_addr);
> >          cq->entries = NULL;
> >
> >          size = ADMIN_AENQ_SIZE(aenq->q_depth);
> >          if (ena_dev->aenq.entries)
> > -               dma_free_coherent(ena_dev->dmadev, size, aenq->entries,
> > -                                 aenq->dma_addr);
> > +               dma_free_coherent(ena_dev->dmadev, size, aenq->entries,
> aenq->dma_addr);
> >          aenq->entries = NULL;
> >   }
> >
> > @@ -1725,10 +1672,8 @@ int
> ena_com_mmio_reg_read_request_init(struct ena_com_dev *ena_dev)
> >          struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
> >
> >          spin_lock_init(&mmio_read->lock);
> > -       mmio_read->read_resp =
> > -               dma_alloc_coherent(ena_dev->dmadev,
> > -                                  sizeof(*mmio_read->read_resp),
> > -                                  &mmio_read->read_resp_dma_addr, GFP_KERNEL);
> > +       mmio_read->read_resp = dma_alloc_coherent(ena_dev->dmadev,
> sizeof(*mmio_read->read_resp),
> > +                                                 &mmio_read->read_resp_dma_addr,
> GFP_KERNEL);
> >          if (unlikely(!mmio_read->read_resp))
> >                  goto err;
> >
> > @@ -1759,8 +1704,8 @@ void
> ena_com_mmio_reg_read_request_destroy(struct ena_com_dev
> *ena_dev)
> >          writel(0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_LO_OFF);
> >          writel(0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_HI_OFF);
> >
> > -       dma_free_coherent(ena_dev->dmadev, sizeof(*mmio_read-
> >read_resp),
> > -                         mmio_read->read_resp, mmio_read-
> >read_resp_dma_addr);
> > +       dma_free_coherent(ena_dev->dmadev, sizeof(*mmio_read-
> >read_resp), mmio_read->read_resp,
> > +                         mmio_read->read_resp_dma_addr);
> >
> >          mmio_read->read_resp = NULL;
> >   }
> > @@ -1792,8 +1737,7 @@ int ena_com_admin_init(struct ena_com_dev
> *ena_dev,
> >          }
> >
> >          if (!(dev_sts & ENA_REGS_DEV_STS_READY_MASK)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Device isn't ready, abort com init\n");
> > +               netdev_err(ena_dev->net_device, "Device isn't ready, abort com
> init\n");
> >                  return -ENODEV;
> >          }
> >
> > @@ -1870,8 +1814,7 @@ int ena_com_create_io_queue(struct
> ena_com_dev *ena_dev,
> >          int ret;
> >
> >          if (ctx->qid >= ENA_TOTAL_NUM_QUEUES) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Qid (%d) is bigger than max num of queues (%d)\n",
> > +               netdev_err(ena_dev->net_device, "Qid (%d) is bigger than max
> num of queues (%d)\n",
> >                             ctx->qid, ENA_TOTAL_NUM_QUEUES);
> >                  return -EINVAL;
> >          }
> > @@ -1897,8 +1840,7 @@ int ena_com_create_io_queue(struct
> ena_com_dev *ena_dev,
> >
> >          if (ctx->direction == ENA_COM_IO_QUEUE_DIRECTION_TX)
> >                  /* header length is limited to 8 bits */
> > -               io_sq->tx_max_header_size =
> > -                       min_t(u32, ena_dev->tx_max_header_size, SZ_256);
> > +               io_sq->tx_max_header_size = min_t(u32, ena_dev-
> >tx_max_header_size, SZ_256);
> >
> >          ret = ena_com_init_io_sq(ena_dev, ctx, io_sq);
> >          if (ret)
> > @@ -1930,8 +1872,7 @@ void ena_com_destroy_io_queue(struct
> ena_com_dev *ena_dev, u16 qid)
> >          struct ena_com_io_cq *io_cq;
> >
> >          if (qid >= ENA_TOTAL_NUM_QUEUES) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Qid (%d) is bigger than max num of queues (%d)\n",
> > +               netdev_err(ena_dev->net_device, "Qid (%d) is bigger than max
> num of queues (%d)\n",
> >                             qid, ENA_TOTAL_NUM_QUEUES);
> >                  return;
> >          }
> > @@ -1975,8 +1916,7 @@ int ena_com_get_dev_attr_feat(struct
> ena_com_dev *ena_dev,
> >                  if (rc)
> >                          return rc;
> >
> > -               if (get_resp.u.max_queue_ext.version !=
> > -                   ENA_FEATURE_MAX_QUEUE_EXT_VER)
> > +               if (get_resp.u.max_queue_ext.version !=
> ENA_FEATURE_MAX_QUEUE_EXT_VER)
> >                          return -EINVAL;
> >
> >                  memcpy(&get_feat_ctx->max_queue_ext,
> &get_resp.u.max_queue_ext,
> > @@ -2017,18 +1957,15 @@ int ena_com_get_dev_attr_feat(struct
> ena_com_dev *ena_dev,
> >          rc = ena_com_get_feature(ena_dev, &get_resp,
> ENA_ADMIN_HW_HINTS, 0);
> >
> >          if (!rc)
> > -               memcpy(&get_feat_ctx->hw_hints, &get_resp.u.hw_hints,
> > -                      sizeof(get_resp.u.hw_hints));
> > +               memcpy(&get_feat_ctx->hw_hints, &get_resp.u.hw_hints,
> sizeof(get_resp.u.hw_hints));
> >          else if (rc == -EOPNOTSUPP)
> > -               memset(&get_feat_ctx->hw_hints, 0x0,
> > -                      sizeof(get_feat_ctx->hw_hints));
> > +               memset(&get_feat_ctx->hw_hints, 0x0, sizeof(get_feat_ctx-
> >hw_hints));
> >          else
> >                  return rc;
> >
> >          rc = ena_com_get_feature(ena_dev, &get_resp, ENA_ADMIN_LLQ,
> 0);
> >          if (!rc)
> > -               memcpy(&get_feat_ctx->llq, &get_resp.u.llq,
> > -                      sizeof(get_resp.u.llq));
> > +               memcpy(&get_feat_ctx->llq, &get_resp.u.llq,
> sizeof(get_resp.u.llq));
> >          else if (rc == -EOPNOTSUPP)
> >                  memset(&get_feat_ctx->llq, 0x0, sizeof(get_feat_ctx->llq));
> >          else
> > @@ -2076,8 +2013,7 @@ void ena_com_aenq_intr_handler(struct
> ena_com_dev *ena_dev, void *data)
> >          aenq_common = &aenq_e->aenq_common_desc;
> >
> >          /* Go over all the events */
> > -       while ((READ_ONCE(aenq_common->flags) &
> > -               ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
> > +       while ((READ_ONCE(aenq_common->flags) &
> ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
> >                  /* Make sure the phase bit (ownership) is as expected before
> >                   * reading the rest of the descriptor.
> >                   */
> > @@ -2086,8 +2022,7 @@ void ena_com_aenq_intr_handler(struct
> ena_com_dev *ena_dev, void *data)
> >                  timestamp = (u64)aenq_common->timestamp_low |
> >                          ((u64)aenq_common->timestamp_high << 32);
> >
> > -               netdev_dbg(ena_dev->net_device,
> > -                          "AENQ! Group[%x] Syndrome[%x] timestamp: [%llus]\n",
> > +               netdev_dbg(ena_dev->net_device, "AENQ! Group[%x]
> Syndrome[%x] timestamp: [%llus]\n",
> >                             aenq_common->group, aenq_common->syndrome,
> timestamp);
> >
> >                  /* Handle specific event*/
> > @@ -2116,8 +2051,7 @@ void ena_com_aenq_intr_handler(struct
> ena_com_dev *ena_dev, void *data)
> >
> >          /* write the aenq doorbell after all AENQ descriptors were read */
> >          mb();
> > -       writel_relaxed((u32)aenq->head,
> > -                      ena_dev->reg_bar + ENA_REGS_AENQ_HEAD_DB_OFF);
> > +       writel_relaxed((u32)aenq->head, ena_dev->reg_bar +
> ENA_REGS_AENQ_HEAD_DB_OFF);
> >   }
> >
> >   int ena_com_dev_reset(struct ena_com_dev *ena_dev,
> > @@ -2129,15 +2063,13 @@ int ena_com_dev_reset(struct ena_com_dev
> *ena_dev,
> >          stat = ena_com_reg_bar_read32(ena_dev,
> ENA_REGS_DEV_STS_OFF);
> >          cap = ena_com_reg_bar_read32(ena_dev, ENA_REGS_CAPS_OFF);
> >
> > -       if (unlikely((stat == ENA_MMIO_READ_TIMEOUT) ||
> > -                    (cap == ENA_MMIO_READ_TIMEOUT))) {
> > +       if (unlikely((stat == ENA_MMIO_READ_TIMEOUT) || (cap ==
> ENA_MMIO_READ_TIMEOUT))) {
> >                  netdev_err(ena_dev->net_device, "Reg read32 timeout
> occurred\n");
> >                  return -ETIME;
> >          }
> >
> >          if ((stat & ENA_REGS_DEV_STS_READY_MASK) == 0) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Device isn't ready, can't reset device\n");
> > +               netdev_err(ena_dev->net_device, "Device isn't ready, can't reset
> device\n");
> >                  return -EINVAL;
> >          }
> >
> > @@ -2160,8 +2092,7 @@ int ena_com_dev_reset(struct ena_com_dev
> *ena_dev,
> >          rc = wait_for_reset_state(ena_dev, timeout,
> >                                    ENA_REGS_DEV_STS_RESET_IN_PROGRESS_MASK);
> >          if (rc != 0) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Reset indication didn't turn on\n");
> > +               netdev_err(ena_dev->net_device, "Reset indication didn't turn
> on\n");
> >                  return rc;
> >          }
> >
> > @@ -2169,8 +2100,7 @@ int ena_com_dev_reset(struct ena_com_dev
> *ena_dev,
> >          writel(0, ena_dev->reg_bar + ENA_REGS_DEV_CTL_OFF);
> >          rc = wait_for_reset_state(ena_dev, timeout, 0);
> >          if (rc != 0) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Reset indication didn't turn off\n");
> > +               netdev_err(ena_dev->net_device, "Reset indication didn't turn
> off\n");
> >                  return rc;
> >          }
> >
> > @@ -2207,8 +2137,7 @@ static int ena_get_dev_stats(struct ena_com_dev
> *ena_dev,
> >                                               sizeof(*get_resp));
> >
> >          if (unlikely(ret))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to get stats. error: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to get stats. error:
> %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -2220,8 +2149,7 @@ int ena_com_get_eni_stats(struct ena_com_dev
> *ena_dev,
> >          int ret;
> >
> >          if (!ena_com_get_cap(ena_dev, ENA_ADMIN_ENI_STATS)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Capability %d isn't supported\n",
> > +               netdev_err(ena_dev->net_device, "Capability %d isn't
> supported\n",
> >                             ENA_ADMIN_ENI_STATS);
> >                  return -EOPNOTSUPP;
> >          }
> > @@ -2258,8 +2186,7 @@ int ena_com_set_dev_mtu(struct ena_com_dev
> *ena_dev, u32 mtu)
> >          int ret;
> >
> >          if (!ena_com_check_supported_feature_id(ena_dev,
> ENA_ADMIN_MTU)) {
> > -               netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n",
> > -                          ENA_ADMIN_MTU);
> > +               netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n", ENA_ADMIN_MTU);
> >                  return -EOPNOTSUPP;
> >          }
> >
> > @@ -2278,8 +2205,7 @@ int ena_com_set_dev_mtu(struct ena_com_dev
> *ena_dev, u32 mtu)
> >                                              sizeof(resp));
> >
> >          if (unlikely(ret))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to set mtu %d. error: %d\n", mtu, ret);
> > +               netdev_err(ena_dev->net_device, "Failed to set mtu %d. error:
> %d\n", mtu, ret);
> >
> >          return ret;
> >   }
> > @@ -2293,8 +2219,7 @@ int ena_com_get_offload_settings(struct
> ena_com_dev *ena_dev,
> >          ret = ena_com_get_feature(ena_dev, &resp,
> >                                    ENA_ADMIN_STATELESS_OFFLOAD_CONFIG, 0);
> >          if (unlikely(ret)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to get offload capabilities %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to get offload
> capabilities %d\n", ret);
> >                  return ret;
> >          }
> >
> > @@ -2312,8 +2237,7 @@ int ena_com_set_hash_function(struct
> ena_com_dev *ena_dev)
> >          struct ena_admin_get_feat_resp get_resp;
> >          int ret;
> >
> > -       if (!ena_com_check_supported_feature_id(ena_dev,
> > -                                               ENA_ADMIN_RSS_HASH_FUNCTION)) {
> > +       if (!ena_com_check_supported_feature_id(ena_dev,
> ENA_ADMIN_RSS_HASH_FUNCTION)) {
> >                  netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n",
> >                             ENA_ADMIN_RSS_HASH_FUNCTION);
> >                  return -EOPNOTSUPP;
> > @@ -2326,8 +2250,7 @@ int ena_com_set_hash_function(struct
> ena_com_dev *ena_dev)
> >                  return ret;
> >
> >          if (!(get_resp.u.flow_hash_func.supported_func & BIT(rss-
> >hash_func))) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Func hash %d isn't supported by device, abort\n",
> > +               netdev_err(ena_dev->net_device, "Func hash %d isn't supported
> by device, abort\n",
> >                             rss->hash_func);
> >                  return -EOPNOTSUPP;
> >          }
> > @@ -2357,8 +2280,7 @@ int ena_com_set_hash_function(struct
> ena_com_dev *ena_dev)
> >                                              (struct ena_admin_acq_entry *)&resp,
> >                                              sizeof(resp));
> >          if (unlikely(ret)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to set hash function %d. error: %d\n",
> > +               netdev_err(ena_dev->net_device, "Failed to set hash function
> %d. error: %d\n",
> >                             rss->hash_func, ret);
> >                  return -EINVAL;
> >          }
> > @@ -2390,16 +2312,15 @@ int ena_com_fill_hash_function(struct
> ena_com_dev *ena_dev,
> >                  return rc;
> >
> >          if (!(BIT(func) & get_resp.u.flow_hash_func.supported_func)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Flow hash function %d isn't supported\n", func);
> > +               netdev_err(ena_dev->net_device, "Flow hash function %d isn't
> supported\n", func);
> >                  return -EOPNOTSUPP;
> >          }
> >
> >          if ((func == ENA_ADMIN_TOEPLITZ) && key) {
> >                  if (key_len != sizeof(hash_key->key)) {
> >                          netdev_err(ena_dev->net_device,
> > -                                  "key len (%u) doesn't equal the supported size (%zu)\n",
> > -                                  key_len, sizeof(hash_key->key));
> > +                                  "key len (%u) doesn't equal the supported size (%zu)\n",
> key_len,
> > +                                  sizeof(hash_key->key));
> >                          return -EINVAL;
> >                  }
> >                  memcpy(hash_key->key, key, key_len);
> > @@ -2487,8 +2408,7 @@ int ena_com_set_hash_ctrl(struct ena_com_dev
> *ena_dev)
> >          struct ena_admin_set_feat_resp resp;
> >          int ret;
> >
> > -       if (!ena_com_check_supported_feature_id(ena_dev,
> > -                                               ENA_ADMIN_RSS_HASH_INPUT)) {
> > +       if (!ena_com_check_supported_feature_id(ena_dev,
> ENA_ADMIN_RSS_HASH_INPUT)) {
> >                  netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n",
> >                             ENA_ADMIN_RSS_HASH_INPUT);
> >                  return -EOPNOTSUPP;
> > @@ -2519,8 +2439,7 @@ int ena_com_set_hash_ctrl(struct ena_com_dev
> *ena_dev)
> >                                              (struct ena_admin_acq_entry *)&resp,
> >                                              sizeof(resp));
> >          if (unlikely(ret))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to set hash input. error: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to set hash input.
> error: %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -2597,8 +2516,7 @@ int ena_com_fill_hash_ctrl(struct ena_com_dev
> *ena_dev,
> >          int rc;
> >
> >          if (proto >= ENA_ADMIN_RSS_PROTO_NUM) {
> > -               netdev_err(ena_dev->net_device, "Invalid proto num (%u)\n",
> > -                          proto);
> > +               netdev_err(ena_dev->net_device, "Invalid proto num (%u)\n",
> proto);
> >                  return -EINVAL;
> >          }
> >
> > @@ -2650,8 +2568,7 @@ int ena_com_indirect_table_set(struct
> ena_com_dev *ena_dev)
> >          struct ena_admin_set_feat_resp resp;
> >          int ret;
> >
> > -       if (!ena_com_check_supported_feature_id(
> > -                   ena_dev, ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG)) {
> > +       if (!ena_com_check_supported_feature_id(ena_dev,
> ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG)) {
> >                  netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n",
> >                             ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG);
> >                  return -EOPNOTSUPP;
> > @@ -2691,8 +2608,7 @@ int ena_com_indirect_table_set(struct
> ena_com_dev *ena_dev)
> >                                              sizeof(resp));
> >
> >          if (unlikely(ret))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to set indirect table. error: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to set indirect table.
> error: %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -2771,9 +2687,8 @@ int ena_com_allocate_host_info(struct
> ena_com_dev *ena_dev)
> >   {
> >          struct ena_host_attribute *host_attr = &ena_dev->host_attr;
> >
> > -       host_attr->host_info =
> > -               dma_alloc_coherent(ena_dev->dmadev, SZ_4K,
> > -                                  &host_attr->host_info_dma_addr, GFP_KERNEL);
> > +       host_attr->host_info = dma_alloc_coherent(ena_dev->dmadev,
> SZ_4K,
> > +                                                 &host_attr->host_info_dma_addr,
> GFP_KERNEL);
> >          if (unlikely(!host_attr->host_info))
> >                  return -ENOMEM;
> >
> > @@ -2819,8 +2734,7 @@ void ena_com_delete_debug_area(struct
> ena_com_dev *ena_dev)
> >
> >          if (host_attr->debug_area_virt_addr) {
> >                  dma_free_coherent(ena_dev->dmadev, host_attr-
> >debug_area_size,
> > -                                 host_attr->debug_area_virt_addr,
> > -                                 host_attr->debug_area_dma_addr);
> > +                                 host_attr->debug_area_virt_addr, host_attr-
> >debug_area_dma_addr);
> >                  host_attr->debug_area_virt_addr = NULL;
> >          }
> >   }
> > @@ -2869,8 +2783,7 @@ int ena_com_set_host_attributes(struct
> ena_com_dev *ena_dev)
> >                                              sizeof(resp));
> >
> >          if (unlikely(ret))
> > -               netdev_err(ena_dev->net_device,
> > -                          "Failed to set host attributes: %d\n", ret);
> > +               netdev_err(ena_dev->net_device, "Failed to set host attributes:
> %d\n", ret);
> >
> >          return ret;
> >   }
> > @@ -2888,8 +2801,7 @@ static int
> ena_com_update_nonadaptive_moderation_interval(struct ena_com_dev
> *en
> >                                                            u32 *intr_moder_interval)
> >   {
> >          if (!intr_delay_resolution) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "Illegal interrupt delay granularity value\n");
> > +               netdev_err(ena_dev->net_device, "Illegal interrupt delay
> granularity value\n");
> >                  return -EFAULT;
> >          }
> >
> > @@ -2927,14 +2839,12 @@ int ena_com_init_interrupt_moderation(struct
> ena_com_dev *ena_dev)
> >
> >          if (rc) {
> >                  if (rc == -EOPNOTSUPP) {
> > -                       netdev_dbg(ena_dev->net_device,
> > -                                  "Feature %d isn't supported\n",
> > +                       netdev_dbg(ena_dev->net_device, "Feature %d isn't
> supported\n",
> >                                     ENA_ADMIN_INTERRUPT_MODERATION);
> >                          rc = 0;
> >                  } else {
> >                          netdev_err(ena_dev->net_device,
> > -                                  "Failed to get interrupt moderation admin cmd. rc: %d\n",
> > -                                  rc);
> > +                                  "Failed to get interrupt moderation admin cmd. rc:
> %d\n", rc);
> >                  }
> >
> >                  /* no moderation supported, disable adaptive support */
> > @@ -2982,8 +2892,7 @@ int ena_com_config_dev_mode(struct
> ena_com_dev *ena_dev,
> >                  (llq_info->descs_num_before_header * sizeof(struct
> ena_eth_io_tx_desc));
> >
> >          if (unlikely(ena_dev->tx_max_header_size == 0)) {
> > -               netdev_err(ena_dev->net_device,
> > -                          "The size of the LLQ entry is smaller than needed\n");
> > +               netdev_err(ena_dev->net_device, "The size of the LLQ entry is
> smaller than needed\n");
> >                  return -EINVAL;
> >          }
> >
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.c
> b/drivers/net/ethernet/amazon/ena/ena_eth_com.c
> > index f9f8862..933e619 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_eth_com.c
> > +++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.c
> > @@ -18,8 +18,7 @@ static struct ena_eth_io_rx_cdesc_base
> *ena_com_get_next_rx_cdesc(
> >          cdesc = (struct ena_eth_io_rx_cdesc_base *)(io_cq-
> >cdesc_addr.virt_addr
> >                          + (head_masked * io_cq->cdesc_entry_size_in_bytes));
> >
> > -       desc_phase = (READ_ONCE(cdesc->status) &
> > -                     ENA_ETH_IO_RX_CDESC_BASE_PHASE_MASK) >>
> > +       desc_phase = (READ_ONCE(cdesc->status) &
> ENA_ETH_IO_RX_CDESC_BASE_PHASE_MASK) >>
> >                       ENA_ETH_IO_RX_CDESC_BASE_PHASE_SHIFT;
> >
> >          if (desc_phase != expected_phase)
> > @@ -65,8 +64,8 @@ static int
> ena_com_write_bounce_buffer_to_dev(struct ena_com_io_sq *io_sq,
> >
> >                  io_sq->entries_in_tx_burst_left--;
> >                  netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                          "Decreasing entries_in_tx_burst_left of queue %d to %d\n",
> > -                          io_sq->qid, io_sq->entries_in_tx_burst_left);
> > +                          "Decreasing entries_in_tx_burst_left of queue %d to %d\n",
> io_sq->qid,
> > +                          io_sq->entries_in_tx_burst_left);
> >          }
> >
> >          /* Make sure everything was written into the bounce buffer before
> > @@ -75,8 +74,8 @@ static int
> ena_com_write_bounce_buffer_to_dev(struct ena_com_io_sq *io_sq,
> >          wmb();
> >
> >          /* The line is completed. Copy it to dev */
> > -       __iowrite64_copy(io_sq->desc_addr.pbuf_dev_addr + dst_offset,
> > -                        bounce_buffer, (llq_info->desc_list_entry_size) / 8);
> > +       __iowrite64_copy(io_sq->desc_addr.pbuf_dev_addr + dst_offset,
> bounce_buffer,
> > +                        (llq_info->desc_list_entry_size) / 8);
> >
> >          io_sq->tail++;
> >
> > @@ -102,16 +101,14 @@ static int
> ena_com_write_header_to_bounce(struct ena_com_io_sq *io_sq,
> >          header_offset =
> >                  llq_info->descs_num_before_header * io_sq->desc_entry_size;
> >
> > -       if (unlikely((header_offset + header_len) >
> > -                    llq_info->desc_list_entry_size)) {
> > +       if (unlikely((header_offset + header_len) > llq_info-
> >desc_list_entry_size)) {
> >                  netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> >                             "Trying to write header larger than llq entry can
> accommodate\n");
> >                  return -EFAULT;
> >          }
> >
> >          if (unlikely(!bounce_buffer)) {
> > -               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                          "Bounce buffer is NULL\n");
> > +               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> "Bounce buffer is NULL\n");
> >                  return -EFAULT;
> >          }
> >
> > @@ -129,8 +126,7 @@ static void *get_sq_desc_llq(struct ena_com_io_sq
> *io_sq)
> >          bounce_buffer = pkt_ctrl->curr_bounce_buf;
> >
> >          if (unlikely(!bounce_buffer)) {
> > -               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                          "Bounce buffer is NULL\n");
> > +               netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> "Bounce buffer is NULL\n");
> >                  return NULL;
> >          }
> >
> > @@ -247,8 +243,7 @@ static u16 ena_com_cdesc_rx_pkt_get(struct
> ena_com_io_cq *io_cq,
> >
> >                  ena_com_cq_inc_head(io_cq);
> >                  count++;
> > -               last = (READ_ONCE(cdesc->status) &
> > -                       ENA_ETH_IO_RX_CDESC_BASE_LAST_MASK) >>
> > +               last = (READ_ONCE(cdesc->status) &
> ENA_ETH_IO_RX_CDESC_BASE_LAST_MASK) >>
> >                         ENA_ETH_IO_RX_CDESC_BASE_LAST_SHIFT;
> >          } while (!last);
> >
> > @@ -369,9 +364,8 @@ static void ena_com_rx_set_flags(struct
> ena_com_io_cq *io_cq,
> >
> >          netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> >                     "l3_proto %d l4_proto %d l3_csum_err %d l4_csum_err %d hash
> %d frag %d cdesc_status %x\n",
> > -                  ena_rx_ctx->l3_proto, ena_rx_ctx->l4_proto,
> > -                  ena_rx_ctx->l3_csum_err, ena_rx_ctx->l4_csum_err,
> > -                  ena_rx_ctx->hash, ena_rx_ctx->frag, cdesc->status);
> > +                  ena_rx_ctx->l3_proto, ena_rx_ctx->l4_proto, ena_rx_ctx-
> >l3_csum_err,
> > +                  ena_rx_ctx->l4_csum_err, ena_rx_ctx->hash, ena_rx_ctx->frag,
> cdesc->status);
> >   }
> >
> >
> /**********************************************************
> *******************/
> > @@ -403,13 +397,12 @@ int ena_com_prepare_tx(struct ena_com_io_sq
> *io_sq,
> >
> >          if (unlikely(header_len > io_sq->tx_max_header_size)) {
> >                  netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                          "Header size is too large %d max header: %d\n",
> > -                          header_len, io_sq->tx_max_header_size);
> > +                          "Header size is too large %d max header: %d\n", header_len,
> > +                          io_sq->tx_max_header_size);
> >                  return -EINVAL;
> >          }
> >
> > -       if (unlikely(io_sq->mem_queue_type ==
> ENA_ADMIN_PLACEMENT_POLICY_DEV &&
> > -                    !buffer_to_push)) {
> > +       if (unlikely(io_sq->mem_queue_type ==
> ENA_ADMIN_PLACEMENT_POLICY_DEV && !buffer_to_push)) {
> >                  netdev_err(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> >                             "Push header wasn't provided in LLQ mode\n");
> >                  return -EINVAL;
> > @@ -556,13 +549,11 @@ int ena_com_rx_pkt(struct ena_com_io_cq
> *io_cq,
> >          }
> >
> >          netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> > -                  "Fetch rx packet: queue %d completed desc: %d\n", io_cq->qid,
> > -                  nb_hw_desc);
> > +                  "Fetch rx packet: queue %d completed desc: %d\n", io_cq->qid,
> nb_hw_desc);
> >
> >          if (unlikely(nb_hw_desc > ena_rx_ctx->max_bufs)) {
> >                  netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> > -                          "Too many RX cdescs (%d) > MAX(%d)\n", nb_hw_desc,
> > -                          ena_rx_ctx->max_bufs);
> > +                          "Too many RX cdescs (%d) > MAX(%d)\n", nb_hw_desc,
> ena_rx_ctx->max_bufs);
> >                  return -ENOSPC;
> >          }
> >
> > @@ -586,8 +577,8 @@ int ena_com_rx_pkt(struct ena_com_io_cq *io_cq,
> >          io_sq->next_to_comp += nb_hw_desc;
> >
> >          netdev_dbg(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> > -                  "[%s][QID#%d] Updating SQ head to: %d\n", __func__,
> > -                  io_sq->qid, io_sq->next_to_comp);
> > +                  "[%s][QID#%d] Updating SQ head to: %d\n", __func__, io_sq-
> >qid,
> > +                  io_sq->next_to_comp);
> >
> >          /* Get rx flags from the last pkt */
> >          ena_com_rx_set_flags(io_cq, ena_rx_ctx, cdesc);
> > @@ -624,8 +615,8 @@ int ena_com_add_single_rx_desc(struct
> ena_com_io_sq *io_sq,
> >          desc->req_id = req_id;
> >
> >          netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                  "[%s] Adding single RX desc, Queue: %u, req_id: %u\n",
> > -                  __func__, io_sq->qid, req_id);
> > +                  "[%s] Adding single RX desc, Queue: %u, req_id: %u\n",
> __func__, io_sq->qid,
> > +                  req_id);
> >
> >          desc->buff_addr_lo = (u32)ena_buf->paddr;
> >          desc->buff_addr_hi =
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> > index 4d65d82..72b0197 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> > +++ b/drivers/net/ethernet/amazon/ena/ena_eth_com.h
> > @@ -143,8 +143,8 @@ static inline bool
> ena_com_is_doorbell_needed(struct ena_com_io_sq *io_sq,
> >          }
> >
> >          netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                  "Queue: %d num_descs: %d num_entries_needed: %d\n",
> > -                  io_sq->qid, num_descs, num_entries_needed);
> > +                  "Queue: %d num_descs: %d num_entries_needed: %d\n",
> io_sq->qid, num_descs,
> > +                  num_entries_needed);
> >
> >          return num_entries_needed > io_sq->entries_in_tx_burst_left;
> >   }
> > @@ -155,15 +155,14 @@ static inline int
> ena_com_write_sq_doorbell(struct ena_com_io_sq *io_sq)
> >          u16 tail = io_sq->tail;
> >
> >          netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                  "Write submission queue doorbell for queue: %d tail: %d\n",
> > -                  io_sq->qid, tail);
> > +                  "Write submission queue doorbell for queue: %d tail: %d\n",
> io_sq->qid, tail);
> >
> >          writel(tail, io_sq->db_addr);
> >
> >          if (is_llq_max_tx_burst_exists(io_sq)) {
> >                  netdev_dbg(ena_com_io_sq_to_ena_dev(io_sq)->net_device,
> > -                          "Reset available entries in tx burst for queue %d to %d\n",
> > -                          io_sq->qid, max_entries_in_tx_burst);
> > +                          "Reset available entries in tx burst for queue %d to %d\n",
> io_sq->qid,
> > +                          max_entries_in_tx_burst);
> >                  io_sq->entries_in_tx_burst_left = max_entries_in_tx_burst;
> >          }
> >
> > @@ -224,8 +223,8 @@ static inline int
> ena_com_tx_comp_req_id_get(struct ena_com_io_cq *io_cq,
> >
> >          *req_id = READ_ONCE(cdesc->req_id);
> >          if (unlikely(*req_id >= io_cq->q_depth)) {
> > -               netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> > -                          "Invalid req id %d\n", cdesc->req_id);
> > +               netdev_err(ena_com_io_cq_to_ena_dev(io_cq)->net_device,
> "Invalid req id %d\n",
> > +                          cdesc->req_id);
> >                  return -EINVAL;
> >          }
> >
> > diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > index ca56dff..526ab3e 100644
> > --- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > +++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
> > @@ -141,11 +141,9 @@ int ena_xmit_common(struct ena_adapter
> *adapter,
> >          if (unlikely(rc)) {
> >                  netif_err(adapter, tx_queued, adapter->netdev,
> >                            "Failed to prepare tx bufs\n");
> > -               ena_increase_stat(&ring->tx_stats.prepare_ctx_err, 1,
> > -                                 &ring->syncp);
> > +               ena_increase_stat(&ring->tx_stats.prepare_ctx_err, 1, &ring-
> >syncp);
> >                  if (rc != -ENOMEM)
> > -                       ena_reset_device(adapter,
> > -                                        ENA_REGS_RESET_DRIVER_INVALID_STATE);
> > +                       ena_reset_device(adapter,
> ENA_REGS_RESET_DRIVER_INVALID_STATE);
> >                  return rc;
> >          }
> >
> > @@ -510,8 +508,7 @@ static struct page *ena_alloc_map_page(struct
> ena_ring *rx_ring,
> >           */
> >          page = dev_alloc_page();
> >          if (!page) {
> > -               ena_increase_stat(&rx_ring->rx_stats.page_alloc_fail, 1,
> > -                                 &rx_ring->syncp);
> > +               ena_increase_stat(&rx_ring->rx_stats.page_alloc_fail, 1,
> &rx_ring->syncp);
> >                  return ERR_PTR(-ENOSPC);
> >          }
> >
> > @@ -570,8 +567,8 @@ static void ena_unmap_rx_buff_attrs(struct
> ena_ring *rx_ring,
> >                                      struct ena_rx_buffer *rx_info,
> >                                      unsigned long attrs)
> >   {
> > -       dma_unmap_page_attrs(rx_ring->dev, rx_info->dma_addr,
> ENA_PAGE_SIZE,
> > -                            DMA_BIDIRECTIONAL, attrs);
> > +       dma_unmap_page_attrs(rx_ring->dev, rx_info->dma_addr,
> ENA_PAGE_SIZE, DMA_BIDIRECTIONAL,
> > +                            attrs);
> >   }
> >
> >   static void ena_free_rx_page(struct ena_ring *rx_ring,
> > @@ -844,8 +841,7 @@ static int ena_clean_tx_irq(struct ena_ring *tx_ring,
> u32 budget)
> >                                                  &req_id);
> >                  if (rc) {
> >                          if (unlikely(rc == -EINVAL))
> > -                               handle_invalid_req_id(tx_ring, req_id, NULL,
> > -                                                     false);
> > +                               handle_invalid_req_id(tx_ring, req_id, NULL, false);
> >                          break;
> >                  }
> >
> > @@ -1070,8 +1066,7 @@ static struct sk_buff *ena_rx_skb(struct ena_ring
> *rx_ring,
> >                                          DMA_FROM_DEVICE);
> >
> >                  if (!reuse_rx_buf_page)
> > -                       ena_unmap_rx_buff_attrs(rx_ring, rx_info,
> > -                                               DMA_ATTR_SKIP_CPU_SYNC);
> > +                       ena_unmap_rx_buff_attrs(rx_ring, rx_info,
> DMA_ATTR_SKIP_CPU_SYNC);
> >
> >                  skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, rx_info->page,
> >                                  page_offset + buf_offset, len, buf_len);
> > @@ -1342,8 +1337,7 @@ error:
> >          adapter = netdev_priv(rx_ring->netdev);
> >
> >          if (rc == -ENOSPC) {
> > -               ena_increase_stat(&rx_ring->rx_stats.bad_desc_num, 1,
> > -                                 &rx_ring->syncp);
> > +               ena_increase_stat(&rx_ring->rx_stats.bad_desc_num, 1,
> &rx_ring->syncp);
> >                  ena_reset_device(adapter,
> ENA_REGS_RESET_TOO_MANY_RX_DESCS);
> >          } else {
> >                  ena_increase_stat(&rx_ring->rx_stats.bad_req_id, 1,
> > @@ -1833,8 +1827,7 @@ static int ena_rss_configure(struct ena_adapter
> *adapter)
> >          if (!ena_dev->rss.tbl_log_size) {
> >                  rc = ena_rss_init_default(adapter);
> >                  if (rc && (rc != -EOPNOTSUPP)) {
> > -                       netif_err(adapter, ifup, adapter->netdev,
> > -                                 "Failed to init RSS rc: %d\n", rc);
> > +                       netif_err(adapter, ifup, adapter->netdev, "Failed to init RSS rc:
> %d\n", rc);
> >                          return rc;
> >                  }
> >          }
> > @@ -2790,8 +2783,7 @@ static void ena_config_debug_area(struct
> ena_adapter *adapter)
> >          rc = ena_com_set_host_attributes(adapter->ena_dev);
> >          if (rc) {
> >                  if (rc == -EOPNOTSUPP)
> > -                       netif_warn(adapter, drv, adapter->netdev,
> > -                                  "Cannot set host attributes\n");
> > +                       netif_warn(adapter, drv, adapter->netdev, "Cannot set host
> attributes\n");
> >                  else
> >                          netif_err(adapter, drv, adapter->netdev,
> >                                    "Cannot set host attributes\n");
> > @@ -3831,8 +3823,8 @@ static int ena_rss_init_default(struct ena_adapter
> *adapter)
> >                  }
> >          }
> >
> > -       rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ,
> NULL,
> > -                                       ENA_HASH_KEY_SIZE, 0xFFFFFFFF);
> > +       rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ,
> NULL, ENA_HASH_KEY_SIZE,
> > +                                       0xFFFFFFFF);
> >          if (unlikely(rc && (rc != -EOPNOTSUPP))) {
> >                  dev_err(dev, "Cannot fill hash function\n");
> >                  goto err_fill_indir;
> > --
> > 2.40.1
> >
> >

Re: [PATCH v1 net-next 00/11] ENA driver changes

[Nelson, Shannon]

On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> 
> From: David Arinzon <darinzon@amazon.com>
> 
> This patchset contains a set of minor and cosmetic
> changes to the ENA driver.

A couple of nits noted, but otherwise looks reasonable.

Reviewed-by: Shannon Nelson <shannon.nelson@amd.com>


> 
> David Arinzon (11):
>    net: ena: Remove an unused field
>    net: ena: Add more documentation for RX copybreak
>    net: ena: Minor cosmetic changes
>    net: ena: Enable DIM by default
>    net: ena: Remove CQ tail pointer update
>    net: ena: Change error print during ena_device_init()
>    net: ena: Add more information on TX timeouts
>    net: ena: Relocate skb_tx_timestamp() to improve time stamping
>      accuracy
>    net: ena: Change default print level for netif_ prints
>    net: ena: handle ena_calc_io_queue_size() possible errors
>    net: ena: Reduce lines with longer column width boundary
> 
>   .../device_drivers/ethernet/amazon/ena.rst    |   6 +
>   drivers/net/ethernet/amazon/ena/ena_com.c     | 323 ++++++------------
>   drivers/net/ethernet/amazon/ena/ena_com.h     |   6 +-
>   drivers/net/ethernet/amazon/ena/ena_eth_com.c |  49 ++-
>   drivers/net/ethernet/amazon/ena/ena_eth_com.h |  39 +--
>   drivers/net/ethernet/amazon/ena/ena_netdev.c  | 161 ++++++---
>   .../net/ethernet/amazon/ena/ena_regs_defs.h   |   1 +
>   drivers/net/ethernet/amazon/ena/ena_xdp.c     |   1 -
>   8 files changed, 258 insertions(+), 328 deletions(-)
> 
> --
> 2.40.1
> 
> 

RE: [PATCH v1 net-next 00/11] ENA driver changes

[Arinzon, David]

> On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
> >
> > From: David Arinzon <darinzon@amazon.com>
> >
> > This patchset contains a set of minor and cosmetic changes to the ENA
> > driver.
> 
> A couple of nits noted, but otherwise looks reasonable.
> 
> Reviewed-by: Shannon Nelson <shannon.nelson@amd.com>
> 
> 

Thanks for taking the time and reviewing the patchset.
I've addressed some of the comments, while the rest will
be fixed in the next patchset version.

David

> >
> > David Arinzon (11):
> >    net: ena: Remove an unused field
> >    net: ena: Add more documentation for RX copybreak
> >    net: ena: Minor cosmetic changes
> >    net: ena: Enable DIM by default
> >    net: ena: Remove CQ tail pointer update
> >    net: ena: Change error print during ena_device_init()
> >    net: ena: Add more information on TX timeouts
> >    net: ena: Relocate skb_tx_timestamp() to improve time stamping
> >      accuracy
> >    net: ena: Change default print level for netif_ prints
> >    net: ena: handle ena_calc_io_queue_size() possible errors
> >    net: ena: Reduce lines with longer column width boundary
> >
> >   .../device_drivers/ethernet/amazon/ena.rst    |   6 +
> >   drivers/net/ethernet/amazon/ena/ena_com.c     | 323 ++++++------------
> >   drivers/net/ethernet/amazon/ena/ena_com.h     |   6 +-
> >   drivers/net/ethernet/amazon/ena/ena_eth_com.c |  49 ++-
> >   drivers/net/ethernet/amazon/ena/ena_eth_com.h |  39 +--
> >   drivers/net/ethernet/amazon/ena/ena_netdev.c  | 161 ++++++---
> >   .../net/ethernet/amazon/ena/ena_regs_defs.h   |   1 +
> >   drivers/net/ethernet/amazon/ena/ena_xdp.c     |   1 -
> >   8 files changed, 258 insertions(+), 328 deletions(-)
> >
> > --
> > 2.40.1
> >
> >

Re: [PATCH v1 net-next 00/11] ENA driver changes

[Nelson, Shannon]

On 1/30/2024 1:39 AM, Arinzon, David wrote:
> 
>> On 1/29/2024 12:55 AM, darinzon@amazon.com wrote:
>>>
>>> From: David Arinzon <darinzon@amazon.com>
>>>
>>> This patchset contains a set of minor and cosmetic changes to the ENA
>>> driver.
>>
>> A couple of nits noted, but otherwise looks reasonable.
>>
>> Reviewed-by: Shannon Nelson <shannon.nelson@amd.com>
>>
>>
> 
> Thanks for taking the time and reviewing the patchset.
> I've addressed some of the comments, while the rest will
> be fixed in the next patchset version.

Yep, I'm fine with your notes.

Cheers,
sln

> 
> David
> 
>>>
>>> David Arinzon (11):
>>>     net: ena: Remove an unused field
>>>     net: ena: Add more documentation for RX copybreak
>>>     net: ena: Minor cosmetic changes
>>>     net: ena: Enable DIM by default
>>>     net: ena: Remove CQ tail pointer update
>>>     net: ena: Change error print during ena_device_init()
>>>     net: ena: Add more information on TX timeouts
>>>     net: ena: Relocate skb_tx_timestamp() to improve time stamping
>>>       accuracy
>>>     net: ena: Change default print level for netif_ prints
>>>     net: ena: handle ena_calc_io_queue_size() possible errors
>>>     net: ena: Reduce lines with longer column width boundary
>>>
>>>    .../device_drivers/ethernet/amazon/ena.rst    |   6 +
>>>    drivers/net/ethernet/amazon/ena/ena_com.c     | 323 ++++++------------
>>>    drivers/net/ethernet/amazon/ena/ena_com.h     |   6 +-
>>>    drivers/net/ethernet/amazon/ena/ena_eth_com.c |  49 ++-
>>>    drivers/net/ethernet/amazon/ena/ena_eth_com.h |  39 +--
>>>    drivers/net/ethernet/amazon/ena/ena_netdev.c  | 161 ++++++---
>>>    .../net/ethernet/amazon/ena/ena_regs_defs.h   |   1 +
>>>    drivers/net/ethernet/amazon/ena/ena_xdp.c     |   1 -
>>>    8 files changed, 258 insertions(+), 328 deletions(-)
>>>
>>> --
>>> 2.40.1
>>>
>>>
>