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

From: "Arinzon, David" <[email-masked]>
Date: Tue, 30 Jan 2024 09:39:36 +0000

> On 1/29/2024 12:55 AM, [email-masked] wrote:
> >
> > From: David Arinzon <[email-masked]>
> >
> > 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 <[email-masked]>
> > ---
> >   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
> >
> >