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