net: ena: Reduce lines with longer column width boundary

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>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
index 675ee728fe527079da355ffb0f9745d7d2355ba9..9e9e4a03f1a8c9bd4c8d68cb20340157c4547e80 100644 (file)
--- 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 f9f886289b970ab2b351fec3b4c589437e5c101e..933e619b3a31342df099de504f0e137aa9cdcbdb 100644 (file)
--- 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 4d65d820a95eda2bb79937a8aa4fe79c585a848d..72b019758caafc04b1aae8e821a03a649d94010c 100644 (file)
--- 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 965a01c5e245a2dfdc5b0a79238befb9fddb00e4..03be2c008c4d8f88ee6d39b6c25646d6f249585a 100644 (file)
--- 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;