LCOV - code coverage report
Current view: top level - drivers/net/ena/base - ena_com.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 1251 0.0 %
Date: 2024-04-01 19:00:53 Functions: 0 101 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 584 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright (c) 2015-2020 Amazon.com, Inc. or its affiliates.
       3                 :            :  * All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "ena_com.h"
       7                 :            : 
       8                 :            : /*****************************************************************************/
       9                 :            : /*****************************************************************************/
      10                 :            : 
      11                 :            : /* Timeout in micro-sec */
      12                 :            : #define ADMIN_CMD_TIMEOUT_US (3000000)
      13                 :            : 
      14                 :            : #define ENA_ASYNC_QUEUE_DEPTH 16
      15                 :            : #define ENA_ADMIN_QUEUE_DEPTH 32
      16                 :            : 
      17                 :            : #define ENA_CTRL_MAJOR          0
      18                 :            : #define ENA_CTRL_MINOR          0
      19                 :            : #define ENA_CTRL_SUB_MINOR      1
      20                 :            : 
      21                 :            : #define MIN_ENA_CTRL_VER \
      22                 :            :         (((ENA_CTRL_MAJOR) << \
      23                 :            :         (ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_SHIFT)) | \
      24                 :            :         ((ENA_CTRL_MINOR) << \
      25                 :            :         (ENA_REGS_CONTROLLER_VERSION_MINOR_VERSION_SHIFT)) | \
      26                 :            :         (ENA_CTRL_SUB_MINOR))
      27                 :            : 
      28                 :            : #define ENA_DMA_ADDR_TO_UINT32_LOW(x)   ((u32)((u64)(x)))
      29                 :            : #define ENA_DMA_ADDR_TO_UINT32_HIGH(x)  ((u32)(((u64)(x)) >> 32))
      30                 :            : 
      31                 :            : #define ENA_MMIO_READ_TIMEOUT 0xFFFFFFFF
      32                 :            : 
      33                 :            : #define ENA_COM_BOUNCE_BUFFER_CNTRL_CNT 4
      34                 :            : 
      35                 :            : #define ENA_REGS_ADMIN_INTR_MASK 1
      36                 :            : 
      37                 :            : #define ENA_MAX_BACKOFF_DELAY_EXP 16U
      38                 :            : 
      39                 :            : #define ENA_MIN_ADMIN_POLL_US 100
      40                 :            : 
      41                 :            : #define ENA_MAX_ADMIN_POLL_US 5000
      42                 :            : 
      43                 :            : /* PHC definitions */
      44                 :            : #define ENA_PHC_DEFAULT_EXPIRE_TIMEOUT_USEC 10
      45                 :            : #define ENA_PHC_DEFAULT_BLOCK_TIMEOUT_USEC 1000
      46                 :            : #define ENA_PHC_MAX_ERROR_BOUND 0xFFFFFFFF
      47                 :            : #define ENA_PHC_REQ_ID_OFFSET 0xDEAD
      48                 :            : #define ENA_PHC_ERROR_FLAGS (ENA_ADMIN_PHC_ERROR_FLAG_TIMESTAMP | \
      49                 :            :                              ENA_ADMIN_PHC_ERROR_FLAG_ERROR_BOUND)
      50                 :            : 
      51                 :            : /*****************************************************************************/
      52                 :            : /*****************************************************************************/
      53                 :            : /*****************************************************************************/
      54                 :            : 
      55                 :            : enum ena_cmd_status {
      56                 :            :         ENA_CMD_SUBMITTED,
      57                 :            :         ENA_CMD_COMPLETED,
      58                 :            :         /* Abort - canceled by the driver */
      59                 :            :         ENA_CMD_ABORTED,
      60                 :            : };
      61                 :            : 
      62                 :            : struct ena_comp_ctx {
      63                 :            :         ena_wait_event_t wait_event;
      64                 :            :         struct ena_admin_acq_entry *user_cqe;
      65                 :            :         u32 comp_size;
      66                 :            :         enum ena_cmd_status status;
      67                 :            :         /* status from the device */
      68                 :            :         u8 comp_status;
      69                 :            :         u8 cmd_opcode;
      70                 :            :         bool occupied;
      71                 :            : };
      72                 :            : 
      73                 :            : struct ena_com_stats_ctx {
      74                 :            :         struct ena_admin_aq_get_stats_cmd get_cmd;
      75                 :            :         struct ena_admin_acq_get_stats_resp get_resp;
      76                 :            : };
      77                 :            : 
      78                 :          0 : static int ena_com_mem_addr_set(struct ena_com_dev *ena_dev,
      79                 :            :                                        struct ena_common_mem_addr *ena_addr,
      80                 :            :                                        dma_addr_t addr)
      81                 :            : {
      82         [ #  # ]:          0 :         if (unlikely((addr & GENMASK_ULL(ena_dev->dma_addr_bits - 1, 0)) != addr)) {
      83                 :          0 :                 ena_trc_err(ena_dev, "DMA address has more bits than the device supports\n");
      84                 :          0 :                 return ENA_COM_INVAL;
      85                 :            :         }
      86                 :            : 
      87                 :          0 :         ena_addr->mem_addr_low = lower_32_bits(addr);
      88                 :          0 :         ena_addr->mem_addr_high = (u16)upper_32_bits(addr);
      89                 :            : 
      90                 :          0 :         return 0;
      91                 :            : }
      92                 :            : 
      93                 :          0 : static int ena_com_admin_init_sq(struct ena_com_admin_queue *admin_queue)
      94                 :            : {
      95                 :            :         struct ena_com_dev *ena_dev = admin_queue->ena_dev;
      96                 :            :         struct ena_com_admin_sq *sq = &admin_queue->sq;
      97                 :          0 :         u16 size = ADMIN_SQ_SIZE(admin_queue->q_depth);
      98                 :            : 
      99                 :          0 :         ENA_MEM_ALLOC_COHERENT(admin_queue->q_dmadev, size, sq->entries, sq->dma_addr,
     100                 :            :                                sq->mem_handle);
     101                 :            : 
     102         [ #  # ]:          0 :         if (unlikely(!sq->entries)) {
     103                 :          0 :                 ena_trc_err(ena_dev, "Memory allocation failed\n");
     104                 :          0 :                 return ENA_COM_NO_MEM;
     105                 :            :         }
     106                 :            : 
     107                 :          0 :         sq->head = 0;
     108                 :          0 :         sq->tail = 0;
     109                 :          0 :         sq->phase = 1;
     110                 :            : 
     111                 :          0 :         sq->db_addr = NULL;
     112                 :            : 
     113                 :          0 :         return 0;
     114                 :            : }
     115                 :            : 
     116                 :          0 : static int ena_com_admin_init_cq(struct ena_com_admin_queue *admin_queue)
     117                 :            : {
     118                 :            :         struct ena_com_dev *ena_dev = admin_queue->ena_dev;
     119                 :            :         struct ena_com_admin_cq *cq = &admin_queue->cq;
     120                 :          0 :         u16 size = ADMIN_CQ_SIZE(admin_queue->q_depth);
     121                 :            : 
     122                 :          0 :         ENA_MEM_ALLOC_COHERENT(admin_queue->q_dmadev, size, cq->entries, cq->dma_addr,
     123                 :            :                                cq->mem_handle);
     124                 :            : 
     125         [ #  # ]:          0 :         if (unlikely(!cq->entries))  {
     126                 :          0 :                 ena_trc_err(ena_dev, "Memory allocation failed\n");
     127                 :          0 :                 return ENA_COM_NO_MEM;
     128                 :            :         }
     129                 :            : 
     130                 :          0 :         cq->head = 0;
     131                 :          0 :         cq->phase = 1;
     132                 :            : 
     133                 :          0 :         return 0;
     134                 :            : }
     135                 :            : 
     136                 :          0 : static int ena_com_admin_init_aenq(struct ena_com_dev *ena_dev,
     137                 :            :                                    struct ena_aenq_handlers *aenq_handlers)
     138                 :            : {
     139                 :            :         struct ena_com_aenq *aenq = &ena_dev->aenq;
     140                 :            :         u32 addr_low, addr_high, aenq_caps;
     141                 :            :         u16 size;
     142                 :            : 
     143                 :          0 :         ena_dev->aenq.q_depth = ENA_ASYNC_QUEUE_DEPTH;
     144                 :            :         size = ADMIN_AENQ_SIZE(ENA_ASYNC_QUEUE_DEPTH);
     145                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev, size,
     146                 :            :                         aenq->entries,
     147                 :            :                         aenq->dma_addr,
     148                 :            :                         aenq->mem_handle);
     149                 :            : 
     150         [ #  # ]:          0 :         if (unlikely(!aenq->entries)) {
     151                 :          0 :                 ena_trc_err(ena_dev, "Memory allocation failed\n");
     152                 :          0 :                 return ENA_COM_NO_MEM;
     153                 :            :         }
     154                 :            : 
     155                 :          0 :         aenq->head = aenq->q_depth;
     156                 :          0 :         aenq->phase = 1;
     157                 :            : 
     158                 :          0 :         addr_low = ENA_DMA_ADDR_TO_UINT32_LOW(aenq->dma_addr);
     159                 :          0 :         addr_high = ENA_DMA_ADDR_TO_UINT32_HIGH(aenq->dma_addr);
     160                 :            : 
     161                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, addr_low, ena_dev->reg_bar + ENA_REGS_AENQ_BASE_LO_OFF);
     162                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, addr_high, ena_dev->reg_bar + ENA_REGS_AENQ_BASE_HI_OFF);
     163                 :            : 
     164                 :            :         aenq_caps = 0;
     165                 :          0 :         aenq_caps |= ena_dev->aenq.q_depth & ENA_REGS_AENQ_CAPS_AENQ_DEPTH_MASK;
     166                 :          0 :         aenq_caps |= (sizeof(struct ena_admin_aenq_entry) <<
     167                 :            :                 ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_SHIFT) &
     168                 :            :                 ENA_REGS_AENQ_CAPS_AENQ_ENTRY_SIZE_MASK;
     169                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, aenq_caps, ena_dev->reg_bar + ENA_REGS_AENQ_CAPS_OFF);
     170                 :            : 
     171         [ #  # ]:          0 :         if (unlikely(!aenq_handlers)) {
     172                 :          0 :                 ena_trc_err(ena_dev, "AENQ handlers pointer is NULL\n");
     173                 :          0 :                 return ENA_COM_INVAL;
     174                 :            :         }
     175                 :            : 
     176                 :          0 :         aenq->aenq_handlers = aenq_handlers;
     177                 :            : 
     178                 :          0 :         return 0;
     179                 :            : }
     180                 :            : 
     181                 :            : static void comp_ctxt_release(struct ena_com_admin_queue *queue,
     182                 :            :                                      struct ena_comp_ctx *comp_ctx)
     183                 :            : {
     184                 :          0 :         comp_ctx->user_cqe = NULL;
     185                 :          0 :         comp_ctx->occupied = false;
     186                 :          0 :         ATOMIC32_DEC(&queue->outstanding_cmds);
     187                 :            : }
     188                 :            : 
     189                 :          0 : static struct ena_comp_ctx *get_comp_ctxt(struct ena_com_admin_queue *admin_queue,
     190                 :            :                                           u16 command_id, bool capture)
     191                 :            : {
     192         [ #  # ]:          0 :         if (unlikely(command_id >= admin_queue->q_depth)) {
     193                 :          0 :                 ena_trc_err(admin_queue->ena_dev,
     194                 :            :                             "Command id is larger than the queue size. cmd_id: %u queue size %d\n",
     195                 :            :                             command_id, admin_queue->q_depth);
     196                 :          0 :                 return NULL;
     197                 :            :         }
     198                 :            : 
     199         [ #  # ]:          0 :         if (unlikely(!admin_queue->comp_ctx)) {
     200                 :          0 :                 ena_trc_err(admin_queue->ena_dev,
     201                 :            :                             "Completion context is NULL\n");
     202                 :          0 :                 return NULL;
     203                 :            :         }
     204                 :            : 
     205   [ #  #  #  # ]:          0 :         if (unlikely(admin_queue->comp_ctx[command_id].occupied && capture)) {
     206                 :          0 :                 ena_trc_err(admin_queue->ena_dev,
     207                 :            :                             "Completion context is occupied\n");
     208                 :          0 :                 return NULL;
     209                 :            :         }
     210                 :            : 
     211         [ #  # ]:          0 :         if (capture) {
     212                 :          0 :                 ATOMIC32_INC(&admin_queue->outstanding_cmds);
     213                 :          0 :                 admin_queue->comp_ctx[command_id].occupied = true;
     214                 :            :         }
     215                 :            : 
     216                 :          0 :         return &admin_queue->comp_ctx[command_id];
     217                 :            : }
     218                 :            : 
     219                 :          0 : static struct ena_comp_ctx *__ena_com_submit_admin_cmd(struct ena_com_admin_queue *admin_queue,
     220                 :            :                                                        struct ena_admin_aq_entry *cmd,
     221                 :            :                                                        size_t cmd_size_in_bytes,
     222                 :            :                                                        struct ena_admin_acq_entry *comp,
     223                 :            :                                                        size_t comp_size_in_bytes)
     224                 :            : {
     225                 :            :         struct ena_comp_ctx *comp_ctx;
     226                 :            :         u16 tail_masked, cmd_id;
     227                 :            :         u16 queue_size_mask;
     228                 :            :         u16 cnt;
     229                 :            : 
     230                 :          0 :         queue_size_mask = admin_queue->q_depth - 1;
     231                 :            : 
     232         [ #  # ]:          0 :         tail_masked = admin_queue->sq.tail & queue_size_mask;
     233                 :            : 
     234                 :            :         /* In case of queue FULL */
     235                 :          0 :         cnt = (u16)ATOMIC32_READ(&admin_queue->outstanding_cmds);
     236         [ #  # ]:          0 :         if (unlikely(cnt >= admin_queue->q_depth)) {
     237                 :          0 :                 ena_trc_dbg(admin_queue->ena_dev, "Admin queue is full.\n");
     238                 :          0 :                 admin_queue->stats.out_of_space++;
     239                 :          0 :                 return ERR_PTR(ENA_COM_NO_SPACE);
     240                 :            :         }
     241                 :            : 
     242                 :          0 :         cmd_id = admin_queue->curr_cmd_id;
     243                 :            : 
     244                 :          0 :         cmd->aq_common_descriptor.flags |= admin_queue->sq.phase &
     245                 :            :                 ENA_ADMIN_AQ_COMMON_DESC_PHASE_MASK;
     246                 :            : 
     247                 :          0 :         cmd->aq_common_descriptor.command_id |= cmd_id &
     248                 :            :                 ENA_ADMIN_AQ_COMMON_DESC_COMMAND_ID_MASK;
     249                 :            : 
     250                 :          0 :         comp_ctx = get_comp_ctxt(admin_queue, cmd_id, true);
     251         [ #  # ]:          0 :         if (unlikely(!comp_ctx))
     252                 :            :                 return ERR_PTR(ENA_COM_INVAL);
     253                 :            : 
     254                 :          0 :         comp_ctx->status = ENA_CMD_SUBMITTED;
     255                 :          0 :         comp_ctx->comp_size = (u32)comp_size_in_bytes;
     256                 :          0 :         comp_ctx->user_cqe = comp;
     257                 :          0 :         comp_ctx->cmd_opcode = cmd->aq_common_descriptor.opcode;
     258                 :            : 
     259                 :            :         ENA_WAIT_EVENT_CLEAR(comp_ctx->wait_event);
     260                 :            : 
     261         [ #  # ]:          0 :         memcpy(&admin_queue->sq.entries[tail_masked], cmd, cmd_size_in_bytes);
     262                 :            : 
     263                 :          0 :         admin_queue->curr_cmd_id = (admin_queue->curr_cmd_id + 1) &
     264                 :            :                 queue_size_mask;
     265                 :            : 
     266                 :          0 :         admin_queue->sq.tail++;
     267                 :          0 :         admin_queue->stats.submitted_cmd++;
     268                 :            : 
     269         [ #  # ]:          0 :         if (unlikely((admin_queue->sq.tail & queue_size_mask) == 0))
     270                 :          0 :                 admin_queue->sq.phase = !admin_queue->sq.phase;
     271                 :            : 
     272                 :            :         ENA_DB_SYNC(&admin_queue->sq.mem_handle);
     273                 :          0 :         ENA_REG_WRITE32(admin_queue->bus, admin_queue->sq.tail,
     274                 :            :                         admin_queue->sq.db_addr);
     275                 :            : 
     276                 :          0 :         return comp_ctx;
     277                 :            : }
     278                 :            : 
     279                 :          0 : static int ena_com_init_comp_ctxt(struct ena_com_admin_queue *admin_queue)
     280                 :            : {
     281                 :            :         struct ena_com_dev *ena_dev = admin_queue->ena_dev;
     282                 :          0 :         size_t size = admin_queue->q_depth * sizeof(struct ena_comp_ctx);
     283                 :            :         struct ena_comp_ctx *comp_ctx;
     284                 :            :         u16 i;
     285                 :            : 
     286                 :          0 :         admin_queue->comp_ctx = ENA_MEM_ALLOC(admin_queue->q_dmadev, size);
     287         [ #  # ]:          0 :         if (unlikely(!admin_queue->comp_ctx)) {
     288                 :          0 :                 ena_trc_err(ena_dev, "Memory allocation failed\n");
     289                 :          0 :                 return ENA_COM_NO_MEM;
     290                 :            :         }
     291                 :            : 
     292         [ #  # ]:          0 :         for (i = 0; i < admin_queue->q_depth; i++) {
     293                 :          0 :                 comp_ctx = get_comp_ctxt(admin_queue, i, false);
     294         [ #  # ]:          0 :                 if (comp_ctx)
     295                 :          0 :                         ENA_WAIT_EVENT_INIT(comp_ctx->wait_event);
     296                 :            :         }
     297                 :            : 
     298                 :            :         return 0;
     299                 :            : }
     300                 :            : 
     301                 :          0 : static struct ena_comp_ctx *ena_com_submit_admin_cmd(struct ena_com_admin_queue *admin_queue,
     302                 :            :                                                      struct ena_admin_aq_entry *cmd,
     303                 :            :                                                      size_t cmd_size_in_bytes,
     304                 :            :                                                      struct ena_admin_acq_entry *comp,
     305                 :            :                                                      size_t comp_size_in_bytes)
     306                 :            : {
     307                 :            :         unsigned long flags = 0;
     308                 :            :         struct ena_comp_ctx *comp_ctx;
     309                 :            : 
     310                 :          0 :         ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
     311         [ #  # ]:          0 :         if (unlikely(!admin_queue->running_state)) {
     312                 :            :                 ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
     313                 :          0 :                 return ERR_PTR(ENA_COM_NO_DEVICE);
     314                 :            :         }
     315                 :          0 :         comp_ctx = __ena_com_submit_admin_cmd(admin_queue, cmd,
     316                 :            :                                               cmd_size_in_bytes,
     317                 :            :                                               comp,
     318                 :            :                                               comp_size_in_bytes);
     319         [ #  # ]:          0 :         if (IS_ERR(comp_ctx))
     320                 :          0 :                 admin_queue->running_state = false;
     321                 :            :         ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
     322                 :            : 
     323                 :          0 :         return comp_ctx;
     324                 :            : }
     325                 :            : 
     326                 :          0 : static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
     327                 :            :                               struct ena_com_create_io_ctx *ctx,
     328                 :            :                               struct ena_com_io_sq *io_sq)
     329                 :            : {
     330                 :            :         size_t size;
     331                 :            :         int dev_node = 0;
     332                 :            : 
     333         [ #  # ]:          0 :         memset(&io_sq->desc_addr, 0x0, sizeof(io_sq->desc_addr));
     334                 :            : 
     335                 :          0 :         io_sq->dma_addr_bits = (u8)ena_dev->dma_addr_bits;
     336                 :          0 :         io_sq->desc_entry_size =
     337                 :            :                 (io_sq->direction == ENA_COM_IO_QUEUE_DIRECTION_TX) ?
     338                 :            :                 sizeof(struct ena_eth_io_tx_desc) :
     339                 :            :                 sizeof(struct ena_eth_io_rx_desc);
     340                 :            : 
     341                 :          0 :         size = io_sq->desc_entry_size * io_sq->q_depth;
     342                 :          0 :         io_sq->bus = ena_dev->bus;
     343                 :            : 
     344         [ #  # ]:          0 :         if (io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_HOST) {
     345                 :          0 :                 ENA_MEM_ALLOC_COHERENT_NODE(ena_dev->dmadev,
     346                 :            :                                             size,
     347                 :            :                                             io_sq->desc_addr.virt_addr,
     348                 :            :                                             io_sq->desc_addr.phys_addr,
     349                 :            :                                             io_sq->desc_addr.mem_handle,
     350                 :            :                                             ctx->numa_node,
     351                 :            :                                             dev_node);
     352         [ #  # ]:          0 :                 if (!io_sq->desc_addr.virt_addr) {
     353                 :          0 :                         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
     354                 :            :                                                size,
     355                 :            :                                                io_sq->desc_addr.virt_addr,
     356                 :            :                                                io_sq->desc_addr.phys_addr,
     357                 :            :                                                io_sq->desc_addr.mem_handle);
     358                 :            :                 }
     359                 :            : 
     360         [ #  # ]:          0 :                 if (unlikely(!io_sq->desc_addr.virt_addr)) {
     361                 :          0 :                         ena_trc_err(ena_dev, "Memory allocation failed\n");
     362                 :          0 :                         return ENA_COM_NO_MEM;
     363                 :            :                 }
     364                 :            :         }
     365                 :            : 
     366         [ #  # ]:          0 :         if (io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV) {
     367                 :            :                 /* Allocate bounce buffers */
     368                 :          0 :                 io_sq->bounce_buf_ctrl.buffer_size =
     369                 :          0 :                         ena_dev->llq_info.desc_list_entry_size;
     370                 :          0 :                 io_sq->bounce_buf_ctrl.buffers_num =
     371                 :            :                         ENA_COM_BOUNCE_BUFFER_CNTRL_CNT;
     372                 :          0 :                 io_sq->bounce_buf_ctrl.next_to_use = 0;
     373                 :            : 
     374                 :          0 :                 size = (size_t)io_sq->bounce_buf_ctrl.buffer_size *
     375                 :            :                         io_sq->bounce_buf_ctrl.buffers_num;
     376                 :            : 
     377                 :          0 :                 ENA_MEM_ALLOC_NODE(ena_dev->dmadev,
     378                 :            :                                    size,
     379                 :            :                                    io_sq->bounce_buf_ctrl.base_buffer,
     380                 :            :                                    ctx->numa_node,
     381                 :            :                                    dev_node);
     382         [ #  # ]:          0 :                 if (!io_sq->bounce_buf_ctrl.base_buffer)
     383                 :          0 :                         io_sq->bounce_buf_ctrl.base_buffer = ENA_MEM_ALLOC(ena_dev->dmadev, size);
     384                 :            : 
     385         [ #  # ]:          0 :                 if (unlikely(!io_sq->bounce_buf_ctrl.base_buffer)) {
     386                 :          0 :                         ena_trc_err(ena_dev, "Bounce buffer memory allocation failed\n");
     387                 :          0 :                         return ENA_COM_NO_MEM;
     388                 :            :                 }
     389                 :            : 
     390         [ #  # ]:          0 :                 memcpy(&io_sq->llq_info, &ena_dev->llq_info,
     391                 :            :                        sizeof(io_sq->llq_info));
     392                 :            : 
     393                 :            :                 /* Initiate the first bounce buffer */
     394                 :          0 :                 io_sq->llq_buf_ctrl.curr_bounce_buf =
     395                 :            :                         ena_com_get_next_bounce_buffer(&io_sq->bounce_buf_ctrl);
     396                 :          0 :                 memset(io_sq->llq_buf_ctrl.curr_bounce_buf,
     397         [ #  # ]:          0 :                        0x0, io_sq->llq_info.desc_list_entry_size);
     398                 :          0 :                 io_sq->llq_buf_ctrl.descs_left_in_line =
     399                 :          0 :                         io_sq->llq_info.descs_num_before_header;
     400                 :          0 :                 io_sq->disable_meta_caching =
     401                 :          0 :                         io_sq->llq_info.disable_meta_caching;
     402                 :            : 
     403         [ #  # ]:          0 :                 if (io_sq->llq_info.max_entries_in_tx_burst > 0)
     404                 :          0 :                         io_sq->entries_in_tx_burst_left =
     405                 :            :                                 io_sq->llq_info.max_entries_in_tx_burst;
     406                 :            :         }
     407                 :            : 
     408                 :          0 :         io_sq->tail = 0;
     409                 :          0 :         io_sq->next_to_comp = 0;
     410                 :          0 :         io_sq->phase = 1;
     411                 :            : 
     412                 :          0 :         return 0;
     413                 :            : }
     414                 :            : 
     415                 :          0 : static int ena_com_init_io_cq(struct ena_com_dev *ena_dev,
     416                 :            :                               struct ena_com_create_io_ctx *ctx,
     417                 :            :                               struct ena_com_io_cq *io_cq)
     418                 :            : {
     419                 :            :         size_t size;
     420                 :            :         int prev_node = 0;
     421                 :            : 
     422         [ #  # ]:          0 :         memset(&io_cq->cdesc_addr, 0x0, sizeof(io_cq->cdesc_addr));
     423                 :            : 
     424                 :            :         /* Use the basic completion descriptor for Rx */
     425                 :          0 :         io_cq->cdesc_entry_size_in_bytes =
     426         [ #  # ]:          0 :                 (io_cq->direction == ENA_COM_IO_QUEUE_DIRECTION_TX) ?
     427                 :            :                 sizeof(struct ena_eth_io_tx_cdesc) :
     428                 :            :                 sizeof(struct ena_eth_io_rx_cdesc_base);
     429                 :            : 
     430                 :          0 :         size = io_cq->cdesc_entry_size_in_bytes * io_cq->q_depth;
     431                 :          0 :         io_cq->bus = ena_dev->bus;
     432                 :            : 
     433                 :          0 :         ENA_MEM_ALLOC_COHERENT_NODE_ALIGNED(ena_dev->dmadev,
     434                 :            :                                             size,
     435                 :            :                                             io_cq->cdesc_addr.virt_addr,
     436                 :            :                                             io_cq->cdesc_addr.phys_addr,
     437                 :            :                                             io_cq->cdesc_addr.mem_handle,
     438                 :            :                                             ctx->numa_node,
     439                 :            :                                             prev_node,
     440                 :            :                                             ENA_CDESC_RING_SIZE_ALIGNMENT);
     441         [ #  # ]:          0 :         if (!io_cq->cdesc_addr.virt_addr) {
     442                 :          0 :                 ENA_MEM_ALLOC_COHERENT_ALIGNED(ena_dev->dmadev,
     443                 :            :                                                size,
     444                 :            :                                                io_cq->cdesc_addr.virt_addr,
     445                 :            :                                                io_cq->cdesc_addr.phys_addr,
     446                 :            :                                                io_cq->cdesc_addr.mem_handle,
     447                 :            :                                                ENA_CDESC_RING_SIZE_ALIGNMENT);
     448                 :            :         }
     449                 :            : 
     450         [ #  # ]:          0 :         if (unlikely(!io_cq->cdesc_addr.virt_addr)) {
     451                 :          0 :                 ena_trc_err(ena_dev, "Memory allocation failed\n");
     452                 :          0 :                 return ENA_COM_NO_MEM;
     453                 :            :         }
     454                 :            : 
     455                 :          0 :         io_cq->phase = 1;
     456                 :          0 :         io_cq->head = 0;
     457                 :            : 
     458                 :          0 :         return 0;
     459                 :            : }
     460                 :            : 
     461                 :          0 : static void ena_com_handle_single_admin_completion(struct ena_com_admin_queue *admin_queue,
     462                 :            :                                                    struct ena_admin_acq_entry *cqe)
     463                 :            : {
     464                 :            :         struct ena_comp_ctx *comp_ctx;
     465                 :            :         u16 cmd_id;
     466                 :            : 
     467                 :          0 :         cmd_id = cqe->acq_common_descriptor.command &
     468                 :            :                 ENA_ADMIN_ACQ_COMMON_DESC_COMMAND_ID_MASK;
     469                 :            : 
     470                 :          0 :         comp_ctx = get_comp_ctxt(admin_queue, cmd_id, false);
     471         [ #  # ]:          0 :         if (unlikely(!comp_ctx)) {
     472                 :          0 :                 ena_trc_err(admin_queue->ena_dev,
     473                 :            :                             "comp_ctx is NULL. Changing the admin queue running state\n");
     474                 :          0 :                 admin_queue->running_state = false;
     475                 :          0 :                 return;
     476                 :            :         }
     477                 :            : 
     478         [ #  # ]:          0 :         if (!comp_ctx->occupied)
     479                 :            :                 return;
     480                 :            : 
     481                 :          0 :         comp_ctx->status = ENA_CMD_COMPLETED;
     482                 :          0 :         comp_ctx->comp_status = cqe->acq_common_descriptor.status;
     483                 :            : 
     484         [ #  # ]:          0 :         if (comp_ctx->user_cqe)
     485         [ #  # ]:          0 :                 memcpy(comp_ctx->user_cqe, (void *)cqe, comp_ctx->comp_size);
     486                 :            : 
     487         [ #  # ]:          0 :         if (!admin_queue->polling)
     488                 :          0 :                 ENA_WAIT_EVENT_SIGNAL(comp_ctx->wait_event);
     489                 :            : }
     490                 :            : 
     491                 :          0 : static void ena_com_handle_admin_completion(struct ena_com_admin_queue *admin_queue)
     492                 :            : {
     493                 :            :         struct ena_admin_acq_entry *cqe = NULL;
     494                 :            :         u16 comp_num = 0;
     495                 :            :         u16 head_masked;
     496                 :            :         u8 phase;
     497                 :            : 
     498                 :          0 :         head_masked = admin_queue->cq.head & (admin_queue->q_depth - 1);
     499                 :          0 :         phase = admin_queue->cq.phase;
     500                 :            : 
     501                 :          0 :         cqe = &admin_queue->cq.entries[head_masked];
     502                 :            : 
     503                 :            :         /* Go over all the completions */
     504                 :          0 :         while ((READ_ONCE8(cqe->acq_common_descriptor.flags) &
     505         [ #  # ]:          0 :                         ENA_ADMIN_ACQ_COMMON_DESC_PHASE_MASK) == phase) {
     506                 :            :                 /* Do not read the rest of the completion entry before the
     507                 :            :                  * phase bit was validated
     508                 :            :                  */
     509                 :            :                 dma_rmb();
     510                 :          0 :                 ena_com_handle_single_admin_completion(admin_queue, cqe);
     511                 :            : 
     512                 :          0 :                 head_masked++;
     513                 :          0 :                 comp_num++;
     514         [ #  # ]:          0 :                 if (unlikely(head_masked == admin_queue->q_depth)) {
     515                 :            :                         head_masked = 0;
     516                 :          0 :                         phase = !phase;
     517                 :            :                 }
     518                 :            : 
     519                 :          0 :                 cqe = &admin_queue->cq.entries[head_masked];
     520                 :            :         }
     521                 :            : 
     522                 :          0 :         admin_queue->cq.head += comp_num;
     523                 :          0 :         admin_queue->cq.phase = phase;
     524                 :          0 :         admin_queue->sq.head += comp_num;
     525                 :          0 :         admin_queue->stats.completed_cmd += comp_num;
     526                 :          0 : }
     527                 :            : 
     528                 :          0 : static int ena_com_comp_status_to_errno(struct ena_com_admin_queue *admin_queue,
     529                 :            :                                         u8 comp_status)
     530                 :            : {
     531         [ #  # ]:          0 :         if (unlikely(comp_status != 0))
     532                 :          0 :                 ena_trc_err(admin_queue->ena_dev,
     533                 :            :                             "Admin command failed[%u]\n", comp_status);
     534                 :            : 
     535                 :            :         switch (comp_status) {
     536                 :            :         case ENA_ADMIN_SUCCESS:
     537                 :            :                 return ENA_COM_OK;
     538                 :            :         case ENA_ADMIN_RESOURCE_ALLOCATION_FAILURE:
     539                 :            :                 return ENA_COM_NO_MEM;
     540                 :            :         case ENA_ADMIN_UNSUPPORTED_OPCODE:
     541                 :            :                 return ENA_COM_UNSUPPORTED;
     542                 :            :         case ENA_ADMIN_BAD_OPCODE:
     543                 :            :         case ENA_ADMIN_MALFORMED_REQUEST:
     544                 :            :         case ENA_ADMIN_ILLEGAL_PARAMETER:
     545                 :            :         case ENA_ADMIN_UNKNOWN_ERROR:
     546                 :            :                 return ENA_COM_INVAL;
     547                 :            :         case ENA_ADMIN_RESOURCE_BUSY:
     548                 :            :                 return ENA_COM_TRY_AGAIN;
     549                 :            :         }
     550                 :            : 
     551                 :            :         return ENA_COM_INVAL;
     552                 :            : }
     553                 :            : 
     554                 :            : static void ena_delay_exponential_backoff_us(u32 exp, u32 delay_us)
     555                 :            : {
     556                 :          0 :         exp = ENA_MIN32(ENA_MAX_BACKOFF_DELAY_EXP, exp);
     557                 :          0 :         delay_us = ENA_MAX32(ENA_MIN_ADMIN_POLL_US, delay_us);
     558                 :          0 :         delay_us = ENA_MIN32(ENA_MAX_ADMIN_POLL_US, delay_us * (1U << exp));
     559                 :          0 :         ENA_USLEEP(delay_us);
     560                 :          0 : }
     561                 :            : 
     562                 :          0 : static int ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx *comp_ctx,
     563                 :            :                                                      struct ena_com_admin_queue *admin_queue)
     564                 :            : {
     565                 :            :         unsigned long flags = 0;
     566                 :            :         ena_time_t timeout;
     567                 :            :         int ret;
     568                 :            :         u32 exp = 0;
     569                 :            : 
     570                 :          0 :         timeout = ENA_GET_SYSTEM_TIMEOUT(admin_queue->completion_timeout);
     571                 :            : 
     572                 :            :         while (1) {
     573                 :          0 :                 ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
     574                 :          0 :                 ena_com_handle_admin_completion(admin_queue);
     575                 :            :                 ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
     576                 :            : 
     577         [ #  # ]:          0 :                 if (comp_ctx->status != ENA_CMD_SUBMITTED)
     578                 :            :                         break;
     579                 :            : 
     580         [ #  # ]:          0 :                 if (unlikely(ENA_TIME_EXPIRE(timeout))) {
     581                 :          0 :                         ena_trc_err(admin_queue->ena_dev,
     582                 :            :                                     "Wait for completion (polling) timeout\n");
     583                 :            :                         /* ENA didn't have any completion */
     584                 :            :                         ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
     585                 :          0 :                         admin_queue->stats.no_completion++;
     586                 :          0 :                         admin_queue->running_state = false;
     587                 :            :                         ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
     588                 :            : 
     589                 :            :                         ret = ENA_COM_TIMER_EXPIRED;
     590                 :          0 :                         goto err;
     591                 :            :                 }
     592                 :            : 
     593                 :          0 :                 ena_delay_exponential_backoff_us(exp++,
     594                 :          0 :                                                  admin_queue->ena_dev->ena_min_poll_delay_us);
     595                 :            :         }
     596                 :            : 
     597         [ #  # ]:          0 :         if (unlikely(comp_ctx->status == ENA_CMD_ABORTED)) {
     598                 :          0 :                 ena_trc_err(admin_queue->ena_dev, "Command was aborted\n");
     599                 :            :                 ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
     600                 :          0 :                 admin_queue->stats.aborted_cmd++;
     601                 :            :                 ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
     602                 :            :                 ret = ENA_COM_NO_DEVICE;
     603                 :          0 :                 goto err;
     604                 :            :         }
     605                 :            : 
     606         [ #  # ]:          0 :         ENA_WARN(comp_ctx->status != ENA_CMD_COMPLETED,
     607                 :            :                  admin_queue->ena_dev, "Invalid comp status %d\n",
     608                 :            :                  comp_ctx->status);
     609                 :            : 
     610                 :          0 :         ret = ena_com_comp_status_to_errno(admin_queue, comp_ctx->comp_status);
     611                 :          0 : err:
     612                 :            :         comp_ctxt_release(admin_queue, comp_ctx);
     613                 :          0 :         return ret;
     614                 :            : }
     615                 :            : 
     616                 :            : /*
     617                 :            :  * Set the LLQ configurations of the firmware
     618                 :            :  *
     619                 :            :  * The driver provides only the enabled feature values to the device,
     620                 :            :  * which in turn, checks if they are supported.
     621                 :            :  */
     622                 :          0 : static int ena_com_set_llq(struct ena_com_dev *ena_dev)
     623                 :            : {
     624                 :            :         struct ena_com_admin_queue *admin_queue;
     625                 :            :         struct ena_admin_set_feat_cmd cmd;
     626                 :            :         struct ena_admin_set_feat_resp resp;
     627                 :            :         struct ena_com_llq_info *llq_info = &ena_dev->llq_info;
     628                 :            :         int ret;
     629                 :            : 
     630                 :            :         memset(&cmd, 0x0, sizeof(cmd));
     631                 :          0 :         admin_queue = &ena_dev->admin_queue;
     632                 :            : 
     633                 :          0 :         cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
     634                 :          0 :         cmd.feat_common.feature_id = ENA_ADMIN_LLQ;
     635                 :            : 
     636                 :          0 :         cmd.u.llq.header_location_ctrl_enabled = llq_info->header_location_ctrl;
     637                 :          0 :         cmd.u.llq.entry_size_ctrl_enabled = llq_info->desc_list_entry_size_ctrl;
     638                 :          0 :         cmd.u.llq.desc_num_before_header_enabled = llq_info->descs_num_before_header;
     639                 :          0 :         cmd.u.llq.descriptors_stride_ctrl_enabled = llq_info->desc_stride_ctrl;
     640                 :            : 
     641                 :          0 :         cmd.u.llq.accel_mode.u.set.enabled_flags =
     642                 :            :                 BIT(ENA_ADMIN_DISABLE_META_CACHING) |
     643                 :            :                 BIT(ENA_ADMIN_LIMIT_TX_BURST);
     644                 :            : 
     645                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
     646                 :            :                                             (struct ena_admin_aq_entry *)&cmd,
     647                 :            :                                             sizeof(cmd),
     648                 :            :                                             (struct ena_admin_acq_entry *)&resp,
     649                 :            :                                             sizeof(resp));
     650                 :            : 
     651         [ #  # ]:          0 :         if (unlikely(ret))
     652                 :          0 :                 ena_trc_err(ena_dev, "Failed to set LLQ configurations: %d\n", ret);
     653                 :            : 
     654                 :          0 :         return ret;
     655                 :            : }
     656                 :            : 
     657                 :          0 : static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
     658                 :            :                                    struct ena_admin_feature_llq_desc *llq_features,
     659                 :            :                                    struct ena_llq_configurations *llq_default_cfg)
     660                 :            : {
     661         [ #  # ]:          0 :         struct ena_com_llq_info *llq_info = &ena_dev->llq_info;
     662                 :            :         struct ena_admin_accel_mode_get llq_accel_mode_get;
     663                 :            :         u16 supported_feat;
     664                 :            :         int rc;
     665                 :            : 
     666                 :            :         memset(llq_info, 0, sizeof(*llq_info));
     667                 :            : 
     668                 :          0 :         supported_feat = llq_features->header_location_ctrl_supported;
     669                 :            : 
     670         [ #  # ]:          0 :         if (likely(supported_feat & llq_default_cfg->llq_header_location)) {
     671                 :          0 :                 llq_info->header_location_ctrl =
     672                 :            :                         llq_default_cfg->llq_header_location;
     673                 :            :         } else {
     674                 :          0 :                 ena_trc_err(ena_dev, "Invalid header location control, supported: 0x%x\n",
     675                 :            :                             supported_feat);
     676                 :          0 :                 return ENA_COM_INVAL;
     677                 :            :         }
     678                 :            : 
     679         [ #  # ]:          0 :         if (likely(llq_info->header_location_ctrl == ENA_ADMIN_INLINE_HEADER)) {
     680                 :          0 :                 supported_feat = llq_features->descriptors_stride_ctrl_supported;
     681         [ #  # ]:          0 :                 if (likely(supported_feat & llq_default_cfg->llq_stride_ctrl)) {
     682                 :          0 :                         llq_info->desc_stride_ctrl = llq_default_cfg->llq_stride_ctrl;
     683                 :            :                 } else  {
     684         [ #  # ]:          0 :                         if (supported_feat & ENA_ADMIN_MULTIPLE_DESCS_PER_ENTRY) {
     685                 :          0 :                                 llq_info->desc_stride_ctrl = ENA_ADMIN_MULTIPLE_DESCS_PER_ENTRY;
     686         [ #  # ]:          0 :                         } else if (supported_feat & ENA_ADMIN_SINGLE_DESC_PER_ENTRY) {
     687                 :          0 :                                 llq_info->desc_stride_ctrl = ENA_ADMIN_SINGLE_DESC_PER_ENTRY;
     688                 :            :                         } else {
     689                 :          0 :                                 ena_trc_err(ena_dev, "Invalid desc_stride_ctrl, supported: 0x%x\n",
     690                 :            :                                             supported_feat);
     691                 :          0 :                                 return ENA_COM_INVAL;
     692                 :            :                         }
     693                 :            : 
     694                 :          0 :                         ena_trc_err(ena_dev, "Default llq stride ctrl is not supported, performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
     695                 :            :                                     llq_default_cfg->llq_stride_ctrl,
     696                 :            :                                     supported_feat,
     697                 :            :                                     llq_info->desc_stride_ctrl);
     698                 :            :                 }
     699                 :            :         } else {
     700                 :          0 :                 llq_info->desc_stride_ctrl = 0;
     701                 :            :         }
     702                 :            : 
     703                 :          0 :         supported_feat = llq_features->entry_size_ctrl_supported;
     704         [ #  # ]:          0 :         if (likely(supported_feat & llq_default_cfg->llq_ring_entry_size)) {
     705                 :          0 :                 llq_info->desc_list_entry_size_ctrl = llq_default_cfg->llq_ring_entry_size;
     706                 :          0 :                 llq_info->desc_list_entry_size = llq_default_cfg->llq_ring_entry_size_value;
     707                 :            :         } else {
     708         [ #  # ]:          0 :                 if (supported_feat & ENA_ADMIN_LIST_ENTRY_SIZE_128B) {
     709                 :          0 :                         llq_info->desc_list_entry_size_ctrl = ENA_ADMIN_LIST_ENTRY_SIZE_128B;
     710                 :          0 :                         llq_info->desc_list_entry_size = 128;
     711         [ #  # ]:          0 :                 } else if (supported_feat & ENA_ADMIN_LIST_ENTRY_SIZE_192B) {
     712                 :          0 :                         llq_info->desc_list_entry_size_ctrl = ENA_ADMIN_LIST_ENTRY_SIZE_192B;
     713                 :          0 :                         llq_info->desc_list_entry_size = 192;
     714         [ #  # ]:          0 :                 } else if (supported_feat & ENA_ADMIN_LIST_ENTRY_SIZE_256B) {
     715                 :          0 :                         llq_info->desc_list_entry_size_ctrl = ENA_ADMIN_LIST_ENTRY_SIZE_256B;
     716                 :          0 :                         llq_info->desc_list_entry_size = 256;
     717                 :            :                 } else {
     718                 :          0 :                         ena_trc_err(ena_dev, "Invalid entry_size_ctrl, supported: 0x%x\n",
     719                 :            :                                     supported_feat);
     720                 :          0 :                         return ENA_COM_INVAL;
     721                 :            :                 }
     722                 :            : 
     723                 :          0 :                 ena_trc_err(ena_dev, "Default llq ring entry size is not supported, performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
     724                 :            :                             llq_default_cfg->llq_ring_entry_size,
     725                 :            :                             supported_feat,
     726                 :            :                             llq_info->desc_list_entry_size);
     727                 :            :         }
     728         [ #  # ]:          0 :         if (unlikely(llq_info->desc_list_entry_size & 0x7)) {
     729                 :            :                 /* The desc list entry size should be whole multiply of 8
     730                 :            :                  * This requirement comes from __iowrite64_copy()
     731                 :            :                  */
     732                 :          0 :                 ena_trc_err(ena_dev, "Illegal entry size %d\n",
     733                 :            :                             llq_info->desc_list_entry_size);
     734                 :          0 :                 return ENA_COM_INVAL;
     735                 :            :         }
     736                 :            : 
     737         [ #  # ]:          0 :         if (llq_info->desc_stride_ctrl == ENA_ADMIN_MULTIPLE_DESCS_PER_ENTRY)
     738                 :          0 :                 llq_info->descs_per_entry = llq_info->desc_list_entry_size /
     739                 :            :                         sizeof(struct ena_eth_io_tx_desc);
     740                 :            :         else
     741                 :          0 :                 llq_info->descs_per_entry = 1;
     742                 :            : 
     743                 :          0 :         supported_feat = llq_features->desc_num_before_header_supported;
     744         [ #  # ]:          0 :         if (likely(supported_feat & llq_default_cfg->llq_num_decs_before_header)) {
     745                 :          0 :                 llq_info->descs_num_before_header = llq_default_cfg->llq_num_decs_before_header;
     746                 :            :         } else {
     747         [ #  # ]:          0 :                 if (supported_feat & ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_2) {
     748                 :          0 :                         llq_info->descs_num_before_header = ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_2;
     749         [ #  # ]:          0 :                 } else if (supported_feat & ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_1) {
     750                 :          0 :                         llq_info->descs_num_before_header = ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_1;
     751         [ #  # ]:          0 :                 } else if (supported_feat & ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_4) {
     752                 :          0 :                         llq_info->descs_num_before_header = ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_4;
     753         [ #  # ]:          0 :                 } else if (supported_feat & ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_8) {
     754                 :          0 :                         llq_info->descs_num_before_header = ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_8;
     755                 :            :                 } else {
     756                 :          0 :                         ena_trc_err(ena_dev, "Invalid descs_num_before_header, supported: 0x%x\n",
     757                 :            :                                     supported_feat);
     758                 :          0 :                         return ENA_COM_INVAL;
     759                 :            :                 }
     760                 :            : 
     761                 :          0 :                 ena_trc_err(ena_dev, "Default llq num descs before header is not supported, performing fallback, default: 0x%x, supported: 0x%x, used: 0x%x\n",
     762                 :            :                             llq_default_cfg->llq_num_decs_before_header,
     763                 :            :                             supported_feat,
     764                 :            :                             llq_info->descs_num_before_header);
     765                 :            :         }
     766                 :            :         /* Check for accelerated queue supported */
     767                 :          0 :         llq_accel_mode_get = llq_features->accel_mode.u.get;
     768                 :            : 
     769                 :          0 :         llq_info->disable_meta_caching =
     770                 :          0 :                 !!(llq_accel_mode_get.supported_flags &
     771                 :            :                    BIT(ENA_ADMIN_DISABLE_META_CACHING));
     772                 :            : 
     773         [ #  # ]:          0 :         if (llq_accel_mode_get.supported_flags & BIT(ENA_ADMIN_LIMIT_TX_BURST))
     774                 :          0 :                 llq_info->max_entries_in_tx_burst =
     775                 :            :                         llq_accel_mode_get.max_tx_burst_size /
     776                 :          0 :                         llq_default_cfg->llq_ring_entry_size_value;
     777                 :            : 
     778                 :          0 :         rc = ena_com_set_llq(ena_dev);
     779         [ #  # ]:          0 :         if (unlikely(rc))
     780                 :          0 :                 ena_trc_err(ena_dev, "Cannot set LLQ configuration: %d\n", rc);
     781                 :            : 
     782                 :            :         return rc;
     783                 :            : }
     784                 :            : 
     785                 :          0 : static int ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx *comp_ctx,
     786                 :            :                                                         struct ena_com_admin_queue *admin_queue)
     787                 :            : {
     788                 :            :         unsigned long flags = 0;
     789                 :            :         int ret;
     790                 :            : 
     791   [ #  #  #  #  :          0 :         ENA_WAIT_EVENT_WAIT(comp_ctx->wait_event,
             #  #  #  # ]
     792                 :            :                             admin_queue->completion_timeout);
     793                 :            : 
     794                 :            :         /* In case the command wasn't completed find out the root cause.
     795                 :            :          * There might be 2 kinds of errors
     796                 :            :          * 1) No completion (timeout reached)
     797                 :            :          * 2) There is completion but the device didn't get any msi-x interrupt.
     798                 :            :          */
     799         [ #  # ]:          0 :         if (unlikely(comp_ctx->status == ENA_CMD_SUBMITTED)) {
     800                 :          0 :                 ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
     801                 :          0 :                 ena_com_handle_admin_completion(admin_queue);
     802                 :          0 :                 admin_queue->stats.no_completion++;
     803                 :            :                 ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
     804                 :            : 
     805         [ #  # ]:          0 :                 if (comp_ctx->status == ENA_CMD_COMPLETED) {
     806                 :          0 :                         admin_queue->is_missing_admin_interrupt = true;
     807         [ #  # ]:          0 :                         ena_trc_err(admin_queue->ena_dev,
     808                 :            :                                     "The ena device sent a completion but the driver didn't receive a MSI-X interrupt (cmd %d), autopolling mode is %s\n",
     809                 :            :                                     comp_ctx->cmd_opcode, admin_queue->auto_polling ? "ON" : "OFF");
     810                 :            :                         /* Check if fallback to polling is enabled */
     811         [ #  # ]:          0 :                         if (admin_queue->auto_polling)
     812                 :          0 :                                 admin_queue->polling = true;
     813                 :            :                 } else {
     814                 :          0 :                         ena_trc_err(admin_queue->ena_dev,
     815                 :            :                                     "The ena device didn't send a completion for the admin cmd %d status %d\n",
     816                 :            :                                     comp_ctx->cmd_opcode, comp_ctx->status);
     817                 :            :                 }
     818                 :            :                 /* Check if shifted to polling mode.
     819                 :            :                  * This will happen if there is a completion without an interrupt
     820                 :            :                  * and autopolling mode is enabled. Continuing normal execution in such case
     821                 :            :                  */
     822         [ #  # ]:          0 :                 if (!admin_queue->polling) {
     823                 :          0 :                         admin_queue->running_state = false;
     824                 :            :                         ret = ENA_COM_TIMER_EXPIRED;
     825                 :          0 :                         goto err;
     826                 :            :                 }
     827         [ #  # ]:          0 :         } else if (unlikely(comp_ctx->status == ENA_CMD_ABORTED)) {
     828                 :          0 :                 ena_trc_err(admin_queue->ena_dev, "Command was aborted\n");
     829                 :          0 :                 ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
     830                 :          0 :                 admin_queue->stats.aborted_cmd++;
     831                 :            :                 ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
     832                 :            :                 ret = ENA_COM_NO_DEVICE;
     833                 :          0 :                 goto err;
     834                 :            :         }
     835                 :            : 
     836         [ #  # ]:          0 :         ENA_WARN(comp_ctx->status != ENA_CMD_COMPLETED,
     837                 :            :                  admin_queue->ena_dev, "Invalid comp status %d\n",
     838                 :            :                  comp_ctx->status);
     839                 :            : 
     840                 :          0 :         ret = ena_com_comp_status_to_errno(admin_queue, comp_ctx->comp_status);
     841                 :          0 : err:
     842                 :            :         comp_ctxt_release(admin_queue, comp_ctx);
     843                 :          0 :         return ret;
     844                 :            : }
     845                 :            : 
     846                 :            : /* This method read the hardware device register through posting writes
     847                 :            :  * and waiting for response
     848                 :            :  * On timeout the function will return ENA_MMIO_READ_TIMEOUT
     849                 :            :  */
     850                 :          0 : static u32 ena_com_reg_bar_read32(struct ena_com_dev *ena_dev, u16 offset)
     851                 :            : {
     852                 :            :         struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
     853                 :          0 :         volatile struct ena_admin_ena_mmio_req_read_less_resp *read_resp =
     854                 :            :                 mmio_read->read_resp;
     855                 :            :         u32 mmio_read_reg, ret, i;
     856                 :            :         unsigned long flags = 0;
     857                 :          0 :         u32 timeout = mmio_read->reg_read_to;
     858                 :            : 
     859                 :            :         ENA_MIGHT_SLEEP();
     860                 :            : 
     861         [ #  # ]:          0 :         if (timeout == 0)
     862                 :            :                 timeout = ENA_REG_READ_TIMEOUT;
     863                 :            : 
     864                 :            :         /* If readless is disabled, perform regular read */
     865         [ #  # ]:          0 :         if (!mmio_read->readless_supported)
     866                 :          0 :                 return ENA_REG_READ32(ena_dev->bus, ena_dev->reg_bar + offset);
     867                 :            : 
     868                 :          0 :         ENA_SPINLOCK_LOCK(mmio_read->lock, flags);
     869                 :          0 :         mmio_read->seq_num++;
     870                 :            : 
     871                 :          0 :         read_resp->req_id = mmio_read->seq_num + 0xDEAD;
     872                 :          0 :         mmio_read_reg = (offset << ENA_REGS_MMIO_REG_READ_REG_OFF_SHIFT) &
     873                 :            :                         ENA_REGS_MMIO_REG_READ_REG_OFF_MASK;
     874                 :          0 :         mmio_read_reg |= mmio_read->seq_num &
     875                 :            :                         ENA_REGS_MMIO_REG_READ_REQ_ID_MASK;
     876                 :            : 
     877                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, mmio_read_reg,
     878                 :            :                         ena_dev->reg_bar + ENA_REGS_MMIO_REG_READ_OFF);
     879                 :            : 
     880         [ #  # ]:          0 :         for (i = 0; i < timeout; i++) {
     881         [ #  # ]:          0 :                 if (READ_ONCE16(read_resp->req_id) == mmio_read->seq_num)
     882                 :            :                         break;
     883                 :            : 
     884                 :          0 :                 ENA_UDELAY(1);
     885                 :            :         }
     886                 :            : 
     887         [ #  # ]:          0 :         if (unlikely(i == timeout)) {
     888                 :          0 :                 ena_trc_err(ena_dev, "Reading reg failed for timeout. expected: req id[%u] offset[%u] actual: req id[%u] offset[%u]\n",
     889                 :            :                             mmio_read->seq_num,
     890                 :            :                             offset,
     891                 :            :                             read_resp->req_id,
     892                 :            :                             read_resp->reg_off);
     893                 :            :                 ret = ENA_MMIO_READ_TIMEOUT;
     894                 :          0 :                 goto err;
     895                 :            :         }
     896                 :            : 
     897         [ #  # ]:          0 :         if (unlikely(read_resp->reg_off != offset)) {
     898                 :          0 :                 ena_trc_err(ena_dev, "Read failure: wrong offset provided\n");
     899                 :            :                 ret = ENA_MMIO_READ_TIMEOUT;
     900                 :            :         } else {
     901                 :          0 :                 ret = read_resp->reg_val;
     902                 :            :         }
     903                 :          0 : err:
     904                 :            :         ENA_SPINLOCK_UNLOCK(mmio_read->lock, flags);
     905                 :            : 
     906                 :          0 :         return ret;
     907                 :            : }
     908                 :            : 
     909                 :            : /* There are two types to wait for completion.
     910                 :            :  * Polling mode - wait until the completion is available.
     911                 :            :  * Async mode - wait on wait queue until the completion is ready
     912                 :            :  * (or the timeout expired).
     913                 :            :  * It is expected that the IRQ called ena_com_handle_admin_completion
     914                 :            :  * to mark the completions.
     915                 :            :  */
     916                 :          0 : static int ena_com_wait_and_process_admin_cq(struct ena_comp_ctx *comp_ctx,
     917                 :            :                                              struct ena_com_admin_queue *admin_queue)
     918                 :            : {
     919         [ #  # ]:          0 :         if (admin_queue->polling)
     920                 :          0 :                 return ena_com_wait_and_process_admin_cq_polling(comp_ctx,
     921                 :            :                                                                  admin_queue);
     922                 :            : 
     923                 :          0 :         return ena_com_wait_and_process_admin_cq_interrupts(comp_ctx,
     924                 :            :                                                             admin_queue);
     925                 :            : }
     926                 :            : 
     927                 :          0 : static int ena_com_destroy_io_sq(struct ena_com_dev *ena_dev,
     928                 :            :                                  struct ena_com_io_sq *io_sq)
     929                 :            : {
     930         [ #  # ]:          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
     931                 :            :         struct ena_admin_aq_destroy_sq_cmd destroy_cmd;
     932                 :            :         struct ena_admin_acq_destroy_sq_resp_desc destroy_resp;
     933                 :            :         u8 direction;
     934                 :            :         int ret;
     935                 :            : 
     936                 :            :         memset(&destroy_cmd, 0x0, sizeof(destroy_cmd));
     937                 :            : 
     938         [ #  # ]:          0 :         if (io_sq->direction == ENA_COM_IO_QUEUE_DIRECTION_TX)
     939                 :            :                 direction = ENA_ADMIN_SQ_DIRECTION_TX;
     940                 :            :         else
     941                 :            :                 direction = ENA_ADMIN_SQ_DIRECTION_RX;
     942                 :            : 
     943                 :          0 :         destroy_cmd.sq.sq_identity |= (direction <<
     944                 :            :                 ENA_ADMIN_SQ_SQ_DIRECTION_SHIFT) &
     945                 :            :                 ENA_ADMIN_SQ_SQ_DIRECTION_MASK;
     946                 :            : 
     947                 :          0 :         destroy_cmd.sq.sq_idx = io_sq->idx;
     948                 :          0 :         destroy_cmd.aq_common_descriptor.opcode = ENA_ADMIN_DESTROY_SQ;
     949                 :            : 
     950                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
     951                 :            :                                             (struct ena_admin_aq_entry *)&destroy_cmd,
     952                 :            :                                             sizeof(destroy_cmd),
     953                 :            :                                             (struct ena_admin_acq_entry *)&destroy_resp,
     954                 :            :                                             sizeof(destroy_resp));
     955                 :            : 
     956         [ #  # ]:          0 :         if (unlikely(ret && (ret != ENA_COM_NO_DEVICE)))
     957                 :          0 :                 ena_trc_err(ena_dev, "Failed to destroy io sq error: %d\n", ret);
     958                 :            : 
     959                 :          0 :         return ret;
     960                 :            : }
     961                 :            : 
     962                 :          0 : static void ena_com_io_queue_free(struct ena_com_dev *ena_dev,
     963                 :            :                                   struct ena_com_io_sq *io_sq,
     964                 :            :                                   struct ena_com_io_cq *io_cq)
     965                 :            : {
     966                 :            :         size_t size;
     967                 :            : 
     968         [ #  # ]:          0 :         if (io_cq->cdesc_addr.virt_addr) {
     969                 :            :                 size = io_cq->cdesc_entry_size_in_bytes * io_cq->q_depth;
     970                 :            : 
     971                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
     972                 :            :                                       size,
     973                 :            :                                       io_cq->cdesc_addr.virt_addr,
     974                 :            :                                       io_cq->cdesc_addr.phys_addr,
     975                 :            :                                       io_cq->cdesc_addr.mem_handle);
     976                 :            : 
     977                 :          0 :                 io_cq->cdesc_addr.virt_addr = NULL;
     978                 :            :         }
     979                 :            : 
     980         [ #  # ]:          0 :         if (io_sq->desc_addr.virt_addr) {
     981                 :            :                 size = io_sq->desc_entry_size * io_sq->q_depth;
     982                 :            : 
     983                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
     984                 :            :                                       size,
     985                 :            :                                       io_sq->desc_addr.virt_addr,
     986                 :            :                                       io_sq->desc_addr.phys_addr,
     987                 :            :                                       io_sq->desc_addr.mem_handle);
     988                 :            : 
     989                 :          0 :                 io_sq->desc_addr.virt_addr = NULL;
     990                 :            :         }
     991                 :            : 
     992         [ #  # ]:          0 :         if (io_sq->bounce_buf_ctrl.base_buffer) {
     993                 :          0 :                 ENA_MEM_FREE(ena_dev->dmadev,
     994                 :            :                              io_sq->bounce_buf_ctrl.base_buffer,
     995                 :            :                              (io_sq->llq_info.desc_list_entry_size * ENA_COM_BOUNCE_BUFFER_CNTRL_CNT));
     996                 :          0 :                 io_sq->bounce_buf_ctrl.base_buffer = NULL;
     997                 :            :         }
     998                 :          0 : }
     999                 :            : 
    1000                 :          0 : static int wait_for_reset_state(struct ena_com_dev *ena_dev, u32 timeout,
    1001                 :            :                                 u16 exp_state)
    1002                 :            : {
    1003                 :            :         u32 val, exp = 0;
    1004                 :            :         ena_time_t timeout_stamp;
    1005                 :            : 
    1006                 :            :         /* Convert timeout from resolution of 100ms to us resolution. */
    1007                 :          0 :         timeout_stamp = ENA_GET_SYSTEM_TIMEOUT(100 * 1000 * timeout);
    1008                 :            : 
    1009                 :            :         while (1) {
    1010                 :          0 :                 val = ena_com_reg_bar_read32(ena_dev, ENA_REGS_DEV_STS_OFF);
    1011                 :            : 
    1012         [ #  # ]:          0 :                 if (unlikely(val == ENA_MMIO_READ_TIMEOUT)) {
    1013                 :          0 :                         ena_trc_err(ena_dev, "Reg read timeout occurred\n");
    1014                 :          0 :                         return ENA_COM_TIMER_EXPIRED;
    1015                 :            :                 }
    1016                 :            : 
    1017         [ #  # ]:          0 :                 if ((val & ENA_REGS_DEV_STS_RESET_IN_PROGRESS_MASK) ==
    1018                 :            :                         exp_state)
    1019                 :            :                         return 0;
    1020                 :            : 
    1021         [ #  # ]:          0 :                 if (unlikely(ENA_TIME_EXPIRE(timeout_stamp)))
    1022                 :            :                         return ENA_COM_TIMER_EXPIRED;
    1023                 :            : 
    1024                 :          0 :                 ena_delay_exponential_backoff_us(exp++, ena_dev->ena_min_poll_delay_us);
    1025                 :            :         }
    1026                 :            : }
    1027                 :            : 
    1028                 :            : static bool ena_com_check_supported_feature_id(struct ena_com_dev *ena_dev,
    1029                 :            :                                                enum ena_admin_aq_feature_id feature_id)
    1030                 :            : {
    1031                 :          0 :         u32 feature_mask = 1 << feature_id;
    1032                 :            : 
    1033                 :            :         /* Device attributes is always supported */
    1034                 :          0 :         if ((feature_id != ENA_ADMIN_DEVICE_ATTRIBUTES) &&
    1035         [ #  # ]:          0 :             !(ena_dev->supported_features & feature_mask))
    1036                 :          0 :                 return false;
    1037                 :            : 
    1038                 :            :         return true;
    1039                 :            : }
    1040                 :            : 
    1041         [ #  # ]:          0 : static int ena_com_get_feature_ex(struct ena_com_dev *ena_dev,
    1042                 :            :                                   struct ena_admin_get_feat_resp *get_resp,
    1043                 :            :                                   enum ena_admin_aq_feature_id feature_id,
    1044                 :            :                                   dma_addr_t control_buf_dma_addr,
    1045                 :            :                                   u32 control_buff_size,
    1046                 :            :                                   u8 feature_ver)
    1047                 :            : {
    1048                 :            :         struct ena_com_admin_queue *admin_queue;
    1049                 :            :         struct ena_admin_get_feat_cmd get_cmd;
    1050                 :            :         int ret;
    1051                 :            : 
    1052                 :            :         if (!ena_com_check_supported_feature_id(ena_dev, feature_id)) {
    1053                 :          0 :                 ena_trc_dbg(ena_dev, "Feature %d isn't supported\n", feature_id);
    1054                 :          0 :                 return ENA_COM_UNSUPPORTED;
    1055                 :            :         }
    1056                 :            : 
    1057                 :            :         memset(&get_cmd, 0x0, sizeof(get_cmd));
    1058                 :          0 :         admin_queue = &ena_dev->admin_queue;
    1059                 :            : 
    1060                 :          0 :         get_cmd.aq_common_descriptor.opcode = ENA_ADMIN_GET_FEATURE;
    1061                 :            : 
    1062         [ #  # ]:          0 :         if (control_buff_size)
    1063                 :          0 :                 get_cmd.aq_common_descriptor.flags =
    1064                 :            :                         ENA_ADMIN_AQ_COMMON_DESC_CTRL_DATA_INDIRECT_MASK;
    1065                 :            :         else
    1066                 :            :                 get_cmd.aq_common_descriptor.flags = 0;
    1067                 :            : 
    1068                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    1069                 :            :                                    &get_cmd.control_buffer.address,
    1070                 :            :                                    control_buf_dma_addr);
    1071         [ #  # ]:          0 :         if (unlikely(ret)) {
    1072                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed\n");
    1073                 :          0 :                 return ret;
    1074                 :            :         }
    1075                 :            : 
    1076                 :          0 :         get_cmd.control_buffer.length = control_buff_size;
    1077                 :          0 :         get_cmd.feat_common.feature_version = feature_ver;
    1078                 :          0 :         get_cmd.feat_common.feature_id = feature_id;
    1079                 :            : 
    1080                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    1081                 :            :                                             (struct ena_admin_aq_entry *)
    1082                 :            :                                             &get_cmd,
    1083                 :            :                                             sizeof(get_cmd),
    1084                 :            :                                             (struct ena_admin_acq_entry *)
    1085                 :            :                                             get_resp,
    1086                 :            :                                             sizeof(*get_resp));
    1087                 :            : 
    1088         [ #  # ]:          0 :         if (unlikely(ret))
    1089                 :          0 :                 ena_trc_err(ena_dev, "Failed to submit get_feature command %d error: %d\n",
    1090                 :            :                             feature_id, ret);
    1091                 :            : 
    1092                 :            :         return ret;
    1093                 :            : }
    1094                 :            : 
    1095                 :            : static int ena_com_get_feature(struct ena_com_dev *ena_dev,
    1096                 :            :                                struct ena_admin_get_feat_resp *get_resp,
    1097                 :            :                                enum ena_admin_aq_feature_id feature_id,
    1098                 :            :                                u8 feature_ver)
    1099                 :            : {
    1100                 :          0 :         return ena_com_get_feature_ex(ena_dev,
    1101                 :            :                                       get_resp,
    1102                 :            :                                       feature_id,
    1103                 :            :                                       0,
    1104                 :            :                                       0,
    1105                 :            :                                       feature_ver);
    1106                 :            : }
    1107                 :            : 
    1108                 :          0 : int ena_com_get_current_hash_function(struct ena_com_dev *ena_dev)
    1109                 :            : {
    1110                 :          0 :         return ena_dev->rss.hash_func;
    1111                 :            : }
    1112                 :            : 
    1113                 :            : static void ena_com_hash_key_fill_default_key(struct ena_com_dev *ena_dev)
    1114                 :            : {
    1115                 :          0 :         struct ena_admin_feature_rss_flow_hash_control *hash_key =
    1116                 :            :                 (ena_dev->rss).hash_key;
    1117                 :            : 
    1118                 :          0 :         ENA_RSS_FILL_KEY(&hash_key->key, sizeof(hash_key->key));
    1119                 :            :         /* The key buffer is stored in the device in an array of
    1120                 :            :          * uint32 elements.
    1121                 :            :          */
    1122                 :          0 :         hash_key->key_parts = ENA_ADMIN_RSS_KEY_PARTS;
    1123                 :          0 : }
    1124                 :            : 
    1125         [ #  # ]:          0 : static int ena_com_hash_key_allocate(struct ena_com_dev *ena_dev)
    1126                 :            : {
    1127                 :            :         struct ena_rss *rss = &ena_dev->rss;
    1128                 :            : 
    1129                 :            :         if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_RSS_HASH_FUNCTION))
    1130                 :            :                 return ENA_COM_UNSUPPORTED;
    1131                 :            : 
    1132                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    1133                 :            :                                sizeof(*rss->hash_key),
    1134                 :            :                                rss->hash_key,
    1135                 :            :                                rss->hash_key_dma_addr,
    1136                 :            :                                rss->hash_key_mem_handle);
    1137                 :            : 
    1138         [ #  # ]:          0 :         if (unlikely(!rss->hash_key))
    1139                 :          0 :                 return ENA_COM_NO_MEM;
    1140                 :            : 
    1141                 :            :         return 0;
    1142                 :            : }
    1143                 :            : 
    1144                 :            : static void ena_com_hash_key_destroy(struct ena_com_dev *ena_dev)
    1145                 :            : {
    1146                 :            :         struct ena_rss *rss = &ena_dev->rss;
    1147                 :            : 
    1148         [ #  # ]:          0 :         if (rss->hash_key)
    1149                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    1150                 :            :                                       sizeof(*rss->hash_key),
    1151                 :            :                                       rss->hash_key,
    1152                 :            :                                       rss->hash_key_dma_addr,
    1153                 :            :                                       rss->hash_key_mem_handle);
    1154                 :          0 :         rss->hash_key = NULL;
    1155                 :          0 : }
    1156                 :            : 
    1157                 :          0 : static int ena_com_hash_ctrl_init(struct ena_com_dev *ena_dev)
    1158                 :            : {
    1159                 :            :         struct ena_rss *rss = &ena_dev->rss;
    1160                 :            : 
    1161                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    1162                 :            :                                sizeof(*rss->hash_ctrl),
    1163                 :            :                                rss->hash_ctrl,
    1164                 :            :                                rss->hash_ctrl_dma_addr,
    1165                 :            :                                rss->hash_ctrl_mem_handle);
    1166                 :            : 
    1167         [ #  # ]:          0 :         if (unlikely(!rss->hash_ctrl))
    1168                 :          0 :                 return ENA_COM_NO_MEM;
    1169                 :            : 
    1170                 :            :         return 0;
    1171                 :            : }
    1172                 :            : 
    1173                 :            : static void ena_com_hash_ctrl_destroy(struct ena_com_dev *ena_dev)
    1174                 :            : {
    1175                 :            :         struct ena_rss *rss = &ena_dev->rss;
    1176                 :            : 
    1177         [ #  # ]:          0 :         if (rss->hash_ctrl)
    1178                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    1179                 :            :                                       sizeof(*rss->hash_ctrl),
    1180                 :            :                                       rss->hash_ctrl,
    1181                 :            :                                       rss->hash_ctrl_dma_addr,
    1182                 :            :                                       rss->hash_ctrl_mem_handle);
    1183                 :            :         rss->hash_ctrl = NULL;
    1184                 :            : }
    1185                 :            : 
    1186                 :          0 : static int ena_com_indirect_table_allocate(struct ena_com_dev *ena_dev,
    1187                 :            :                                            u16 log_size)
    1188                 :            : {
    1189                 :            :         struct ena_rss *rss = &ena_dev->rss;
    1190                 :            :         struct ena_admin_get_feat_resp get_resp;
    1191                 :            :         size_t tbl_size;
    1192                 :            :         int ret;
    1193                 :            : 
    1194                 :            :         ret = ena_com_get_feature(ena_dev, &get_resp,
    1195                 :            :                                   ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG, 0);
    1196         [ #  # ]:          0 :         if (unlikely(ret))
    1197                 :            :                 return ret;
    1198                 :            : 
    1199         [ #  # ]:          0 :         if ((get_resp.u.ind_table.min_size > log_size) ||
    1200         [ #  # ]:          0 :             (get_resp.u.ind_table.max_size < log_size)) {
    1201                 :          0 :                 ena_trc_err(ena_dev, "Indirect table size doesn't fit. requested size: %d while min is:%d and max %d\n",
    1202                 :            :                             1 << log_size,
    1203                 :            :                             1 << get_resp.u.ind_table.min_size,
    1204                 :            :                             1 << get_resp.u.ind_table.max_size);
    1205                 :          0 :                 return ENA_COM_INVAL;
    1206                 :            :         }
    1207                 :            : 
    1208                 :          0 :         tbl_size = (1ULL << log_size) *
    1209                 :            :                 sizeof(struct ena_admin_rss_ind_table_entry);
    1210                 :            : 
    1211                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    1212                 :            :                              tbl_size,
    1213                 :            :                              rss->rss_ind_tbl,
    1214                 :            :                              rss->rss_ind_tbl_dma_addr,
    1215                 :            :                              rss->rss_ind_tbl_mem_handle);
    1216         [ #  # ]:          0 :         if (unlikely(!rss->rss_ind_tbl))
    1217                 :          0 :                 goto mem_err1;
    1218                 :            : 
    1219                 :          0 :         tbl_size = (1ULL << log_size) * sizeof(u16);
    1220                 :          0 :         rss->host_rss_ind_tbl =
    1221                 :          0 :                 ENA_MEM_ALLOC(ena_dev->dmadev, tbl_size);
    1222         [ #  # ]:          0 :         if (unlikely(!rss->host_rss_ind_tbl))
    1223                 :          0 :                 goto mem_err2;
    1224                 :            : 
    1225                 :          0 :         rss->tbl_log_size = log_size;
    1226                 :            : 
    1227                 :          0 :         return 0;
    1228                 :            : 
    1229                 :            : mem_err2:
    1230                 :            :         tbl_size = (1ULL << log_size) *
    1231                 :            :                 sizeof(struct ena_admin_rss_ind_table_entry);
    1232                 :            : 
    1233                 :          0 :         ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    1234                 :            :                               tbl_size,
    1235                 :            :                               rss->rss_ind_tbl,
    1236                 :            :                               rss->rss_ind_tbl_dma_addr,
    1237                 :            :                               rss->rss_ind_tbl_mem_handle);
    1238                 :          0 :         rss->rss_ind_tbl = NULL;
    1239                 :          0 : mem_err1:
    1240                 :          0 :         rss->tbl_log_size = 0;
    1241                 :          0 :         return ENA_COM_NO_MEM;
    1242                 :            : }
    1243                 :            : 
    1244                 :          0 : static void ena_com_indirect_table_destroy(struct ena_com_dev *ena_dev)
    1245                 :            : {
    1246                 :            :         struct ena_rss *rss = &ena_dev->rss;
    1247                 :            :         size_t tbl_size = (1ULL << rss->tbl_log_size) *
    1248                 :            :                 sizeof(struct ena_admin_rss_ind_table_entry);
    1249                 :            : 
    1250         [ #  # ]:          0 :         if (rss->rss_ind_tbl)
    1251                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    1252                 :            :                                       tbl_size,
    1253                 :            :                                       rss->rss_ind_tbl,
    1254                 :            :                                       rss->rss_ind_tbl_dma_addr,
    1255                 :            :                                       rss->rss_ind_tbl_mem_handle);
    1256                 :          0 :         rss->rss_ind_tbl = NULL;
    1257                 :            : 
    1258         [ #  # ]:          0 :         if (rss->host_rss_ind_tbl)
    1259                 :          0 :                 ENA_MEM_FREE(ena_dev->dmadev,
    1260                 :            :                              rss->host_rss_ind_tbl,
    1261                 :            :                              ((1ULL << rss->tbl_log_size) * sizeof(u16)));
    1262                 :          0 :         rss->host_rss_ind_tbl = NULL;
    1263                 :          0 : }
    1264                 :            : 
    1265                 :          0 : static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
    1266                 :            :                                 struct ena_com_io_sq *io_sq, u16 cq_idx)
    1267                 :            : {
    1268         [ #  # ]:          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    1269                 :            :         struct ena_admin_aq_create_sq_cmd create_cmd;
    1270                 :            :         struct ena_admin_acq_create_sq_resp_desc cmd_completion;
    1271                 :            :         u8 direction;
    1272                 :            :         int ret;
    1273                 :            : 
    1274                 :            :         memset(&create_cmd, 0x0, sizeof(create_cmd));
    1275                 :            : 
    1276                 :          0 :         create_cmd.aq_common_descriptor.opcode = ENA_ADMIN_CREATE_SQ;
    1277                 :            : 
    1278         [ #  # ]:          0 :         if (io_sq->direction == ENA_COM_IO_QUEUE_DIRECTION_TX)
    1279                 :            :                 direction = ENA_ADMIN_SQ_DIRECTION_TX;
    1280                 :            :         else
    1281                 :            :                 direction = ENA_ADMIN_SQ_DIRECTION_RX;
    1282                 :            : 
    1283                 :          0 :         create_cmd.sq_identity |= (direction <<
    1284                 :            :                 ENA_ADMIN_AQ_CREATE_SQ_CMD_SQ_DIRECTION_SHIFT) &
    1285                 :            :                 ENA_ADMIN_AQ_CREATE_SQ_CMD_SQ_DIRECTION_MASK;
    1286                 :            : 
    1287                 :          0 :         create_cmd.sq_caps_2 |= io_sq->mem_queue_type &
    1288                 :            :                 ENA_ADMIN_AQ_CREATE_SQ_CMD_PLACEMENT_POLICY_MASK;
    1289                 :            : 
    1290                 :            :         create_cmd.sq_caps_2 |= (ENA_ADMIN_COMPLETION_POLICY_DESC <<
    1291                 :            :                 ENA_ADMIN_AQ_CREATE_SQ_CMD_COMPLETION_POLICY_SHIFT) &
    1292                 :            :                 ENA_ADMIN_AQ_CREATE_SQ_CMD_COMPLETION_POLICY_MASK;
    1293                 :            : 
    1294                 :          0 :         create_cmd.sq_caps_3 |=
    1295                 :            :                 ENA_ADMIN_AQ_CREATE_SQ_CMD_IS_PHYSICALLY_CONTIGUOUS_MASK;
    1296                 :            : 
    1297                 :          0 :         create_cmd.cq_idx = cq_idx;
    1298                 :          0 :         create_cmd.sq_depth = io_sq->q_depth;
    1299                 :            : 
    1300         [ #  # ]:          0 :         if (io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_HOST) {
    1301                 :          0 :                 ret = ena_com_mem_addr_set(ena_dev,
    1302                 :            :                                            &create_cmd.sq_ba,
    1303                 :            :                                            io_sq->desc_addr.phys_addr);
    1304         [ #  # ]:          0 :                 if (unlikely(ret)) {
    1305                 :          0 :                         ena_trc_err(ena_dev, "Memory address set failed\n");
    1306                 :          0 :                         return ret;
    1307                 :            :                 }
    1308                 :            :         }
    1309                 :            : 
    1310                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    1311                 :            :                                             (struct ena_admin_aq_entry *)&create_cmd,
    1312                 :            :                                             sizeof(create_cmd),
    1313                 :            :                                             (struct ena_admin_acq_entry *)&cmd_completion,
    1314                 :            :                                             sizeof(cmd_completion));
    1315         [ #  # ]:          0 :         if (unlikely(ret)) {
    1316                 :          0 :                 ena_trc_err(ena_dev, "Failed to create IO SQ. error: %d\n", ret);
    1317                 :          0 :                 return ret;
    1318                 :            :         }
    1319                 :            : 
    1320                 :          0 :         io_sq->idx = cmd_completion.sq_idx;
    1321                 :            : 
    1322                 :          0 :         io_sq->db_addr = (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
    1323                 :          0 :                 (uintptr_t)cmd_completion.sq_doorbell_offset);
    1324                 :            : 
    1325         [ #  # ]:          0 :         if (io_sq->mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV) {
    1326                 :          0 :                 io_sq->desc_addr.pbuf_dev_addr =
    1327                 :          0 :                         (u8 __iomem *)((uintptr_t)ena_dev->mem_bar +
    1328                 :          0 :                         cmd_completion.llq_descriptors_offset);
    1329                 :            :         }
    1330                 :            : 
    1331                 :          0 :         ena_trc_dbg(ena_dev, "Created sq[%u], depth[%u]\n", io_sq->idx, io_sq->q_depth);
    1332                 :            : 
    1333                 :          0 :         return ret;
    1334                 :            : }
    1335                 :            : 
    1336                 :          0 : static int ena_com_ind_tbl_convert_to_device(struct ena_com_dev *ena_dev)
    1337                 :            : {
    1338                 :            :         struct ena_rss *rss = &ena_dev->rss;
    1339                 :            :         struct ena_com_io_sq *io_sq;
    1340                 :            :         u16 qid;
    1341                 :            :         int i;
    1342                 :            : 
    1343         [ #  # ]:          0 :         for (i = 0; i < 1 << rss->tbl_log_size; i++) {
    1344                 :          0 :                 qid = rss->host_rss_ind_tbl[i];
    1345         [ #  # ]:          0 :                 if (qid >= ENA_TOTAL_NUM_QUEUES)
    1346                 :            :                         return ENA_COM_INVAL;
    1347                 :            : 
    1348                 :          0 :                 io_sq = &ena_dev->io_sq_queues[qid];
    1349                 :            : 
    1350         [ #  # ]:          0 :                 if (io_sq->direction != ENA_COM_IO_QUEUE_DIRECTION_RX)
    1351                 :            :                         return ENA_COM_INVAL;
    1352                 :            : 
    1353                 :          0 :                 rss->rss_ind_tbl[i].cq_idx = io_sq->idx;
    1354                 :            :         }
    1355                 :            : 
    1356                 :            :         return 0;
    1357                 :            : }
    1358                 :            : 
    1359                 :          0 : static void ena_com_update_intr_delay_resolution(struct ena_com_dev *ena_dev,
    1360                 :            :                                                  u16 intr_delay_resolution)
    1361                 :            : {
    1362                 :          0 :         u16 prev_intr_delay_resolution = ena_dev->intr_delay_resolution;
    1363                 :            : 
    1364         [ #  # ]:          0 :         if (unlikely(!intr_delay_resolution)) {
    1365                 :          0 :                 ena_trc_err(ena_dev, "Illegal intr_delay_resolution provided. Going to use default 1 usec resolution\n");
    1366                 :            :                 intr_delay_resolution = ENA_DEFAULT_INTR_DELAY_RESOLUTION;
    1367                 :            :         }
    1368                 :            : 
    1369                 :            :         /* update Rx */
    1370                 :          0 :         ena_dev->intr_moder_rx_interval =
    1371                 :          0 :                 ena_dev->intr_moder_rx_interval *
    1372                 :          0 :                 prev_intr_delay_resolution /
    1373                 :            :                 intr_delay_resolution;
    1374                 :            : 
    1375                 :            :         /* update Tx */
    1376                 :          0 :         ena_dev->intr_moder_tx_interval =
    1377                 :          0 :                 ena_dev->intr_moder_tx_interval *
    1378                 :          0 :                 prev_intr_delay_resolution /
    1379                 :            :                 intr_delay_resolution;
    1380                 :            : 
    1381                 :          0 :         ena_dev->intr_delay_resolution = intr_delay_resolution;
    1382                 :          0 : }
    1383                 :            : 
    1384                 :            : /*****************************************************************************/
    1385                 :            : /*******************************      API       ******************************/
    1386                 :            : /*****************************************************************************/
    1387                 :            : 
    1388                 :          0 : int ena_com_execute_admin_command(struct ena_com_admin_queue *admin_queue,
    1389                 :            :                                   struct ena_admin_aq_entry *cmd,
    1390                 :            :                                   size_t cmd_size,
    1391                 :            :                                   struct ena_admin_acq_entry *comp,
    1392                 :            :                                   size_t comp_size)
    1393                 :            : {
    1394                 :            :         struct ena_comp_ctx *comp_ctx;
    1395                 :            :         int ret;
    1396                 :            : 
    1397                 :          0 :         comp_ctx = ena_com_submit_admin_cmd(admin_queue, cmd, cmd_size,
    1398                 :            :                                             comp, comp_size);
    1399         [ #  # ]:          0 :         if (IS_ERR(comp_ctx)) {
    1400                 :          0 :                 ret = PTR_ERR(comp_ctx);
    1401         [ #  # ]:          0 :                 if (ret == ENA_COM_NO_DEVICE)
    1402                 :          0 :                         ena_trc_dbg(admin_queue->ena_dev,
    1403                 :            :                                     "Failed to submit command [%d]\n",
    1404                 :            :                                     ret);
    1405                 :            :                 else
    1406                 :          0 :                         ena_trc_err(admin_queue->ena_dev,
    1407                 :            :                                     "Failed to submit command [%d]\n",
    1408                 :            :                                     ret);
    1409                 :            : 
    1410                 :          0 :                 return ret;
    1411                 :            :         }
    1412                 :            : 
    1413                 :          0 :         ret = ena_com_wait_and_process_admin_cq(comp_ctx, admin_queue);
    1414         [ #  # ]:          0 :         if (unlikely(ret)) {
    1415         [ #  # ]:          0 :                 if (admin_queue->running_state)
    1416                 :          0 :                         ena_trc_err(admin_queue->ena_dev,
    1417                 :            :                                     "Failed to process command. ret = %d\n", ret);
    1418                 :            :                 else
    1419                 :          0 :                         ena_trc_dbg(admin_queue->ena_dev,
    1420                 :            :                                     "Failed to process command. ret = %d\n", ret);
    1421                 :            :         }
    1422                 :            :         return ret;
    1423                 :            : }
    1424                 :            : 
    1425                 :          0 : int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
    1426                 :            :                          struct ena_com_io_cq *io_cq)
    1427                 :            : {
    1428                 :          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    1429                 :            :         struct ena_admin_aq_create_cq_cmd create_cmd;
    1430                 :            :         struct ena_admin_acq_create_cq_resp_desc cmd_completion;
    1431                 :            :         int ret;
    1432                 :            : 
    1433                 :            :         memset(&create_cmd, 0x0, sizeof(create_cmd));
    1434                 :            : 
    1435                 :          0 :         create_cmd.aq_common_descriptor.opcode = ENA_ADMIN_CREATE_CQ;
    1436                 :            : 
    1437                 :          0 :         create_cmd.cq_caps_2 |= (io_cq->cdesc_entry_size_in_bytes / 4) &
    1438                 :            :                 ENA_ADMIN_AQ_CREATE_CQ_CMD_CQ_ENTRY_SIZE_WORDS_MASK;
    1439                 :          0 :         create_cmd.cq_caps_1 |=
    1440                 :            :                 ENA_ADMIN_AQ_CREATE_CQ_CMD_INTERRUPT_MODE_ENABLED_MASK;
    1441                 :            : 
    1442                 :          0 :         create_cmd.msix_vector = io_cq->msix_vector;
    1443                 :          0 :         create_cmd.cq_depth = io_cq->q_depth;
    1444                 :            : 
    1445                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    1446                 :            :                                    &create_cmd.cq_ba,
    1447                 :            :                                    io_cq->cdesc_addr.phys_addr);
    1448         [ #  # ]:          0 :         if (unlikely(ret)) {
    1449                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed\n");
    1450                 :          0 :                 return ret;
    1451                 :            :         }
    1452                 :            : 
    1453                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    1454                 :            :                                             (struct ena_admin_aq_entry *)&create_cmd,
    1455                 :            :                                             sizeof(create_cmd),
    1456                 :            :                                             (struct ena_admin_acq_entry *)&cmd_completion,
    1457                 :            :                                             sizeof(cmd_completion));
    1458         [ #  # ]:          0 :         if (unlikely(ret)) {
    1459                 :          0 :                 ena_trc_err(ena_dev, "Failed to create IO CQ. error: %d\n", ret);
    1460                 :          0 :                 return ret;
    1461                 :            :         }
    1462                 :            : 
    1463                 :          0 :         io_cq->idx = cmd_completion.cq_idx;
    1464                 :            : 
    1465                 :          0 :         io_cq->unmask_reg = (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
    1466                 :          0 :                 cmd_completion.cq_interrupt_unmask_register_offset);
    1467                 :            : 
    1468         [ #  # ]:          0 :         if (cmd_completion.numa_node_register_offset)
    1469                 :          0 :                 io_cq->numa_node_cfg_reg =
    1470                 :          0 :                         (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
    1471                 :          0 :                         cmd_completion.numa_node_register_offset);
    1472                 :            : 
    1473                 :          0 :         ena_trc_dbg(ena_dev, "Created cq[%u], depth[%u]\n", io_cq->idx, io_cq->q_depth);
    1474                 :            : 
    1475                 :          0 :         return ret;
    1476                 :            : }
    1477                 :            : 
    1478                 :          0 : int ena_com_get_io_handlers(struct ena_com_dev *ena_dev, u16 qid,
    1479                 :            :                             struct ena_com_io_sq **io_sq,
    1480                 :            :                             struct ena_com_io_cq **io_cq)
    1481                 :            : {
    1482         [ #  # ]:          0 :         if (unlikely(qid >= ENA_TOTAL_NUM_QUEUES)) {
    1483                 :          0 :                 ena_trc_err(ena_dev, "Invalid queue number %d but the max is %d\n",
    1484                 :            :                             qid, ENA_TOTAL_NUM_QUEUES);
    1485                 :          0 :                 return ENA_COM_INVAL;
    1486                 :            :         }
    1487                 :            : 
    1488                 :          0 :         *io_sq = &ena_dev->io_sq_queues[qid];
    1489                 :          0 :         *io_cq = &ena_dev->io_cq_queues[qid];
    1490                 :            : 
    1491                 :          0 :         return 0;
    1492                 :            : }
    1493                 :            : 
    1494                 :          0 : void ena_com_abort_admin_commands(struct ena_com_dev *ena_dev)
    1495                 :            : {
    1496                 :          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    1497                 :            :         struct ena_comp_ctx *comp_ctx;
    1498                 :            :         u16 i;
    1499                 :            : 
    1500         [ #  # ]:          0 :         if (!admin_queue->comp_ctx)
    1501                 :            :                 return;
    1502                 :            : 
    1503         [ #  # ]:          0 :         for (i = 0; i < admin_queue->q_depth; i++) {
    1504                 :          0 :                 comp_ctx = get_comp_ctxt(admin_queue, i, false);
    1505         [ #  # ]:          0 :                 if (unlikely(!comp_ctx))
    1506                 :            :                         break;
    1507                 :            : 
    1508                 :          0 :                 comp_ctx->status = ENA_CMD_ABORTED;
    1509                 :            : 
    1510                 :          0 :                 ENA_WAIT_EVENT_SIGNAL(comp_ctx->wait_event);
    1511                 :            :         }
    1512                 :            : }
    1513                 :            : 
    1514                 :          0 : void ena_com_wait_for_abort_completion(struct ena_com_dev *ena_dev)
    1515                 :            : {
    1516                 :            :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    1517                 :            :         unsigned long flags = 0;
    1518                 :            :         u32 exp = 0;
    1519                 :            : 
    1520                 :          0 :         ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
    1521         [ #  # ]:          0 :         while (ATOMIC32_READ(&admin_queue->outstanding_cmds) != 0) {
    1522                 :            :                 ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
    1523                 :          0 :                 ena_delay_exponential_backoff_us(exp++, ena_dev->ena_min_poll_delay_us);
    1524                 :            :                 ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
    1525                 :            :         }
    1526                 :            :         ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
    1527                 :          0 : }
    1528                 :            : 
    1529                 :          0 : int ena_com_destroy_io_cq(struct ena_com_dev *ena_dev,
    1530                 :            :                           struct ena_com_io_cq *io_cq)
    1531                 :            : {
    1532                 :          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    1533                 :            :         struct ena_admin_aq_destroy_cq_cmd destroy_cmd;
    1534                 :            :         struct ena_admin_acq_destroy_cq_resp_desc destroy_resp;
    1535                 :            :         int ret;
    1536                 :            : 
    1537                 :            :         memset(&destroy_cmd, 0x0, sizeof(destroy_cmd));
    1538                 :            : 
    1539                 :          0 :         destroy_cmd.cq_idx = io_cq->idx;
    1540                 :          0 :         destroy_cmd.aq_common_descriptor.opcode = ENA_ADMIN_DESTROY_CQ;
    1541                 :            : 
    1542                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    1543                 :            :                                             (struct ena_admin_aq_entry *)&destroy_cmd,
    1544                 :            :                                             sizeof(destroy_cmd),
    1545                 :            :                                             (struct ena_admin_acq_entry *)&destroy_resp,
    1546                 :            :                                             sizeof(destroy_resp));
    1547                 :            : 
    1548         [ #  # ]:          0 :         if (unlikely(ret && (ret != ENA_COM_NO_DEVICE)))
    1549                 :          0 :                 ena_trc_err(ena_dev, "Failed to destroy IO CQ. error: %d\n", ret);
    1550                 :            : 
    1551                 :          0 :         return ret;
    1552                 :            : }
    1553                 :            : 
    1554                 :          0 : bool ena_com_get_admin_running_state(struct ena_com_dev *ena_dev)
    1555                 :            : {
    1556                 :          0 :         return ena_dev->admin_queue.running_state;
    1557                 :            : }
    1558                 :            : 
    1559                 :          0 : void ena_com_set_admin_running_state(struct ena_com_dev *ena_dev, bool state)
    1560                 :            : {
    1561                 :            :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    1562                 :            :         unsigned long flags = 0;
    1563                 :            : 
    1564                 :          0 :         ENA_SPINLOCK_LOCK(admin_queue->q_lock, flags);
    1565                 :          0 :         ena_dev->admin_queue.running_state = state;
    1566                 :            :         ENA_SPINLOCK_UNLOCK(admin_queue->q_lock, flags);
    1567                 :          0 : }
    1568                 :            : 
    1569                 :          0 : void ena_com_admin_aenq_enable(struct ena_com_dev *ena_dev)
    1570                 :            : {
    1571                 :          0 :         u16 depth = ena_dev->aenq.q_depth;
    1572                 :            : 
    1573         [ #  # ]:          0 :         ENA_WARN(ena_dev->aenq.head != depth, ena_dev, "Invalid AENQ state\n");
    1574                 :            : 
    1575                 :            :         /* Init head_db to mark that all entries in the queue
    1576                 :            :          * are initially available
    1577                 :            :          */
    1578                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, depth, ena_dev->reg_bar + ENA_REGS_AENQ_HEAD_DB_OFF);
    1579                 :          0 : }
    1580                 :            : 
    1581                 :          0 : int ena_com_set_aenq_config(struct ena_com_dev *ena_dev, u32 groups_flag)
    1582                 :            : {
    1583                 :            :         struct ena_com_admin_queue *admin_queue;
    1584                 :            :         struct ena_admin_set_feat_cmd cmd;
    1585                 :            :         struct ena_admin_set_feat_resp resp;
    1586                 :            :         struct ena_admin_get_feat_resp get_resp;
    1587                 :            :         int ret;
    1588                 :            : 
    1589                 :            :         ret = ena_com_get_feature(ena_dev, &get_resp, ENA_ADMIN_AENQ_CONFIG, 0);
    1590         [ #  # ]:          0 :         if (unlikely(ret)) {
    1591                 :          0 :                 ena_trc_info(ena_dev, "Can't get aenq configuration\n");
    1592                 :          0 :                 return ret;
    1593                 :            :         }
    1594                 :            : 
    1595         [ #  # ]:          0 :         if ((get_resp.u.aenq.supported_groups & groups_flag) != groups_flag) {
    1596                 :          0 :                 ena_trc_warn(ena_dev, "Trying to set unsupported aenq events. supported flag: 0x%x asked flag: 0x%x\n",
    1597                 :            :                              get_resp.u.aenq.supported_groups,
    1598                 :            :                              groups_flag);
    1599                 :          0 :                 return ENA_COM_UNSUPPORTED;
    1600                 :            :         }
    1601                 :            : 
    1602                 :            :         memset(&cmd, 0x0, sizeof(cmd));
    1603                 :          0 :         admin_queue = &ena_dev->admin_queue;
    1604                 :            : 
    1605                 :          0 :         cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
    1606                 :            :         cmd.aq_common_descriptor.flags = 0;
    1607                 :          0 :         cmd.feat_common.feature_id = ENA_ADMIN_AENQ_CONFIG;
    1608                 :          0 :         cmd.u.aenq.enabled_groups = groups_flag;
    1609                 :            : 
    1610                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    1611                 :            :                                             (struct ena_admin_aq_entry *)&cmd,
    1612                 :            :                                             sizeof(cmd),
    1613                 :            :                                             (struct ena_admin_acq_entry *)&resp,
    1614                 :            :                                             sizeof(resp));
    1615                 :            : 
    1616         [ #  # ]:          0 :         if (unlikely(ret))
    1617                 :          0 :                 ena_trc_err(ena_dev, "Failed to config AENQ ret: %d\n", ret);
    1618                 :            : 
    1619                 :            :         return ret;
    1620                 :            : }
    1621                 :            : 
    1622                 :          0 : int ena_com_get_dma_width(struct ena_com_dev *ena_dev)
    1623                 :            : {
    1624                 :          0 :         u32 caps = ena_com_reg_bar_read32(ena_dev, ENA_REGS_CAPS_OFF);
    1625                 :            :         u32 width;
    1626                 :            : 
    1627         [ #  # ]:          0 :         if (unlikely(caps == ENA_MMIO_READ_TIMEOUT)) {
    1628                 :          0 :                 ena_trc_err(ena_dev, "Reg read timeout occurred\n");
    1629                 :          0 :                 return ENA_COM_TIMER_EXPIRED;
    1630                 :            :         }
    1631                 :            : 
    1632                 :          0 :         width = (caps & ENA_REGS_CAPS_DMA_ADDR_WIDTH_MASK) >>
    1633                 :            :                 ENA_REGS_CAPS_DMA_ADDR_WIDTH_SHIFT;
    1634                 :            : 
    1635                 :          0 :         ena_trc_dbg(ena_dev, "ENA dma width: %d\n", width);
    1636                 :            : 
    1637         [ #  # ]:          0 :         if (unlikely(width < 32 || width > ENA_MAX_PHYS_ADDR_SIZE_BITS)) {
    1638                 :          0 :                 ena_trc_err(ena_dev, "DMA width illegal value: %d\n", width);
    1639                 :          0 :                 return ENA_COM_INVAL;
    1640                 :            :         }
    1641                 :            : 
    1642                 :          0 :         ena_dev->dma_addr_bits = width;
    1643                 :            : 
    1644                 :          0 :         return width;
    1645                 :            : }
    1646                 :            : 
    1647                 :          0 : int ena_com_validate_version(struct ena_com_dev *ena_dev)
    1648                 :            : {
    1649                 :            :         u32 ver;
    1650                 :            :         u32 ctrl_ver;
    1651                 :            :         u32 ctrl_ver_masked;
    1652                 :            : 
    1653                 :            :         /* Make sure the ENA version and the controller version are at least
    1654                 :            :          * as the driver expects
    1655                 :            :          */
    1656                 :          0 :         ver = ena_com_reg_bar_read32(ena_dev, ENA_REGS_VERSION_OFF);
    1657                 :          0 :         ctrl_ver = ena_com_reg_bar_read32(ena_dev,
    1658                 :            :                                           ENA_REGS_CONTROLLER_VERSION_OFF);
    1659                 :            : 
    1660         [ #  # ]:          0 :         if (unlikely((ver == ENA_MMIO_READ_TIMEOUT) ||
    1661                 :            :                      (ctrl_ver == ENA_MMIO_READ_TIMEOUT))) {
    1662                 :          0 :                 ena_trc_err(ena_dev, "Reg read timeout occurred\n");
    1663                 :          0 :                 return ENA_COM_TIMER_EXPIRED;
    1664                 :            :         }
    1665                 :            : 
    1666                 :          0 :         ena_trc_info(ena_dev, "ENA device version: %d.%d\n",
    1667                 :            :                      (ver & ENA_REGS_VERSION_MAJOR_VERSION_MASK) >>
    1668                 :            :                      ENA_REGS_VERSION_MAJOR_VERSION_SHIFT,
    1669                 :            :                      ver & ENA_REGS_VERSION_MINOR_VERSION_MASK);
    1670                 :            : 
    1671                 :          0 :         ena_trc_info(ena_dev, "ENA controller version: %d.%d.%d implementation version %d\n",
    1672                 :            :                      (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_MASK)
    1673                 :            :                      >> ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_SHIFT,
    1674                 :            :                      (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MINOR_VERSION_MASK)
    1675                 :            :                      >> ENA_REGS_CONTROLLER_VERSION_MINOR_VERSION_SHIFT,
    1676                 :            :                      (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_SUBMINOR_VERSION_MASK),
    1677                 :            :                      (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_IMPL_ID_MASK) >>
    1678                 :            :                      ENA_REGS_CONTROLLER_VERSION_IMPL_ID_SHIFT);
    1679                 :            : 
    1680                 :          0 :         ctrl_ver_masked =
    1681                 :            :                 (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MAJOR_VERSION_MASK) |
    1682                 :            :                 (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_MINOR_VERSION_MASK) |
    1683                 :            :                 (ctrl_ver & ENA_REGS_CONTROLLER_VERSION_SUBMINOR_VERSION_MASK);
    1684                 :            : 
    1685                 :            :         /* Validate the ctrl version without the implementation ID */
    1686         [ #  # ]:          0 :         if (ctrl_ver_masked < MIN_ENA_CTRL_VER) {
    1687                 :          0 :                 ena_trc_err(ena_dev, "ENA ctrl version is lower than the minimal ctrl version the driver supports\n");
    1688                 :          0 :                 return -1;
    1689                 :            :         }
    1690                 :            : 
    1691                 :            :         return 0;
    1692                 :            : }
    1693                 :            : 
    1694                 :            : static void
    1695                 :            : ena_com_free_ena_admin_queue_comp_ctx(struct ena_com_dev *ena_dev,
    1696                 :            :                                       struct ena_com_admin_queue *admin_queue)
    1697                 :            : 
    1698                 :            : {
    1699                 :          0 :         if (!admin_queue->comp_ctx)
    1700                 :            :                 return;
    1701                 :            : 
    1702                 :            :         ENA_WAIT_EVENTS_DESTROY(admin_queue);
    1703                 :          0 :         ENA_MEM_FREE(ena_dev->dmadev,
    1704                 :            :                      admin_queue->comp_ctx,
    1705                 :            :                      (admin_queue->q_depth * sizeof(struct ena_comp_ctx)));
    1706                 :            : 
    1707                 :          0 :         admin_queue->comp_ctx = NULL;
    1708                 :            : }
    1709                 :            : 
    1710         [ #  # ]:          0 : void ena_com_admin_destroy(struct ena_com_dev *ena_dev)
    1711                 :            : {
    1712                 :            :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    1713                 :            :         struct ena_com_admin_cq *cq = &admin_queue->cq;
    1714                 :            :         struct ena_com_admin_sq *sq = &admin_queue->sq;
    1715                 :            :         struct ena_com_aenq *aenq = &ena_dev->aenq;
    1716                 :            :         u16 size;
    1717                 :            : 
    1718                 :            :         ena_com_free_ena_admin_queue_comp_ctx(ena_dev, admin_queue);
    1719                 :            : 
    1720                 :            :         size = ADMIN_SQ_SIZE(admin_queue->q_depth);
    1721         [ #  # ]:          0 :         if (sq->entries)
    1722                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev, size, sq->entries,
    1723                 :            :                                       sq->dma_addr, sq->mem_handle);
    1724                 :          0 :         sq->entries = NULL;
    1725                 :            : 
    1726                 :            :         size = ADMIN_CQ_SIZE(admin_queue->q_depth);
    1727         [ #  # ]:          0 :         if (cq->entries)
    1728                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev, size, cq->entries,
    1729                 :            :                                       cq->dma_addr, cq->mem_handle);
    1730                 :          0 :         cq->entries = NULL;
    1731                 :            : 
    1732                 :            :         size = ADMIN_AENQ_SIZE(aenq->q_depth);
    1733         [ #  # ]:          0 :         if (ena_dev->aenq.entries)
    1734                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev, size, aenq->entries,
    1735                 :            :                                       aenq->dma_addr, aenq->mem_handle);
    1736                 :          0 :         aenq->entries = NULL;
    1737                 :            :         ENA_SPINLOCK_DESTROY(admin_queue->q_lock);
    1738                 :          0 : }
    1739                 :            : 
    1740                 :          0 : void ena_com_set_admin_polling_mode(struct ena_com_dev *ena_dev, bool polling)
    1741                 :            : {
    1742                 :            :         u32 mask_value = 0;
    1743                 :            : 
    1744         [ #  # ]:          0 :         if (polling)
    1745                 :            :                 mask_value = ENA_REGS_ADMIN_INTR_MASK;
    1746                 :            : 
    1747                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, mask_value,
    1748                 :            :                         ena_dev->reg_bar + ENA_REGS_INTR_MASK_OFF);
    1749                 :          0 :         ena_dev->admin_queue.polling = polling;
    1750                 :          0 : }
    1751                 :            : 
    1752                 :          0 : bool ena_com_get_admin_polling_mode(struct ena_com_dev *ena_dev)
    1753                 :            : {
    1754                 :          0 :         return ena_dev->admin_queue.polling;
    1755                 :            : }
    1756                 :            : 
    1757                 :          0 : void ena_com_set_admin_auto_polling_mode(struct ena_com_dev *ena_dev,
    1758                 :            :                                          bool polling)
    1759                 :            : {
    1760                 :          0 :         ena_dev->admin_queue.auto_polling = polling;
    1761                 :          0 : }
    1762                 :            : 
    1763         [ #  # ]:          0 : bool ena_com_phc_supported(struct ena_com_dev *ena_dev)
    1764                 :            : {
    1765                 :          0 :         return ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_PHC_CONFIG);
    1766                 :            : }
    1767                 :            : 
    1768                 :          0 : int ena_com_phc_init(struct ena_com_dev *ena_dev)
    1769                 :            : {
    1770                 :          0 :         struct ena_com_phc_info *phc = &ena_dev->phc;
    1771                 :            : 
    1772                 :            :         memset(phc, 0x0, sizeof(*phc));
    1773                 :            : 
    1774                 :            :         /* Allocate shared mem used PHC timestamp retrieved from device */
    1775                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    1776                 :            :                                sizeof(*phc->virt_addr),
    1777                 :            :                                phc->virt_addr,
    1778                 :            :                                phc->phys_addr,
    1779                 :            :                                phc->mem_handle);
    1780         [ #  # ]:          0 :         if (unlikely(!phc->virt_addr))
    1781                 :            :                 return ENA_COM_NO_MEM;
    1782                 :            : 
    1783                 :            :         ENA_SPINLOCK_INIT(phc->lock);
    1784                 :            : 
    1785                 :          0 :         phc->virt_addr->req_id = 0;
    1786                 :          0 :         phc->virt_addr->timestamp = 0;
    1787                 :            : 
    1788                 :          0 :         return 0;
    1789                 :            : }
    1790                 :            : 
    1791                 :          0 : int ena_com_phc_config(struct ena_com_dev *ena_dev)
    1792                 :            : {
    1793                 :            :         struct ena_com_phc_info *phc = &ena_dev->phc;
    1794                 :            :         struct ena_admin_get_feat_resp get_feat_resp;
    1795                 :            :         struct ena_admin_set_feat_resp set_feat_resp;
    1796                 :            :         struct ena_admin_set_feat_cmd set_feat_cmd;
    1797                 :            :         int ret = 0;
    1798                 :            : 
    1799                 :            :         /* Get default device PHC configuration */
    1800                 :            :         ret = ena_com_get_feature(ena_dev,
    1801                 :            :                                   &get_feat_resp,
    1802                 :            :                                   ENA_ADMIN_PHC_CONFIG,
    1803                 :            :                                   ENA_ADMIN_PHC_FEATURE_VERSION_0);
    1804         [ #  # ]:          0 :         if (unlikely(ret)) {
    1805                 :          0 :                 ena_trc_err(ena_dev, "Failed to get PHC feature configuration, error: %d\n", ret);
    1806                 :          0 :                 return ret;
    1807                 :            :         }
    1808                 :            : 
    1809                 :            :         /* Supporting only PHC V0 (readless mode with error bound) */
    1810         [ #  # ]:          0 :         if (get_feat_resp.u.phc.version != ENA_ADMIN_PHC_FEATURE_VERSION_0) {
    1811                 :          0 :                 ena_trc_err(ena_dev, "Unsupported PHC version (0x%X), error: %d\n",
    1812                 :            :                             get_feat_resp.u.phc.version,
    1813                 :            :                             ENA_COM_UNSUPPORTED);
    1814                 :          0 :                 return ENA_COM_UNSUPPORTED;
    1815                 :            :         }
    1816                 :            : 
    1817                 :            :         /* Update PHC doorbell offset according to device value, used to write req_id to PHC bar */
    1818                 :          0 :         phc->doorbell_offset = get_feat_resp.u.phc.doorbell_offset;
    1819                 :            : 
    1820                 :            :         /* Update PHC expire timeout according to device or default driver value */
    1821                 :          0 :         phc->expire_timeout_usec = (get_feat_resp.u.phc.expire_timeout_usec) ?
    1822         [ #  # ]:          0 :                                     get_feat_resp.u.phc.expire_timeout_usec :
    1823                 :            :                                     ENA_PHC_DEFAULT_EXPIRE_TIMEOUT_USEC;
    1824                 :            : 
    1825                 :            :         /* Update PHC block timeout according to device or default driver value */
    1826                 :          0 :         phc->block_timeout_usec = (get_feat_resp.u.phc.block_timeout_usec) ?
    1827         [ #  # ]:          0 :                                    get_feat_resp.u.phc.block_timeout_usec :
    1828                 :            :                                    ENA_PHC_DEFAULT_BLOCK_TIMEOUT_USEC;
    1829                 :            : 
    1830                 :            :         /* Sanity check - expire timeout must not exceed block timeout */
    1831         [ #  # ]:          0 :         if (phc->expire_timeout_usec > phc->block_timeout_usec)
    1832                 :          0 :                 phc->expire_timeout_usec = phc->block_timeout_usec;
    1833                 :            : 
    1834                 :            :         /* Prepare PHC config feature command */
    1835                 :            :         memset(&set_feat_cmd, 0x0, sizeof(set_feat_cmd));
    1836                 :          0 :         set_feat_cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
    1837                 :          0 :         set_feat_cmd.feat_common.feature_id = ENA_ADMIN_PHC_CONFIG;
    1838                 :          0 :         set_feat_cmd.u.phc.output_length = sizeof(*phc->virt_addr);
    1839                 :          0 :         ret = ena_com_mem_addr_set(ena_dev, &set_feat_cmd.u.phc.output_address, phc->phys_addr);
    1840         [ #  # ]:          0 :         if (unlikely(ret)) {
    1841                 :          0 :                 ena_trc_err(ena_dev, "Failed setting PHC output address, error: %d\n", ret);
    1842                 :          0 :                 return ret;
    1843                 :            :         }
    1844                 :            : 
    1845                 :            :         /* Send PHC feature command to the device */
    1846                 :          0 :         ret = ena_com_execute_admin_command(&ena_dev->admin_queue,
    1847                 :            :                                             (struct ena_admin_aq_entry *)&set_feat_cmd,
    1848                 :            :                                             sizeof(set_feat_cmd),
    1849                 :            :                                             (struct ena_admin_acq_entry *)&set_feat_resp,
    1850                 :            :                                             sizeof(set_feat_resp));
    1851                 :            : 
    1852         [ #  # ]:          0 :         if (unlikely(ret)) {
    1853                 :          0 :                 ena_trc_err(ena_dev, "Failed to enable PHC, error: %d\n", ret);
    1854                 :          0 :                 return ret;
    1855                 :            :         }
    1856                 :            : 
    1857                 :          0 :         phc->active = true;
    1858                 :          0 :         ena_trc_dbg(ena_dev, "PHC is active in the device\n");
    1859                 :            : 
    1860                 :          0 :         return ret;
    1861                 :            : }
    1862                 :            : 
    1863                 :          0 : void ena_com_phc_destroy(struct ena_com_dev *ena_dev)
    1864                 :            : {
    1865                 :            :         struct ena_com_phc_info *phc = &ena_dev->phc;
    1866                 :            :         unsigned long flags = 0;
    1867                 :            : 
    1868                 :            :         /* In case PHC is not supported by the device, silently exiting */
    1869         [ #  # ]:          0 :         if (!phc->virt_addr)
    1870                 :            :                 return;
    1871                 :            : 
    1872                 :          0 :         ENA_SPINLOCK_LOCK(phc->lock, flags);
    1873                 :          0 :         phc->active = false;
    1874                 :            :         ENA_SPINLOCK_UNLOCK(phc->lock, flags);
    1875                 :            : 
    1876                 :          0 :         ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    1877                 :            :                               sizeof(*phc->virt_addr),
    1878                 :            :                               phc->virt_addr,
    1879                 :            :                               phc->phys_addr,
    1880                 :            :                               phc->mem_handle);
    1881                 :          0 :         phc->virt_addr = NULL;
    1882                 :            : 
    1883                 :            :         ENA_SPINLOCK_DESTROY(phc->lock);
    1884                 :            : }
    1885                 :            : 
    1886                 :          0 : int ena_com_phc_get_timestamp(struct ena_com_dev *ena_dev, u64 *timestamp)
    1887                 :            : {
    1888                 :          0 :         volatile struct ena_admin_phc_resp *read_resp = ena_dev->phc.virt_addr;
    1889                 :            :         const ena_time_high_res_t zero_system_time = ENA_TIME_INIT_HIGH_RES();
    1890                 :            :         struct ena_com_phc_info *phc = &ena_dev->phc;
    1891                 :            :         ena_time_high_res_t expire_time;
    1892                 :            :         ena_time_high_res_t block_time;
    1893                 :            :         unsigned long flags = 0;
    1894                 :            :         int ret = ENA_COM_OK;
    1895                 :            : 
    1896         [ #  # ]:          0 :         if (!phc->active) {
    1897                 :          0 :                 ena_trc_err(ena_dev, "PHC feature is not active in the device\n");
    1898                 :          0 :                 return ENA_COM_UNSUPPORTED;
    1899                 :            :         }
    1900                 :            : 
    1901                 :          0 :         ENA_SPINLOCK_LOCK(phc->lock, flags);
    1902                 :            : 
    1903                 :            :         /* Check if PHC is in blocked state */
    1904                 :            :         if (unlikely(ENA_TIME_COMPARE_HIGH_RES(phc->system_time, zero_system_time))) {
    1905                 :            :                 /* Check if blocking time expired */
    1906                 :            :                 block_time = ENA_GET_SYSTEM_TIMEOUT_HIGH_RES(phc->system_time,
    1907                 :            :                                                              phc->block_timeout_usec);
    1908                 :            :                 if (!ENA_TIME_EXPIRE_HIGH_RES(block_time)) {
    1909                 :            :                         /* PHC is still in blocked state, skip PHC request */
    1910                 :            :                         phc->stats.phc_skp++;
    1911                 :            :                         ret = ENA_COM_DEVICE_BUSY;
    1912                 :            :                         goto skip;
    1913                 :            :                 }
    1914                 :            : 
    1915                 :            :                 /* PHC is in active state, update statistics according to req_id and error_flags */
    1916                 :            :                 if ((READ_ONCE16(read_resp->req_id) != phc->req_id) ||
    1917                 :            :                     (read_resp->error_flags & ENA_PHC_ERROR_FLAGS))
    1918                 :            :                         /* Device didn't update req_id during blocking time or timestamp is invalid,
    1919                 :            :                          * this indicates on a device error
    1920                 :            :                          */
    1921                 :            :                         phc->stats.phc_err++;
    1922                 :            :                 else
    1923                 :            :                         /* Device updated req_id during blocking time with valid timestamp */
    1924                 :            :                         phc->stats.phc_exp++;
    1925                 :            :         }
    1926                 :            : 
    1927                 :            :         /* Setting relative timeouts */
    1928                 :          0 :         phc->system_time = ENA_GET_SYSTEM_TIME_HIGH_RES();
    1929                 :            :         block_time = ENA_GET_SYSTEM_TIMEOUT_HIGH_RES(phc->system_time, phc->block_timeout_usec);
    1930                 :            :         expire_time = ENA_GET_SYSTEM_TIMEOUT_HIGH_RES(phc->system_time, phc->expire_timeout_usec);
    1931                 :            : 
    1932                 :            :         /* We expect the device to return this req_id once the new PHC timestamp is updated */
    1933                 :          0 :         phc->req_id++;
    1934                 :            : 
    1935                 :            :         /* Initialize PHC shared memory with different req_id value to be able to identify once the
    1936                 :            :          * device changes it to req_id
    1937                 :            :          */
    1938                 :          0 :         read_resp->req_id = phc->req_id + ENA_PHC_REQ_ID_OFFSET;
    1939                 :            : 
    1940                 :            :         /* Writing req_id to PHC bar */
    1941                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, phc->req_id, ena_dev->reg_bar + phc->doorbell_offset);
    1942                 :            : 
    1943                 :            :         /* Stalling until the device updates req_id */
    1944                 :            :         while (1) {
    1945                 :          0 :                 if (unlikely(ENA_TIME_EXPIRE_HIGH_RES(expire_time))) {
    1946                 :            :                         /* Gave up waiting for updated req_id, PHC enters into blocked state until
    1947                 :            :                          * passing blocking time, during this time any get PHC timestamp or
    1948                 :            :                          * error bound requests will fail with device busy error
    1949                 :            :                          */
    1950                 :            :                         phc->error_bound = ENA_PHC_MAX_ERROR_BOUND;
    1951                 :            :                         ret = ENA_COM_DEVICE_BUSY;
    1952                 :            :                         break;
    1953                 :            :                 }
    1954                 :            : 
    1955                 :            :                 /* Check if req_id was updated by the device */
    1956         [ #  # ]:          0 :                 if (READ_ONCE16(read_resp->req_id) != phc->req_id) {
    1957                 :            :                         /* req_id was not updated by the device yet, check again on next loop */
    1958                 :            :                         continue;
    1959                 :            :                 }
    1960                 :            : 
    1961                 :            :                 /* req_id was updated by the device which indicates that PHC timestamp, error_bound
    1962                 :            :                  * and error_flags are updated too, checking errors before retrieving timestamp and
    1963                 :            :                  * error_bound values
    1964                 :            :                  */
    1965         [ #  # ]:          0 :                 if (unlikely(read_resp->error_flags & ENA_PHC_ERROR_FLAGS)) {
    1966                 :            :                         /* Retrieved timestamp or error bound errors, PHC enters into blocked state
    1967                 :            :                          * until passing blocking time, during this time any get PHC timestamp or
    1968                 :            :                          * error bound requests will fail with device busy error
    1969                 :            :                          */
    1970                 :          0 :                         phc->error_bound = ENA_PHC_MAX_ERROR_BOUND;
    1971                 :            :                         ret = ENA_COM_DEVICE_BUSY;
    1972                 :          0 :                         break;
    1973                 :            :                 }
    1974                 :            : 
    1975                 :            :                 /* PHC timestamp value is returned to the caller */
    1976                 :          0 :                 *timestamp = read_resp->timestamp;
    1977                 :            : 
    1978                 :            :                 /* Error bound value is cached for future retrieval by caller */
    1979                 :          0 :                 phc->error_bound = read_resp->error_bound;
    1980                 :            : 
    1981                 :            :                 /* Update statistic on valid PHC timestamp retrieval */
    1982                 :          0 :                 phc->stats.phc_cnt++;
    1983                 :            : 
    1984                 :            :                 /* This indicates PHC state is active */
    1985                 :          0 :                 phc->system_time = zero_system_time;
    1986                 :          0 :                 break;
    1987                 :            :         }
    1988                 :            : 
    1989                 :          0 : skip:
    1990                 :            :         ENA_SPINLOCK_UNLOCK(phc->lock, flags);
    1991                 :            : 
    1992                 :          0 :         return ret;
    1993                 :            : }
    1994                 :            : 
    1995                 :          0 : int ena_com_phc_get_error_bound(struct ena_com_dev *ena_dev, u32 *error_bound)
    1996                 :            : {
    1997                 :            :         struct ena_com_phc_info *phc = &ena_dev->phc;
    1998                 :          0 :         u32 local_error_bound = phc->error_bound;
    1999                 :            : 
    2000         [ #  # ]:          0 :         if (!phc->active) {
    2001                 :          0 :                 ena_trc_err(ena_dev, "PHC feature is not active in the device\n");
    2002                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2003                 :            :         }
    2004                 :            : 
    2005         [ #  # ]:          0 :         if (local_error_bound == ENA_PHC_MAX_ERROR_BOUND)
    2006                 :            :                 return ENA_COM_DEVICE_BUSY;
    2007                 :            : 
    2008                 :          0 :         *error_bound = local_error_bound;
    2009                 :            : 
    2010                 :          0 :         return ENA_COM_OK;
    2011                 :            : }
    2012                 :            : 
    2013                 :          0 : int ena_com_mmio_reg_read_request_init(struct ena_com_dev *ena_dev)
    2014                 :            : {
    2015                 :            :         struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
    2016                 :            : 
    2017                 :            :         ENA_SPINLOCK_INIT(mmio_read->lock);
    2018                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    2019                 :            :                                sizeof(*mmio_read->read_resp),
    2020                 :            :                                mmio_read->read_resp,
    2021                 :            :                                mmio_read->read_resp_dma_addr,
    2022                 :            :                                mmio_read->read_resp_mem_handle);
    2023         [ #  # ]:          0 :         if (unlikely(!mmio_read->read_resp))
    2024                 :          0 :                 goto err;
    2025                 :            : 
    2026                 :          0 :         ena_com_mmio_reg_read_request_write_dev_addr(ena_dev);
    2027                 :            : 
    2028                 :          0 :         mmio_read->read_resp->req_id = 0x0;
    2029                 :          0 :         mmio_read->seq_num = 0x0;
    2030                 :          0 :         mmio_read->readless_supported = true;
    2031                 :            : 
    2032                 :          0 :         return 0;
    2033                 :            : 
    2034                 :            : err:
    2035                 :            :                 ENA_SPINLOCK_DESTROY(mmio_read->lock);
    2036                 :          0 :                 return ENA_COM_NO_MEM;
    2037                 :            : }
    2038                 :            : 
    2039                 :          0 : void ena_com_set_mmio_read_mode(struct ena_com_dev *ena_dev, bool readless_supported)
    2040                 :            : {
    2041                 :            :         struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
    2042                 :            : 
    2043                 :          0 :         mmio_read->readless_supported = readless_supported;
    2044                 :          0 : }
    2045                 :            : 
    2046                 :          0 : void ena_com_mmio_reg_read_request_destroy(struct ena_com_dev *ena_dev)
    2047                 :            : {
    2048                 :            :         struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
    2049                 :            : 
    2050                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, 0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_LO_OFF);
    2051                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, 0x0, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_HI_OFF);
    2052                 :            : 
    2053                 :          0 :         ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    2054                 :            :                               sizeof(*mmio_read->read_resp),
    2055                 :            :                               mmio_read->read_resp,
    2056                 :            :                               mmio_read->read_resp_dma_addr,
    2057                 :            :                               mmio_read->read_resp_mem_handle);
    2058                 :            : 
    2059                 :          0 :         mmio_read->read_resp = NULL;
    2060                 :            :         ENA_SPINLOCK_DESTROY(mmio_read->lock);
    2061                 :          0 : }
    2062                 :            : 
    2063                 :          0 : void ena_com_mmio_reg_read_request_write_dev_addr(struct ena_com_dev *ena_dev)
    2064                 :            : {
    2065                 :            :         struct ena_com_mmio_read *mmio_read = &ena_dev->mmio_read;
    2066                 :            :         u32 addr_low, addr_high;
    2067                 :            : 
    2068                 :          0 :         addr_low = ENA_DMA_ADDR_TO_UINT32_LOW(mmio_read->read_resp_dma_addr);
    2069                 :          0 :         addr_high = ENA_DMA_ADDR_TO_UINT32_HIGH(mmio_read->read_resp_dma_addr);
    2070                 :            : 
    2071                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, addr_low, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_LO_OFF);
    2072                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, addr_high, ena_dev->reg_bar + ENA_REGS_MMIO_RESP_HI_OFF);
    2073                 :          0 : }
    2074                 :            : 
    2075                 :          0 : int ena_com_admin_init(struct ena_com_dev *ena_dev,
    2076                 :            :                        struct ena_aenq_handlers *aenq_handlers)
    2077                 :            : {
    2078                 :          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    2079                 :            :         u32 aq_caps, acq_caps, dev_sts, addr_low, addr_high;
    2080                 :            :         int ret;
    2081                 :            : 
    2082                 :          0 :         dev_sts = ena_com_reg_bar_read32(ena_dev, ENA_REGS_DEV_STS_OFF);
    2083                 :            : 
    2084         [ #  # ]:          0 :         if (unlikely(dev_sts == ENA_MMIO_READ_TIMEOUT)) {
    2085                 :          0 :                 ena_trc_err(ena_dev, "Reg read timeout occurred\n");
    2086                 :          0 :                 return ENA_COM_TIMER_EXPIRED;
    2087                 :            :         }
    2088                 :            : 
    2089         [ #  # ]:          0 :         if (!(dev_sts & ENA_REGS_DEV_STS_READY_MASK)) {
    2090                 :          0 :                 ena_trc_err(ena_dev, "Device isn't ready, abort com init\n");
    2091                 :          0 :                 return ENA_COM_NO_DEVICE;
    2092                 :            :         }
    2093                 :            : 
    2094                 :          0 :         admin_queue->q_depth = ENA_ADMIN_QUEUE_DEPTH;
    2095                 :            : 
    2096                 :          0 :         admin_queue->bus = ena_dev->bus;
    2097                 :          0 :         admin_queue->q_dmadev = ena_dev->dmadev;
    2098                 :          0 :         admin_queue->polling = false;
    2099                 :          0 :         admin_queue->curr_cmd_id = 0;
    2100                 :            : 
    2101                 :            :         ATOMIC32_SET(&admin_queue->outstanding_cmds, 0);
    2102                 :            : 
    2103                 :            :         ENA_SPINLOCK_INIT(admin_queue->q_lock);
    2104                 :            : 
    2105                 :          0 :         ret = ena_com_init_comp_ctxt(admin_queue);
    2106         [ #  # ]:          0 :         if (unlikely(ret))
    2107                 :          0 :                 goto error;
    2108                 :            : 
    2109                 :          0 :         ret = ena_com_admin_init_sq(admin_queue);
    2110         [ #  # ]:          0 :         if (unlikely(ret))
    2111                 :          0 :                 goto error;
    2112                 :            : 
    2113                 :          0 :         ret = ena_com_admin_init_cq(admin_queue);
    2114         [ #  # ]:          0 :         if (unlikely(ret))
    2115                 :          0 :                 goto error;
    2116                 :            : 
    2117                 :          0 :         admin_queue->sq.db_addr = (u32 __iomem *)((uintptr_t)ena_dev->reg_bar +
    2118                 :            :                 ENA_REGS_AQ_DB_OFF);
    2119                 :            : 
    2120                 :          0 :         addr_low = ENA_DMA_ADDR_TO_UINT32_LOW(admin_queue->sq.dma_addr);
    2121                 :          0 :         addr_high = ENA_DMA_ADDR_TO_UINT32_HIGH(admin_queue->sq.dma_addr);
    2122                 :            : 
    2123                 :            :         ENA_REG_WRITE32(ena_dev->bus, addr_low, ena_dev->reg_bar + ENA_REGS_AQ_BASE_LO_OFF);
    2124                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, addr_high, ena_dev->reg_bar + ENA_REGS_AQ_BASE_HI_OFF);
    2125                 :            : 
    2126                 :          0 :         addr_low = ENA_DMA_ADDR_TO_UINT32_LOW(admin_queue->cq.dma_addr);
    2127                 :          0 :         addr_high = ENA_DMA_ADDR_TO_UINT32_HIGH(admin_queue->cq.dma_addr);
    2128                 :            : 
    2129                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, addr_low, ena_dev->reg_bar + ENA_REGS_ACQ_BASE_LO_OFF);
    2130                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, addr_high, ena_dev->reg_bar + ENA_REGS_ACQ_BASE_HI_OFF);
    2131                 :            : 
    2132                 :            :         aq_caps = 0;
    2133                 :          0 :         aq_caps |= admin_queue->q_depth & ENA_REGS_AQ_CAPS_AQ_DEPTH_MASK;
    2134                 :          0 :         aq_caps |= (sizeof(struct ena_admin_aq_entry) <<
    2135                 :            :                         ENA_REGS_AQ_CAPS_AQ_ENTRY_SIZE_SHIFT) &
    2136                 :            :                         ENA_REGS_AQ_CAPS_AQ_ENTRY_SIZE_MASK;
    2137                 :            : 
    2138                 :            :         acq_caps = 0;
    2139                 :            :         acq_caps |= admin_queue->q_depth & ENA_REGS_ACQ_CAPS_ACQ_DEPTH_MASK;
    2140                 :            :         acq_caps |= (sizeof(struct ena_admin_acq_entry) <<
    2141                 :            :                 ENA_REGS_ACQ_CAPS_ACQ_ENTRY_SIZE_SHIFT) &
    2142                 :            :                 ENA_REGS_ACQ_CAPS_ACQ_ENTRY_SIZE_MASK;
    2143                 :            : 
    2144                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, aq_caps, ena_dev->reg_bar + ENA_REGS_AQ_CAPS_OFF);
    2145                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, acq_caps, ena_dev->reg_bar + ENA_REGS_ACQ_CAPS_OFF);
    2146                 :          0 :         ret = ena_com_admin_init_aenq(ena_dev, aenq_handlers);
    2147         [ #  # ]:          0 :         if (unlikely(ret))
    2148                 :          0 :                 goto error;
    2149                 :            : 
    2150                 :          0 :         admin_queue->ena_dev = ena_dev;
    2151                 :          0 :         admin_queue->running_state = true;
    2152                 :          0 :         admin_queue->is_missing_admin_interrupt = false;
    2153                 :            : 
    2154                 :          0 :         return 0;
    2155                 :          0 : error:
    2156                 :          0 :         ena_com_admin_destroy(ena_dev);
    2157                 :            : 
    2158                 :          0 :         return ret;
    2159                 :            : }
    2160                 :            : 
    2161                 :          0 : int ena_com_create_io_queue(struct ena_com_dev *ena_dev,
    2162                 :            :                             struct ena_com_create_io_ctx *ctx)
    2163                 :            : {
    2164                 :            :         struct ena_com_io_sq *io_sq;
    2165                 :            :         struct ena_com_io_cq *io_cq;
    2166                 :            :         int ret;
    2167                 :            : 
    2168         [ #  # ]:          0 :         if (unlikely(ctx->qid >= ENA_TOTAL_NUM_QUEUES)) {
    2169                 :          0 :                 ena_trc_err(ena_dev, "Qid (%d) is bigger than max num of queues (%d)\n",
    2170                 :            :                             ctx->qid, ENA_TOTAL_NUM_QUEUES);
    2171                 :          0 :                 return ENA_COM_INVAL;
    2172                 :            :         }
    2173                 :            : 
    2174                 :          0 :         io_sq = &ena_dev->io_sq_queues[ctx->qid];
    2175         [ #  # ]:          0 :         io_cq = &ena_dev->io_cq_queues[ctx->qid];
    2176                 :            : 
    2177                 :            :         memset(io_sq, 0x0, sizeof(*io_sq));
    2178                 :            :         memset(io_cq, 0x0, sizeof(*io_cq));
    2179                 :            : 
    2180                 :            :         /* Init CQ */
    2181                 :          0 :         io_cq->q_depth = ctx->queue_size;
    2182                 :          0 :         io_cq->direction = ctx->direction;
    2183                 :          0 :         io_cq->qid = ctx->qid;
    2184                 :            : 
    2185                 :          0 :         io_cq->msix_vector = ctx->msix_vector;
    2186                 :            : 
    2187                 :          0 :         io_sq->q_depth = ctx->queue_size;
    2188                 :          0 :         io_sq->direction = ctx->direction;
    2189                 :          0 :         io_sq->qid = ctx->qid;
    2190                 :            : 
    2191                 :          0 :         io_sq->mem_queue_type = ctx->mem_queue_type;
    2192                 :            : 
    2193         [ #  # ]:          0 :         if (ctx->direction == ENA_COM_IO_QUEUE_DIRECTION_TX)
    2194                 :            :                 /* header length is limited to 8 bits */
    2195                 :          0 :                 io_sq->tx_max_header_size =
    2196                 :          0 :                         ENA_MIN32(ena_dev->tx_max_header_size, SZ_256);
    2197                 :            : 
    2198                 :          0 :         ret = ena_com_init_io_sq(ena_dev, ctx, io_sq);
    2199         [ #  # ]:          0 :         if (unlikely(ret))
    2200                 :          0 :                 goto error;
    2201                 :          0 :         ret = ena_com_init_io_cq(ena_dev, ctx, io_cq);
    2202         [ #  # ]:          0 :         if (unlikely(ret))
    2203                 :          0 :                 goto error;
    2204                 :            : 
    2205                 :          0 :         ret = ena_com_create_io_cq(ena_dev, io_cq);
    2206         [ #  # ]:          0 :         if (unlikely(ret))
    2207                 :          0 :                 goto error;
    2208                 :            : 
    2209                 :          0 :         ret = ena_com_create_io_sq(ena_dev, io_sq, io_cq->idx);
    2210         [ #  # ]:          0 :         if (unlikely(ret))
    2211                 :          0 :                 goto destroy_io_cq;
    2212                 :            : 
    2213                 :            :         return 0;
    2214                 :            : 
    2215                 :            : destroy_io_cq:
    2216                 :          0 :         ena_com_destroy_io_cq(ena_dev, io_cq);
    2217                 :          0 : error:
    2218                 :          0 :         ena_com_io_queue_free(ena_dev, io_sq, io_cq);
    2219                 :          0 :         return ret;
    2220                 :            : }
    2221                 :            : 
    2222                 :          0 : void ena_com_destroy_io_queue(struct ena_com_dev *ena_dev, u16 qid)
    2223                 :            : {
    2224                 :            :         struct ena_com_io_sq *io_sq;
    2225                 :            :         struct ena_com_io_cq *io_cq;
    2226                 :            : 
    2227         [ #  # ]:          0 :         if (unlikely(qid >= ENA_TOTAL_NUM_QUEUES)) {
    2228                 :          0 :                 ena_trc_err(ena_dev, "Qid (%d) is bigger than max num of queues (%d)\n",
    2229                 :            :                             qid, ENA_TOTAL_NUM_QUEUES);
    2230                 :          0 :                 return;
    2231                 :            :         }
    2232                 :            : 
    2233                 :          0 :         io_sq = &ena_dev->io_sq_queues[qid];
    2234                 :          0 :         io_cq = &ena_dev->io_cq_queues[qid];
    2235                 :            : 
    2236                 :          0 :         ena_com_destroy_io_sq(ena_dev, io_sq);
    2237                 :          0 :         ena_com_destroy_io_cq(ena_dev, io_cq);
    2238                 :            : 
    2239                 :          0 :         ena_com_io_queue_free(ena_dev, io_sq, io_cq);
    2240                 :            : }
    2241                 :            : 
    2242                 :          0 : int ena_com_get_link_params(struct ena_com_dev *ena_dev,
    2243                 :            :                             struct ena_admin_get_feat_resp *resp)
    2244                 :            : {
    2245                 :          0 :         return ena_com_get_feature(ena_dev, resp, ENA_ADMIN_LINK_CONFIG, 0);
    2246                 :            : }
    2247                 :            : 
    2248                 :          0 : static int ena_get_dev_stats(struct ena_com_dev *ena_dev,
    2249                 :            :                              struct ena_com_stats_ctx *ctx,
    2250                 :            :                              enum ena_admin_get_stats_type type)
    2251                 :            : {
    2252                 :          0 :         struct ena_admin_acq_get_stats_resp *get_resp = &ctx->get_resp;
    2253                 :          0 :         struct ena_admin_aq_get_stats_cmd *get_cmd = &ctx->get_cmd;
    2254                 :            :         struct ena_com_admin_queue *admin_queue;
    2255                 :            :         int ret;
    2256                 :            : 
    2257                 :          0 :         admin_queue = &ena_dev->admin_queue;
    2258                 :            : 
    2259                 :          0 :         get_cmd->aq_common_descriptor.opcode = ENA_ADMIN_GET_STATS;
    2260                 :          0 :         get_cmd->aq_common_descriptor.flags = 0;
    2261                 :          0 :         get_cmd->type = type;
    2262                 :            : 
    2263                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    2264                 :            :                                             (struct ena_admin_aq_entry *)get_cmd,
    2265                 :            :                                             sizeof(*get_cmd),
    2266                 :            :                                             (struct ena_admin_acq_entry *)get_resp,
    2267                 :            :                                             sizeof(*get_resp));
    2268                 :            : 
    2269         [ #  # ]:          0 :         if (unlikely(ret))
    2270                 :          0 :                 ena_trc_err(ena_dev, "Failed to get stats. error: %d\n", ret);
    2271                 :            : 
    2272                 :          0 :         return ret;
    2273                 :            : }
    2274                 :            : 
    2275         [ #  # ]:          0 : static void ena_com_set_supported_customer_metrics(struct ena_com_dev *ena_dev)
    2276                 :            : {
    2277                 :            :         struct ena_customer_metrics *customer_metrics;
    2278                 :            :         struct ena_com_stats_ctx ctx;
    2279                 :            :         int ret;
    2280                 :            : 
    2281                 :            :         customer_metrics = &ena_dev->customer_metrics;
    2282         [ #  # ]:          0 :         if (!ena_com_get_cap(ena_dev, ENA_ADMIN_CUSTOMER_METRICS)) {
    2283                 :          0 :                 customer_metrics->supported_metrics = ENA_ADMIN_CUSTOMER_METRICS_MIN_SUPPORT_MASK;
    2284                 :          0 :                 return;
    2285                 :            :         }
    2286                 :            : 
    2287                 :            :         memset(&ctx, 0x0, sizeof(ctx));
    2288                 :          0 :         ctx.get_cmd.requested_metrics = ENA_ADMIN_CUSTOMER_METRICS_SUPPORT_MASK;
    2289                 :          0 :         ret = ena_get_dev_stats(ena_dev, &ctx, ENA_ADMIN_GET_STATS_TYPE_CUSTOMER_METRICS);
    2290         [ #  # ]:          0 :         if (likely(ret == 0))
    2291                 :          0 :                 customer_metrics->supported_metrics =
    2292                 :          0 :                         ctx.get_resp.u.customer_metrics.reported_metrics;
    2293                 :            :         else
    2294                 :          0 :                 ena_trc_err(ena_dev, "Failed to query customer metrics support. error: %d\n", ret);
    2295                 :            : }
    2296                 :            : 
    2297                 :          0 : int ena_com_get_dev_attr_feat(struct ena_com_dev *ena_dev,
    2298                 :            :                               struct ena_com_dev_get_features_ctx *get_feat_ctx)
    2299                 :            : {
    2300                 :            :         struct ena_admin_get_feat_resp get_resp;
    2301                 :            :         int rc;
    2302                 :            : 
    2303                 :            :         rc = ena_com_get_feature(ena_dev, &get_resp,
    2304                 :            :                                  ENA_ADMIN_DEVICE_ATTRIBUTES, 0);
    2305         [ #  # ]:          0 :         if (rc)
    2306                 :            :                 return rc;
    2307                 :            : 
    2308         [ #  # ]:          0 :         memcpy(&get_feat_ctx->dev_attr, &get_resp.u.dev_attr,
    2309                 :            :                sizeof(get_resp.u.dev_attr));
    2310                 :            : 
    2311                 :          0 :         ena_dev->supported_features = get_resp.u.dev_attr.supported_features;
    2312                 :          0 :         ena_dev->capabilities = get_resp.u.dev_attr.capabilities;
    2313                 :            : 
    2314         [ #  # ]:          0 :         if (ena_dev->supported_features & BIT(ENA_ADMIN_MAX_QUEUES_EXT)) {
    2315                 :            :                 rc = ena_com_get_feature(ena_dev, &get_resp,
    2316                 :            :                                          ENA_ADMIN_MAX_QUEUES_EXT,
    2317                 :            :                                          ENA_FEATURE_MAX_QUEUE_EXT_VER);
    2318         [ #  # ]:          0 :                 if (rc)
    2319                 :            :                         return rc;
    2320                 :            : 
    2321         [ #  # ]:          0 :                 if (get_resp.u.max_queue_ext.version != ENA_FEATURE_MAX_QUEUE_EXT_VER)
    2322                 :            :                         return ENA_COM_INVAL;
    2323                 :            : 
    2324         [ #  # ]:          0 :                 memcpy(&get_feat_ctx->max_queue_ext, &get_resp.u.max_queue_ext,
    2325                 :            :                        sizeof(get_resp.u.max_queue_ext));
    2326                 :          0 :                 ena_dev->tx_max_header_size =
    2327                 :          0 :                         get_resp.u.max_queue_ext.max_queue_ext.max_tx_header_size;
    2328                 :            :         } else {
    2329                 :            :                 rc = ena_com_get_feature(ena_dev, &get_resp,
    2330                 :            :                                          ENA_ADMIN_MAX_QUEUES_NUM, 0);
    2331         [ #  # ]:          0 :                 memcpy(&get_feat_ctx->max_queues, &get_resp.u.max_queue,
    2332                 :            :                        sizeof(get_resp.u.max_queue));
    2333                 :          0 :                 ena_dev->tx_max_header_size =
    2334                 :          0 :                         get_resp.u.max_queue.max_header_size;
    2335                 :            : 
    2336         [ #  # ]:          0 :                 if (rc)
    2337                 :            :                         return rc;
    2338                 :            :         }
    2339                 :            : 
    2340                 :            :         rc = ena_com_get_feature(ena_dev, &get_resp,
    2341                 :            :                                  ENA_ADMIN_AENQ_CONFIG, 0);
    2342         [ #  # ]:          0 :         if (rc)
    2343                 :            :                 return rc;
    2344                 :            : 
    2345         [ #  # ]:          0 :         memcpy(&get_feat_ctx->aenq, &get_resp.u.aenq,
    2346                 :            :                sizeof(get_resp.u.aenq));
    2347                 :            : 
    2348                 :            :         rc = ena_com_get_feature(ena_dev, &get_resp,
    2349                 :            :                                  ENA_ADMIN_STATELESS_OFFLOAD_CONFIG, 0);
    2350         [ #  # ]:          0 :         if (rc)
    2351                 :            :                 return rc;
    2352                 :            : 
    2353         [ #  # ]:          0 :         memcpy(&get_feat_ctx->offload, &get_resp.u.offload,
    2354                 :            :                sizeof(get_resp.u.offload));
    2355                 :            : 
    2356                 :            :         /* Driver hints isn't mandatory admin command. So in case the
    2357                 :            :          * command isn't supported set driver hints to 0
    2358                 :            :          */
    2359                 :            :         rc = ena_com_get_feature(ena_dev, &get_resp, ENA_ADMIN_HW_HINTS, 0);
    2360                 :            : 
    2361         [ #  # ]:          0 :         if (!rc)
    2362         [ #  # ]:          0 :                 memcpy(&get_feat_ctx->hw_hints, &get_resp.u.hw_hints,
    2363                 :            :                        sizeof(get_resp.u.hw_hints));
    2364         [ #  # ]:          0 :         else if (rc == ENA_COM_UNSUPPORTED)
    2365                 :          0 :                 memset(&get_feat_ctx->hw_hints, 0x0, sizeof(get_feat_ctx->hw_hints));
    2366                 :            :         else
    2367                 :            :                 return rc;
    2368                 :            : 
    2369                 :            :         rc = ena_com_get_feature(ena_dev, &get_resp,
    2370                 :            :                                  ENA_ADMIN_LLQ, ENA_ADMIN_LLQ_FEATURE_VERSION_1);
    2371         [ #  # ]:          0 :         if (!rc)
    2372         [ #  # ]:          0 :                 memcpy(&get_feat_ctx->llq, &get_resp.u.llq,
    2373                 :            :                        sizeof(get_resp.u.llq));
    2374         [ #  # ]:          0 :         else if (rc == ENA_COM_UNSUPPORTED)
    2375                 :          0 :                 memset(&get_feat_ctx->llq, 0x0, sizeof(get_feat_ctx->llq));
    2376                 :            :         else
    2377                 :            :                 return rc;
    2378                 :            : 
    2379                 :          0 :         ena_com_set_supported_customer_metrics(ena_dev);
    2380                 :            : 
    2381                 :          0 :         return 0;
    2382                 :            : }
    2383                 :            : 
    2384                 :          0 : void ena_com_admin_q_comp_intr_handler(struct ena_com_dev *ena_dev)
    2385                 :            : {
    2386                 :          0 :         ena_com_handle_admin_completion(&ena_dev->admin_queue);
    2387                 :          0 : }
    2388                 :            : 
    2389                 :            : /* ena_handle_specific_aenq_event:
    2390                 :            :  * return the handler that is relevant to the specific event group
    2391                 :            :  */
    2392                 :            : static ena_aenq_handler ena_com_get_specific_aenq_cb(struct ena_com_dev *ena_dev,
    2393                 :            :                                                      u16 group)
    2394                 :            : {
    2395                 :          0 :         struct ena_aenq_handlers *aenq_handlers = ena_dev->aenq.aenq_handlers;
    2396                 :            : 
    2397         [ #  # ]:          0 :         if ((group < ENA_MAX_HANDLERS) && aenq_handlers->handlers[group])
    2398                 :            :                 return aenq_handlers->handlers[group];
    2399                 :            : 
    2400                 :          0 :         return aenq_handlers->unimplemented_handler;
    2401                 :            : }
    2402                 :            : 
    2403                 :            : /* ena_aenq_intr_handler:
    2404                 :            :  * handles the aenq incoming events.
    2405                 :            :  * pop events from the queue and apply the specific handler
    2406                 :            :  */
    2407                 :          0 : void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
    2408                 :            : {
    2409                 :            :         struct ena_admin_aenq_entry *aenq_e;
    2410                 :            :         struct ena_admin_aenq_common_desc *aenq_common;
    2411                 :            :         struct ena_com_aenq *aenq  = &ena_dev->aenq;
    2412                 :            :         u64 timestamp;
    2413                 :            :         ena_aenq_handler handler_cb;
    2414                 :            :         u16 masked_head, processed = 0;
    2415                 :            :         u8 phase;
    2416                 :            : 
    2417                 :          0 :         masked_head = aenq->head & (aenq->q_depth - 1);
    2418                 :          0 :         phase = aenq->phase;
    2419                 :          0 :         aenq_e = &aenq->entries[masked_head]; /* Get first entry */
    2420                 :          0 :         aenq_common = &aenq_e->aenq_common_desc;
    2421                 :            : 
    2422                 :            :         /* Go over all the events */
    2423                 :          0 :         while ((READ_ONCE8(aenq_common->flags) &
    2424         [ #  # ]:          0 :                 ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
    2425                 :            :                 /* Make sure the device finished writing the rest of the descriptor
    2426                 :            :                  * before reading it.
    2427                 :            :                  */
    2428                 :            :                 dma_rmb();
    2429                 :            : 
    2430                 :          0 :                 timestamp = (u64)aenq_common->timestamp_low |
    2431                 :          0 :                         ((u64)aenq_common->timestamp_high << 32);
    2432                 :            : 
    2433                 :          0 :                 ena_trc_dbg(ena_dev, "AENQ! Group[%x] Syndrome[%x] timestamp: [%" ENA_PRIu64 "s]\n",
    2434                 :            :                             aenq_common->group,
    2435                 :            :                             aenq_common->syndrome,
    2436                 :            :                             timestamp);
    2437                 :            : 
    2438                 :            :                 /* Handle specific event*/
    2439                 :          0 :                 handler_cb = ena_com_get_specific_aenq_cb(ena_dev,
    2440         [ #  # ]:          0 :                                                           aenq_common->group);
    2441                 :          0 :                 handler_cb(data, aenq_e); /* call the actual event handler*/
    2442                 :            : 
    2443                 :            :                 /* Get next event entry */
    2444                 :          0 :                 masked_head++;
    2445                 :          0 :                 processed++;
    2446                 :            : 
    2447         [ #  # ]:          0 :                 if (unlikely(masked_head == aenq->q_depth)) {
    2448                 :            :                         masked_head = 0;
    2449                 :          0 :                         phase = !phase;
    2450                 :            :                 }
    2451                 :          0 :                 aenq_e = &aenq->entries[masked_head];
    2452                 :          0 :                 aenq_common = &aenq_e->aenq_common_desc;
    2453                 :            :         }
    2454                 :            : 
    2455                 :          0 :         aenq->head += processed;
    2456                 :          0 :         aenq->phase = phase;
    2457                 :            : 
    2458                 :            :         /* Don't update aenq doorbell if there weren't any processed events */
    2459         [ #  # ]:          0 :         if (!processed)
    2460                 :            :                 return;
    2461                 :            : 
    2462                 :            :         /* write the aenq doorbell after all AENQ descriptors were read */
    2463                 :            :         mb();
    2464                 :          0 :         ENA_REG_WRITE32_RELAXED(ena_dev->bus, (u32)aenq->head,
    2465                 :            :                                 ena_dev->reg_bar + ENA_REGS_AENQ_HEAD_DB_OFF);
    2466                 :          0 :         mmiowb();
    2467                 :            : }
    2468                 :            : 
    2469                 :          0 : bool ena_com_aenq_has_keep_alive(struct ena_com_dev *ena_dev)
    2470                 :            : {
    2471                 :            :         struct ena_admin_aenq_common_desc *aenq_common;
    2472                 :            :         struct ena_com_aenq *aenq = &ena_dev->aenq;
    2473                 :            :         struct ena_admin_aenq_entry *aenq_e;
    2474                 :          0 :         u8 phase = aenq->phase;
    2475                 :            :         u16 masked_head;
    2476                 :            : 
    2477                 :          0 :         masked_head = aenq->head & (aenq->q_depth - 1);
    2478                 :          0 :         aenq_e = &aenq->entries[masked_head]; /* Get first entry */
    2479                 :          0 :         aenq_common = &aenq_e->aenq_common_desc;
    2480                 :            : 
    2481                 :            :         /* Go over all the events */
    2482                 :          0 :         while ((READ_ONCE8(aenq_common->flags) &
    2483         [ #  # ]:          0 :                 ENA_ADMIN_AENQ_COMMON_DESC_PHASE_MASK) == phase) {
    2484                 :            :                 /* Make sure the device finished writing the rest of the descriptor
    2485                 :            :                  * before reading it.
    2486                 :            :                  */
    2487                 :            :                 dma_rmb();
    2488                 :            : 
    2489         [ #  # ]:          0 :                 if (aenq_common->group == ENA_ADMIN_KEEP_ALIVE)
    2490                 :            :                         return true;
    2491                 :            : 
    2492                 :            :                 /* Get next event entry */
    2493                 :          0 :                 masked_head++;
    2494                 :            : 
    2495         [ #  # ]:          0 :                 if (unlikely(masked_head == aenq->q_depth)) {
    2496                 :            :                         masked_head = 0;
    2497                 :          0 :                         phase = !phase;
    2498                 :            :                 }
    2499                 :            : 
    2500                 :          0 :                 aenq_e = &aenq->entries[masked_head];
    2501                 :          0 :                 aenq_common = &aenq_e->aenq_common_desc;
    2502                 :            :         }
    2503                 :            : 
    2504                 :            :         return false;
    2505                 :            : }
    2506                 :            : 
    2507                 :            : 
    2508                 :          0 : int ena_com_dev_reset(struct ena_com_dev *ena_dev,
    2509                 :            :                       enum ena_regs_reset_reason_types reset_reason)
    2510                 :            : {
    2511                 :            :         u32 reset_reason_msb, reset_reason_lsb;
    2512                 :            :         u32 stat, timeout, cap, reset_val;
    2513                 :            :         int rc;
    2514                 :            : 
    2515                 :          0 :         stat = ena_com_reg_bar_read32(ena_dev, ENA_REGS_DEV_STS_OFF);
    2516                 :          0 :         cap = ena_com_reg_bar_read32(ena_dev, ENA_REGS_CAPS_OFF);
    2517                 :            : 
    2518         [ #  # ]:          0 :         if (unlikely((stat == ENA_MMIO_READ_TIMEOUT) ||
    2519                 :            :                      (cap == ENA_MMIO_READ_TIMEOUT))) {
    2520                 :          0 :                 ena_trc_err(ena_dev, "Reg read32 timeout occurred\n");
    2521                 :          0 :                 return ENA_COM_TIMER_EXPIRED;
    2522                 :            :         }
    2523                 :            : 
    2524         [ #  # ]:          0 :         if ((stat & ENA_REGS_DEV_STS_READY_MASK) == 0) {
    2525                 :          0 :                 ena_trc_err(ena_dev, "Device isn't ready, can't reset device\n");
    2526                 :          0 :                 return ENA_COM_INVAL;
    2527                 :            :         }
    2528                 :            : 
    2529                 :          0 :         timeout = (cap & ENA_REGS_CAPS_RESET_TIMEOUT_MASK) >>
    2530                 :            :                         ENA_REGS_CAPS_RESET_TIMEOUT_SHIFT;
    2531         [ #  # ]:          0 :         if (timeout == 0) {
    2532                 :          0 :                 ena_trc_err(ena_dev, "Invalid timeout value\n");
    2533                 :          0 :                 return ENA_COM_INVAL;
    2534                 :            :         }
    2535                 :            : 
    2536                 :            :         /* start reset */
    2537                 :            :         reset_val = ENA_REGS_DEV_CTL_DEV_RESET_MASK;
    2538                 :            : 
    2539                 :            :         /* For backward compatibility, device will interpret
    2540                 :            :          * bits 24-27 as MSB, bits 28-31 as LSB
    2541                 :            :          */
    2542                 :            :         reset_reason_lsb = ENA_FIELD_GET(reset_reason, ENA_RESET_REASON_LSB_MASK,
    2543                 :            :                                          ENA_RESET_REASON_LSB_OFFSET);
    2544                 :            : 
    2545                 :          0 :         reset_reason_msb = ENA_FIELD_GET(reset_reason, ENA_RESET_REASON_MSB_MASK,
    2546                 :            :                                          ENA_RESET_REASON_MSB_OFFSET);
    2547                 :            : 
    2548         [ #  # ]:          0 :         reset_val |= reset_reason_lsb << ENA_REGS_DEV_CTL_RESET_REASON_SHIFT;
    2549                 :            : 
    2550         [ #  # ]:          0 :         if (ena_com_get_cap(ena_dev, ENA_ADMIN_EXTENDED_RESET_REASONS))
    2551                 :          0 :                 reset_val |= reset_reason_msb << ENA_REGS_DEV_CTL_RESET_REASON_EXT_SHIFT;
    2552         [ #  # ]:          0 :         else if (reset_reason_msb) {
    2553                 :            :                 /* In case the device does not support intended
    2554                 :            :                  * extended reset reason fallback to generic
    2555                 :            :                  */
    2556                 :            :                 reset_val = ENA_REGS_DEV_CTL_DEV_RESET_MASK;
    2557                 :            :                 reset_val |= (ENA_REGS_RESET_GENERIC << ENA_REGS_DEV_CTL_RESET_REASON_SHIFT) &
    2558                 :            :                               ENA_REGS_DEV_CTL_RESET_REASON_MASK;
    2559                 :            :         }
    2560                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, reset_val, ena_dev->reg_bar + ENA_REGS_DEV_CTL_OFF);
    2561                 :            : 
    2562                 :            :         /* Write again the MMIO read request address */
    2563                 :          0 :         ena_com_mmio_reg_read_request_write_dev_addr(ena_dev);
    2564                 :            : 
    2565                 :          0 :         rc = wait_for_reset_state(ena_dev, timeout,
    2566                 :            :                                   ENA_REGS_DEV_STS_RESET_IN_PROGRESS_MASK);
    2567         [ #  # ]:          0 :         if (unlikely(rc)) {
    2568                 :          0 :                 ena_trc_err(ena_dev, "Reset indication didn't turn on\n");
    2569                 :          0 :                 return rc;
    2570                 :            :         }
    2571                 :            : 
    2572                 :            :         /* reset done */
    2573                 :          0 :         ENA_REG_WRITE32(ena_dev->bus, 0, ena_dev->reg_bar + ENA_REGS_DEV_CTL_OFF);
    2574                 :          0 :         rc = wait_for_reset_state(ena_dev, timeout, 0);
    2575         [ #  # ]:          0 :         if (unlikely(rc)) {
    2576                 :          0 :                 ena_trc_err(ena_dev, "Reset indication didn't turn off\n");
    2577                 :          0 :                 return rc;
    2578                 :            :         }
    2579                 :            : 
    2580                 :          0 :         timeout = (cap & ENA_REGS_CAPS_ADMIN_CMD_TO_MASK) >>
    2581                 :            :                 ENA_REGS_CAPS_ADMIN_CMD_TO_SHIFT;
    2582         [ #  # ]:          0 :         if (timeout)
    2583                 :            :                 /* the resolution of timeout reg is 100ms */
    2584                 :          0 :                 ena_dev->admin_queue.completion_timeout = timeout * 100000;
    2585                 :            :         else
    2586                 :          0 :                 ena_dev->admin_queue.completion_timeout = ADMIN_CMD_TIMEOUT_US;
    2587                 :            : 
    2588                 :            :         return 0;
    2589                 :            : }
    2590                 :            : 
    2591         [ #  # ]:          0 : int ena_com_get_eni_stats(struct ena_com_dev *ena_dev,
    2592                 :            :                           struct ena_admin_eni_stats *stats)
    2593                 :            : {
    2594                 :            :         struct ena_com_stats_ctx ctx;
    2595                 :            :         int ret;
    2596                 :            : 
    2597         [ #  # ]:          0 :         if (!ena_com_get_cap(ena_dev, ENA_ADMIN_ENI_STATS)) {
    2598                 :          0 :                 ena_trc_err(ena_dev, "Capability %d isn't supported\n", ENA_ADMIN_ENI_STATS);
    2599                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2600                 :            :         }
    2601                 :            : 
    2602                 :            :         memset(&ctx, 0x0, sizeof(ctx));
    2603                 :          0 :         ret = ena_get_dev_stats(ena_dev, &ctx, ENA_ADMIN_GET_STATS_TYPE_ENI);
    2604         [ #  # ]:          0 :         if (likely(ret == 0))
    2605                 :            :                 memcpy(stats, &ctx.get_resp.u.eni_stats,
    2606                 :            :                        sizeof(ctx.get_resp.u.eni_stats));
    2607                 :            : 
    2608                 :            :         return ret;
    2609                 :            : }
    2610                 :            : 
    2611         [ #  # ]:          0 : int ena_com_get_ena_srd_info(struct ena_com_dev *ena_dev,
    2612                 :            :                               struct ena_admin_ena_srd_info *info)
    2613                 :            : {
    2614                 :            :         struct ena_com_stats_ctx ctx;
    2615                 :            :         int ret;
    2616                 :            : 
    2617         [ #  # ]:          0 :         if (!ena_com_get_cap(ena_dev, ENA_ADMIN_ENA_SRD_INFO)) {
    2618                 :          0 :                 ena_trc_err(ena_dev, "Capability %d isn't supported\n", ENA_ADMIN_ENA_SRD_INFO);
    2619                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2620                 :            :         }
    2621                 :            : 
    2622                 :            :         memset(&ctx, 0x0, sizeof(ctx));
    2623                 :          0 :         ret = ena_get_dev_stats(ena_dev, &ctx, ENA_ADMIN_GET_STATS_TYPE_ENA_SRD);
    2624         [ #  # ]:          0 :         if (likely(ret == 0))
    2625                 :            :                 memcpy(info, &ctx.get_resp.u.ena_srd_info,
    2626                 :            :                        sizeof(ctx.get_resp.u.ena_srd_info));
    2627                 :            : 
    2628                 :            :         return ret;
    2629                 :            : }
    2630                 :            : 
    2631                 :          0 : int ena_com_get_dev_basic_stats(struct ena_com_dev *ena_dev,
    2632                 :            :                                 struct ena_admin_basic_stats *stats)
    2633                 :            : {
    2634                 :            :         struct ena_com_stats_ctx ctx;
    2635                 :            :         int ret;
    2636                 :            : 
    2637                 :            :         memset(&ctx, 0x0, sizeof(ctx));
    2638                 :          0 :         ret = ena_get_dev_stats(ena_dev, &ctx, ENA_ADMIN_GET_STATS_TYPE_BASIC);
    2639         [ #  # ]:          0 :         if (likely(ret == 0))
    2640                 :            :                 memcpy(stats, &ctx.get_resp.u.basic_stats,
    2641                 :            :                        sizeof(ctx.get_resp.u.basic_stats));
    2642                 :            : 
    2643                 :          0 :         return ret;
    2644                 :            : }
    2645                 :            : 
    2646                 :          0 : int ena_com_get_customer_metrics(struct ena_com_dev *ena_dev, char *buffer, u32 len)
    2647                 :            : {
    2648                 :            :         struct ena_admin_aq_get_stats_cmd *get_cmd;
    2649                 :            :         struct ena_com_stats_ctx ctx;
    2650                 :            :         int ret;
    2651                 :            : 
    2652         [ #  # ]:          0 :         if (unlikely(len > ena_dev->customer_metrics.buffer_len)) {
    2653                 :          0 :                 ena_trc_err(ena_dev, "Invalid buffer size %u. The given buffer is too big.\n", len);
    2654                 :          0 :                 return ENA_COM_INVAL;
    2655                 :            :         }
    2656                 :            : 
    2657         [ #  # ]:          0 :         if (!ena_com_get_cap(ena_dev, ENA_ADMIN_CUSTOMER_METRICS)) {
    2658                 :          0 :                 ena_trc_err(ena_dev, "Capability %d not supported.\n", ENA_ADMIN_CUSTOMER_METRICS);
    2659                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2660                 :            :         }
    2661                 :            : 
    2662         [ #  # ]:          0 :         if (!ena_dev->customer_metrics.supported_metrics) {
    2663                 :          0 :                 ena_trc_err(ena_dev, "No supported customer metrics.\n");
    2664                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2665                 :            :         }
    2666                 :            : 
    2667                 :            :         get_cmd = &ctx.get_cmd;
    2668                 :            :         memset(&ctx, 0x0, sizeof(ctx));
    2669                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    2670                 :            :                 &get_cmd->u.control_buffer.address,
    2671                 :            :                 ena_dev->customer_metrics.buffer_dma_addr);
    2672         [ #  # ]:          0 :         if (unlikely(ret)) {
    2673                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed.\n");
    2674                 :          0 :                 return ret;
    2675                 :            :         }
    2676                 :            : 
    2677                 :          0 :         get_cmd->u.control_buffer.length = ena_dev->customer_metrics.buffer_len;
    2678                 :          0 :         get_cmd->requested_metrics = ena_dev->customer_metrics.supported_metrics;
    2679                 :          0 :         ret = ena_get_dev_stats(ena_dev, &ctx, ENA_ADMIN_GET_STATS_TYPE_CUSTOMER_METRICS);
    2680         [ #  # ]:          0 :         if (likely(ret == 0))
    2681         [ #  # ]:          0 :                 memcpy(buffer, ena_dev->customer_metrics.buffer_virt_addr, len);
    2682                 :            :         else
    2683                 :          0 :                 ena_trc_err(ena_dev, "Failed to get customer metrics. error: %d\n", ret);
    2684                 :            : 
    2685                 :            :         return ret;
    2686                 :            : }
    2687                 :            : 
    2688         [ #  # ]:          0 : int ena_com_set_dev_mtu(struct ena_com_dev *ena_dev, u32 mtu)
    2689                 :            : {
    2690                 :            :         struct ena_com_admin_queue *admin_queue;
    2691                 :            :         struct ena_admin_set_feat_cmd cmd;
    2692                 :            :         struct ena_admin_set_feat_resp resp;
    2693                 :            :         int ret;
    2694                 :            : 
    2695                 :            :         if (!ena_com_check_supported_feature_id(ena_dev, ENA_ADMIN_MTU)) {
    2696                 :          0 :                 ena_trc_dbg(ena_dev, "Feature %d isn't supported\n", ENA_ADMIN_MTU);
    2697                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2698                 :            :         }
    2699                 :            : 
    2700                 :            :         memset(&cmd, 0x0, sizeof(cmd));
    2701                 :          0 :         admin_queue = &ena_dev->admin_queue;
    2702                 :            : 
    2703                 :          0 :         cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
    2704                 :            :         cmd.aq_common_descriptor.flags = 0;
    2705                 :          0 :         cmd.feat_common.feature_id = ENA_ADMIN_MTU;
    2706                 :          0 :         cmd.u.mtu.mtu = mtu;
    2707                 :            : 
    2708                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    2709                 :            :                                             (struct ena_admin_aq_entry *)&cmd,
    2710                 :            :                                             sizeof(cmd),
    2711                 :            :                                             (struct ena_admin_acq_entry *)&resp,
    2712                 :            :                                             sizeof(resp));
    2713                 :            : 
    2714         [ #  # ]:          0 :         if (unlikely(ret))
    2715                 :          0 :                 ena_trc_err(ena_dev, "Failed to set mtu %d. error: %d\n", mtu, ret);
    2716                 :            : 
    2717                 :            :         return ret;
    2718                 :            : }
    2719                 :            : 
    2720                 :          0 : int ena_com_get_offload_settings(struct ena_com_dev *ena_dev,
    2721                 :            :                                  struct ena_admin_feature_offload_desc *offload)
    2722                 :            : {
    2723                 :            :         int ret;
    2724                 :            :         struct ena_admin_get_feat_resp resp;
    2725                 :            : 
    2726                 :            :         ret = ena_com_get_feature(ena_dev, &resp,
    2727                 :            :                                   ENA_ADMIN_STATELESS_OFFLOAD_CONFIG, 0);
    2728         [ #  # ]:          0 :         if (unlikely(ret)) {
    2729                 :          0 :                 ena_trc_err(ena_dev, "Failed to get offload capabilities %d\n", ret);
    2730                 :          0 :                 return ret;
    2731                 :            :         }
    2732                 :            : 
    2733                 :            :         memcpy(offload, &resp.u.offload, sizeof(resp.u.offload));
    2734                 :            : 
    2735                 :            :         return 0;
    2736                 :            : }
    2737                 :            : 
    2738                 :          0 : int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
    2739                 :            : {
    2740         [ #  # ]:          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    2741                 :            :         struct ena_rss *rss = &ena_dev->rss;
    2742                 :            :         struct ena_admin_set_feat_cmd cmd;
    2743                 :            :         struct ena_admin_set_feat_resp resp;
    2744                 :            :         struct ena_admin_get_feat_resp get_resp;
    2745                 :            :         int ret;
    2746                 :            : 
    2747                 :            :         if (!ena_com_check_supported_feature_id(ena_dev,
    2748                 :            :                                                 ENA_ADMIN_RSS_HASH_FUNCTION)) {
    2749                 :          0 :                 ena_trc_dbg(ena_dev, "Feature %d isn't supported\n",
    2750                 :            :                             ENA_ADMIN_RSS_HASH_FUNCTION);
    2751                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2752                 :            :         }
    2753                 :            : 
    2754                 :            :         /* Validate hash function is supported */
    2755                 :            :         ret = ena_com_get_feature(ena_dev, &get_resp,
    2756                 :            :                                   ENA_ADMIN_RSS_HASH_FUNCTION, 0);
    2757         [ #  # ]:          0 :         if (unlikely(ret))
    2758                 :            :                 return ret;
    2759                 :            : 
    2760         [ #  # ]:          0 :         if (!(get_resp.u.flow_hash_func.supported_func & BIT(rss->hash_func))) {
    2761                 :          0 :                 ena_trc_err(ena_dev, "Func hash %d isn't supported by device, abort\n",
    2762                 :            :                             rss->hash_func);
    2763                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2764                 :            :         }
    2765                 :            : 
    2766                 :            :         memset(&cmd, 0x0, sizeof(cmd));
    2767                 :            : 
    2768                 :          0 :         cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
    2769                 :          0 :         cmd.aq_common_descriptor.flags =
    2770                 :            :                 ENA_ADMIN_AQ_COMMON_DESC_CTRL_DATA_INDIRECT_MASK;
    2771                 :          0 :         cmd.feat_common.feature_id = ENA_ADMIN_RSS_HASH_FUNCTION;
    2772                 :          0 :         cmd.u.flow_hash_func.init_val = rss->hash_init_val;
    2773                 :          0 :         cmd.u.flow_hash_func.selected_func = 1 << rss->hash_func;
    2774                 :            : 
    2775                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    2776                 :            :                                    &cmd.control_buffer.address,
    2777                 :            :                                    rss->hash_key_dma_addr);
    2778         [ #  # ]:          0 :         if (unlikely(ret)) {
    2779                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed\n");
    2780                 :          0 :                 return ret;
    2781                 :            :         }
    2782                 :            : 
    2783                 :          0 :         cmd.control_buffer.length = sizeof(*rss->hash_key);
    2784                 :            : 
    2785                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    2786                 :            :                                             (struct ena_admin_aq_entry *)&cmd,
    2787                 :            :                                             sizeof(cmd),
    2788                 :            :                                             (struct ena_admin_acq_entry *)&resp,
    2789                 :            :                                             sizeof(resp));
    2790         [ #  # ]:          0 :         if (unlikely(ret)) {
    2791                 :          0 :                 ena_trc_err(ena_dev, "Failed to set hash function %d. error: %d\n",
    2792                 :            :                             rss->hash_func, ret);
    2793                 :          0 :                 return ENA_COM_INVAL;
    2794                 :            :         }
    2795                 :            : 
    2796                 :            :         return 0;
    2797                 :            : }
    2798                 :            : 
    2799                 :          0 : int ena_com_fill_hash_function(struct ena_com_dev *ena_dev,
    2800                 :            :                                enum ena_admin_hash_functions func,
    2801                 :            :                                const u8 *key, u16 key_len, u32 init_val)
    2802                 :            : {
    2803                 :            :         struct ena_admin_feature_rss_flow_hash_control *hash_key;
    2804                 :            :         struct ena_admin_get_feat_resp get_resp;
    2805                 :            :         enum ena_admin_hash_functions old_func;
    2806                 :            :         struct ena_rss *rss = &ena_dev->rss;
    2807                 :            :         int rc;
    2808                 :            : 
    2809                 :          0 :         hash_key = rss->hash_key;
    2810                 :            : 
    2811                 :            :         /* Make sure size is a mult of DWs */
    2812         [ #  # ]:          0 :         if (unlikely(key_len & 0x3))
    2813                 :            :                 return ENA_COM_INVAL;
    2814                 :            : 
    2815                 :          0 :         rc = ena_com_get_feature_ex(ena_dev, &get_resp,
    2816                 :            :                                     ENA_ADMIN_RSS_HASH_FUNCTION,
    2817                 :            :                                     rss->hash_key_dma_addr,
    2818                 :            :                                     sizeof(*rss->hash_key), 0);
    2819         [ #  # ]:          0 :         if (unlikely(rc))
    2820                 :            :                 return rc;
    2821                 :            : 
    2822         [ #  # ]:          0 :         if (!(BIT(func) & get_resp.u.flow_hash_func.supported_func)) {
    2823                 :          0 :                 ena_trc_err(ena_dev, "Flow hash function %d isn't supported\n", func);
    2824                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2825                 :            :         }
    2826                 :            : 
    2827         [ #  # ]:          0 :         if (func == ENA_ADMIN_TOEPLITZ && key) {
    2828         [ #  # ]:          0 :                 if (key_len != sizeof(hash_key->key)) {
    2829                 :          0 :                         ena_trc_err(ena_dev, "key len (%u) doesn't equal the supported size (%zu)\n",
    2830                 :            :                                     key_len, sizeof(hash_key->key));
    2831                 :          0 :                         return ENA_COM_INVAL;
    2832                 :            :                 }
    2833         [ #  # ]:          0 :                 memcpy(hash_key->key, key, key_len);
    2834                 :          0 :                 hash_key->key_parts = key_len / sizeof(hash_key->key[0]);
    2835                 :            :         }
    2836                 :            : 
    2837                 :          0 :         rss->hash_init_val = init_val;
    2838                 :          0 :         old_func = rss->hash_func;
    2839                 :          0 :         rss->hash_func = func;
    2840                 :          0 :         rc = ena_com_set_hash_function(ena_dev);
    2841                 :            : 
    2842                 :            :         /* Restore the old function */
    2843         [ #  # ]:          0 :         if (unlikely(rc))
    2844                 :          0 :                 rss->hash_func = old_func;
    2845                 :            : 
    2846                 :            :         return rc;
    2847                 :            : }
    2848                 :            : 
    2849                 :          0 : int ena_com_get_hash_function(struct ena_com_dev *ena_dev,
    2850                 :            :                               enum ena_admin_hash_functions *func)
    2851                 :            : {
    2852                 :            :         struct ena_rss *rss = &ena_dev->rss;
    2853                 :            :         struct ena_admin_get_feat_resp get_resp;
    2854                 :            :         int rc;
    2855                 :            : 
    2856         [ #  # ]:          0 :         if (unlikely(!func))
    2857                 :            :                 return ENA_COM_INVAL;
    2858                 :            : 
    2859                 :          0 :         rc = ena_com_get_feature_ex(ena_dev, &get_resp,
    2860                 :            :                                     ENA_ADMIN_RSS_HASH_FUNCTION,
    2861                 :            :                                     rss->hash_key_dma_addr,
    2862                 :            :                                     sizeof(*rss->hash_key), 0);
    2863         [ #  # ]:          0 :         if (unlikely(rc))
    2864                 :            :                 return rc;
    2865                 :            : 
    2866                 :            :         /* ENA_FFS() returns 1 in case the lsb is set */
    2867                 :          0 :         rss->hash_func = ENA_FFS(get_resp.u.flow_hash_func.selected_func);
    2868         [ #  # ]:          0 :         if (rss->hash_func)
    2869                 :          0 :                 rss->hash_func--;
    2870                 :            : 
    2871                 :          0 :         *func = rss->hash_func;
    2872                 :            : 
    2873                 :          0 :         return 0;
    2874                 :            : }
    2875                 :            : 
    2876                 :          0 : int ena_com_get_hash_key(struct ena_com_dev *ena_dev, u8 *key)
    2877                 :            : {
    2878                 :          0 :         struct ena_admin_feature_rss_flow_hash_control *hash_key =
    2879                 :            :                 ena_dev->rss.hash_key;
    2880                 :            : 
    2881         [ #  # ]:          0 :         if (key)
    2882                 :          0 :                 memcpy(key, hash_key->key,
    2883         [ #  # ]:          0 :                        (size_t)(hash_key->key_parts) * sizeof(hash_key->key[0]));
    2884                 :            : 
    2885                 :          0 :         return 0;
    2886                 :            : }
    2887                 :            : 
    2888                 :          0 : int ena_com_get_hash_ctrl(struct ena_com_dev *ena_dev,
    2889                 :            :                           enum ena_admin_flow_hash_proto proto,
    2890                 :            :                           u16 *fields)
    2891                 :            : {
    2892                 :            :         struct ena_rss *rss = &ena_dev->rss;
    2893                 :            :         struct ena_admin_get_feat_resp get_resp;
    2894                 :            :         int rc;
    2895                 :            : 
    2896                 :          0 :         rc = ena_com_get_feature_ex(ena_dev, &get_resp,
    2897                 :            :                                     ENA_ADMIN_RSS_HASH_INPUT,
    2898                 :            :                                     rss->hash_ctrl_dma_addr,
    2899                 :            :                                     sizeof(*rss->hash_ctrl), 0);
    2900         [ #  # ]:          0 :         if (unlikely(rc))
    2901                 :            :                 return rc;
    2902                 :            : 
    2903         [ #  # ]:          0 :         if (fields)
    2904                 :          0 :                 *fields = rss->hash_ctrl->selected_fields[proto].fields;
    2905                 :            : 
    2906                 :            :         return 0;
    2907                 :            : }
    2908                 :            : 
    2909                 :          0 : int ena_com_set_hash_ctrl(struct ena_com_dev *ena_dev)
    2910                 :            : {
    2911         [ #  # ]:          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    2912                 :            :         struct ena_rss *rss = &ena_dev->rss;
    2913                 :            :         struct ena_admin_feature_rss_hash_control *hash_ctrl = rss->hash_ctrl;
    2914                 :            :         struct ena_admin_set_feat_cmd cmd;
    2915                 :            :         struct ena_admin_set_feat_resp resp;
    2916                 :            :         int ret;
    2917                 :            : 
    2918                 :            :         if (!ena_com_check_supported_feature_id(ena_dev,
    2919                 :            :                                                 ENA_ADMIN_RSS_HASH_INPUT)) {
    2920                 :          0 :                 ena_trc_dbg(ena_dev, "Feature %d isn't supported\n",
    2921                 :            :                             ENA_ADMIN_RSS_HASH_INPUT);
    2922                 :          0 :                 return ENA_COM_UNSUPPORTED;
    2923                 :            :         }
    2924                 :            : 
    2925                 :            :         memset(&cmd, 0x0, sizeof(cmd));
    2926                 :            : 
    2927                 :          0 :         cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
    2928                 :          0 :         cmd.aq_common_descriptor.flags =
    2929                 :            :                 ENA_ADMIN_AQ_COMMON_DESC_CTRL_DATA_INDIRECT_MASK;
    2930                 :          0 :         cmd.feat_common.feature_id = ENA_ADMIN_RSS_HASH_INPUT;
    2931                 :          0 :         cmd.u.flow_hash_input.enabled_input_sort =
    2932                 :            :                 ENA_ADMIN_FEATURE_RSS_FLOW_HASH_INPUT_L3_SORT_MASK |
    2933                 :            :                 ENA_ADMIN_FEATURE_RSS_FLOW_HASH_INPUT_L4_SORT_MASK;
    2934                 :            : 
    2935                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    2936                 :            :                                    &cmd.control_buffer.address,
    2937                 :            :                                    rss->hash_ctrl_dma_addr);
    2938         [ #  # ]:          0 :         if (unlikely(ret)) {
    2939                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed\n");
    2940                 :          0 :                 return ret;
    2941                 :            :         }
    2942                 :          0 :         cmd.control_buffer.length = sizeof(*hash_ctrl);
    2943                 :            : 
    2944                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    2945                 :            :                                             (struct ena_admin_aq_entry *)&cmd,
    2946                 :            :                                             sizeof(cmd),
    2947                 :            :                                             (struct ena_admin_acq_entry *)&resp,
    2948                 :            :                                             sizeof(resp));
    2949         [ #  # ]:          0 :         if (unlikely(ret))
    2950                 :          0 :                 ena_trc_err(ena_dev, "Failed to set hash input. error: %d\n", ret);
    2951                 :            : 
    2952                 :            :         return ret;
    2953                 :            : }
    2954                 :            : 
    2955                 :          0 : int ena_com_set_default_hash_ctrl(struct ena_com_dev *ena_dev)
    2956                 :            : {
    2957                 :            :         struct ena_rss *rss = &ena_dev->rss;
    2958                 :          0 :         struct ena_admin_feature_rss_hash_control *hash_ctrl =
    2959                 :            :                 rss->hash_ctrl;
    2960                 :            :         u16 available_fields = 0;
    2961                 :            :         int rc, i;
    2962                 :            : 
    2963                 :            :         /* Get the supported hash input */
    2964                 :          0 :         rc = ena_com_get_hash_ctrl(ena_dev, 0, NULL);
    2965         [ #  # ]:          0 :         if (unlikely(rc))
    2966                 :            :                 return rc;
    2967                 :            : 
    2968                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_TCP4].fields =
    2969                 :            :                 ENA_ADMIN_RSS_L3_SA | ENA_ADMIN_RSS_L3_DA |
    2970                 :            :                 ENA_ADMIN_RSS_L4_DP | ENA_ADMIN_RSS_L4_SP;
    2971                 :            : 
    2972                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_UDP4].fields =
    2973                 :            :                 ENA_ADMIN_RSS_L3_SA | ENA_ADMIN_RSS_L3_DA |
    2974                 :            :                 ENA_ADMIN_RSS_L4_DP | ENA_ADMIN_RSS_L4_SP;
    2975                 :            : 
    2976                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_TCP6].fields =
    2977                 :            :                 ENA_ADMIN_RSS_L3_SA | ENA_ADMIN_RSS_L3_DA |
    2978                 :            :                 ENA_ADMIN_RSS_L4_DP | ENA_ADMIN_RSS_L4_SP;
    2979                 :            : 
    2980                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_UDP6].fields =
    2981                 :            :                 ENA_ADMIN_RSS_L3_SA | ENA_ADMIN_RSS_L3_DA |
    2982                 :            :                 ENA_ADMIN_RSS_L4_DP | ENA_ADMIN_RSS_L4_SP;
    2983                 :            : 
    2984                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_IP4].fields =
    2985                 :            :                 ENA_ADMIN_RSS_L3_SA | ENA_ADMIN_RSS_L3_DA;
    2986                 :            : 
    2987                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_IP6].fields =
    2988                 :            :                 ENA_ADMIN_RSS_L3_SA | ENA_ADMIN_RSS_L3_DA;
    2989                 :            : 
    2990                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_IP4_FRAG].fields =
    2991                 :            :                 ENA_ADMIN_RSS_L3_SA | ENA_ADMIN_RSS_L3_DA;
    2992                 :            : 
    2993                 :          0 :         hash_ctrl->selected_fields[ENA_ADMIN_RSS_NOT_IP].fields =
    2994                 :            :                 ENA_ADMIN_RSS_L2_DA | ENA_ADMIN_RSS_L2_SA;
    2995                 :            : 
    2996         [ #  # ]:          0 :         for (i = 0; i < ENA_ADMIN_RSS_PROTO_NUM; i++) {
    2997                 :          0 :                 available_fields = hash_ctrl->selected_fields[i].fields &
    2998                 :          0 :                                 hash_ctrl->supported_fields[i].fields;
    2999         [ #  # ]:          0 :                 if (available_fields != hash_ctrl->selected_fields[i].fields) {
    3000                 :          0 :                         ena_trc_err(ena_dev, "Hash control doesn't support all the desire configuration. proto %x supported %x selected %x\n",
    3001                 :            :                                     i, hash_ctrl->supported_fields[i].fields,
    3002                 :            :                                     hash_ctrl->selected_fields[i].fields);
    3003                 :          0 :                         return ENA_COM_UNSUPPORTED;
    3004                 :            :                 }
    3005                 :            :         }
    3006                 :            : 
    3007                 :          0 :         rc = ena_com_set_hash_ctrl(ena_dev);
    3008                 :            : 
    3009                 :            :         /* In case of failure, restore the old hash ctrl */
    3010         [ #  # ]:          0 :         if (unlikely(rc))
    3011                 :          0 :                 ena_com_get_hash_ctrl(ena_dev, 0, NULL);
    3012                 :            : 
    3013                 :            :         return rc;
    3014                 :            : }
    3015                 :            : 
    3016                 :          0 : int ena_com_fill_hash_ctrl(struct ena_com_dev *ena_dev,
    3017                 :            :                            enum ena_admin_flow_hash_proto proto,
    3018                 :            :                            u16 hash_fields)
    3019                 :            : {
    3020                 :            :         struct ena_rss *rss = &ena_dev->rss;
    3021                 :          0 :         struct ena_admin_feature_rss_hash_control *hash_ctrl = rss->hash_ctrl;
    3022                 :            :         u16 supported_fields;
    3023                 :            :         int rc;
    3024                 :            : 
    3025         [ #  # ]:          0 :         if (proto >= ENA_ADMIN_RSS_PROTO_NUM) {
    3026                 :          0 :                 ena_trc_err(ena_dev, "Invalid proto num (%u)\n", proto);
    3027                 :          0 :                 return ENA_COM_INVAL;
    3028                 :            :         }
    3029                 :            : 
    3030                 :            :         /* Get the ctrl table */
    3031                 :          0 :         rc = ena_com_get_hash_ctrl(ena_dev, proto, NULL);
    3032         [ #  # ]:          0 :         if (unlikely(rc))
    3033                 :            :                 return rc;
    3034                 :            : 
    3035                 :            :         /* Make sure all the fields are supported */
    3036                 :          0 :         supported_fields = hash_ctrl->supported_fields[proto].fields;
    3037         [ #  # ]:          0 :         if ((hash_fields & supported_fields) != hash_fields) {
    3038                 :          0 :                 ena_trc_err(ena_dev, "Proto %d doesn't support the required fields %x. supports only: %x\n",
    3039                 :            :                             proto, hash_fields, supported_fields);
    3040                 :            :         }
    3041                 :            : 
    3042                 :          0 :         hash_ctrl->selected_fields[proto].fields = hash_fields;
    3043                 :            : 
    3044                 :          0 :         rc = ena_com_set_hash_ctrl(ena_dev);
    3045                 :            : 
    3046                 :            :         /* In case of failure, restore the old hash ctrl */
    3047         [ #  # ]:          0 :         if (unlikely(rc))
    3048                 :          0 :                 ena_com_get_hash_ctrl(ena_dev, 0, NULL);
    3049                 :            : 
    3050                 :            :         return 0;
    3051                 :            : }
    3052                 :            : 
    3053                 :          0 : int ena_com_indirect_table_fill_entry(struct ena_com_dev *ena_dev,
    3054                 :            :                                       u16 entry_idx, u16 entry_value)
    3055                 :            : {
    3056                 :            :         struct ena_rss *rss = &ena_dev->rss;
    3057                 :            : 
    3058         [ #  # ]:          0 :         if (unlikely(entry_idx >= (1 << rss->tbl_log_size)))
    3059                 :            :                 return ENA_COM_INVAL;
    3060                 :            : 
    3061         [ #  # ]:          0 :         if (unlikely((entry_value > ENA_TOTAL_NUM_QUEUES)))
    3062                 :            :                 return ENA_COM_INVAL;
    3063                 :            : 
    3064                 :          0 :         rss->host_rss_ind_tbl[entry_idx] = entry_value;
    3065                 :            : 
    3066                 :          0 :         return 0;
    3067                 :            : }
    3068                 :            : 
    3069                 :          0 : int ena_com_indirect_table_set(struct ena_com_dev *ena_dev)
    3070                 :            : {
    3071         [ #  # ]:          0 :         struct ena_com_admin_queue *admin_queue = &ena_dev->admin_queue;
    3072                 :            :         struct ena_rss *rss = &ena_dev->rss;
    3073                 :            :         struct ena_admin_set_feat_cmd cmd;
    3074                 :            :         struct ena_admin_set_feat_resp resp;
    3075                 :            :         int ret;
    3076                 :            : 
    3077                 :            :         if (!ena_com_check_supported_feature_id(ena_dev,
    3078                 :            :                                                 ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG)) {
    3079                 :          0 :                 ena_trc_dbg(ena_dev, "Feature %d isn't supported\n",
    3080                 :            :                             ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG);
    3081                 :          0 :                 return ENA_COM_UNSUPPORTED;
    3082                 :            :         }
    3083                 :            : 
    3084                 :          0 :         ret = ena_com_ind_tbl_convert_to_device(ena_dev);
    3085         [ #  # ]:          0 :         if (ret) {
    3086                 :          0 :                 ena_trc_err(ena_dev, "Failed to convert host indirection table to device table\n");
    3087                 :          0 :                 return ret;
    3088                 :            :         }
    3089                 :            : 
    3090                 :            :         memset(&cmd, 0x0, sizeof(cmd));
    3091                 :            : 
    3092                 :          0 :         cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
    3093                 :          0 :         cmd.aq_common_descriptor.flags =
    3094                 :            :                 ENA_ADMIN_AQ_COMMON_DESC_CTRL_DATA_INDIRECT_MASK;
    3095                 :          0 :         cmd.feat_common.feature_id = ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG;
    3096                 :          0 :         cmd.u.ind_table.size = rss->tbl_log_size;
    3097                 :          0 :         cmd.u.ind_table.inline_index = 0xFFFFFFFF;
    3098                 :            : 
    3099                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    3100                 :            :                                    &cmd.control_buffer.address,
    3101                 :            :                                    rss->rss_ind_tbl_dma_addr);
    3102         [ #  # ]:          0 :         if (unlikely(ret)) {
    3103                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed\n");
    3104                 :          0 :                 return ret;
    3105                 :            :         }
    3106                 :            : 
    3107                 :          0 :         cmd.control_buffer.length = (1ULL << rss->tbl_log_size) *
    3108                 :            :                 sizeof(struct ena_admin_rss_ind_table_entry);
    3109                 :            : 
    3110                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    3111                 :            :                                             (struct ena_admin_aq_entry *)&cmd,
    3112                 :            :                                             sizeof(cmd),
    3113                 :            :                                             (struct ena_admin_acq_entry *)&resp,
    3114                 :            :                                             sizeof(resp));
    3115                 :            : 
    3116         [ #  # ]:          0 :         if (unlikely(ret))
    3117                 :          0 :                 ena_trc_err(ena_dev, "Failed to set indirect table. error: %d\n", ret);
    3118                 :            : 
    3119                 :            :         return ret;
    3120                 :            : }
    3121                 :            : 
    3122                 :          0 : int ena_com_indirect_table_get(struct ena_com_dev *ena_dev, u32 *ind_tbl)
    3123                 :            : {
    3124                 :            :         struct ena_rss *rss = &ena_dev->rss;
    3125                 :            :         struct ena_admin_get_feat_resp get_resp;
    3126                 :            :         u32 tbl_size;
    3127                 :            :         int i, rc;
    3128                 :            : 
    3129                 :          0 :         tbl_size = (1ULL << rss->tbl_log_size) *
    3130                 :            :                 sizeof(struct ena_admin_rss_ind_table_entry);
    3131                 :            : 
    3132                 :          0 :         rc = ena_com_get_feature_ex(ena_dev, &get_resp,
    3133                 :            :                                     ENA_ADMIN_RSS_INDIRECTION_TABLE_CONFIG,
    3134                 :            :                                     rss->rss_ind_tbl_dma_addr,
    3135                 :            :                                     tbl_size, 0);
    3136         [ #  # ]:          0 :         if (unlikely(rc))
    3137                 :            :                 return rc;
    3138                 :            : 
    3139         [ #  # ]:          0 :         if (!ind_tbl)
    3140                 :            :                 return 0;
    3141                 :            : 
    3142         [ #  # ]:          0 :         for (i = 0; i < (1 << rss->tbl_log_size); i++)
    3143                 :          0 :                 ind_tbl[i] = rss->host_rss_ind_tbl[i];
    3144                 :            : 
    3145                 :            :         return 0;
    3146                 :            : }
    3147                 :            : 
    3148                 :          0 : int ena_com_rss_init(struct ena_com_dev *ena_dev, u16 indr_tbl_log_size)
    3149                 :            : {
    3150                 :            :         int rc;
    3151                 :            : 
    3152                 :          0 :         memset(&ena_dev->rss, 0x0, sizeof(ena_dev->rss));
    3153                 :            : 
    3154                 :          0 :         rc = ena_com_indirect_table_allocate(ena_dev, indr_tbl_log_size);
    3155         [ #  # ]:          0 :         if (unlikely(rc))
    3156                 :          0 :                 goto err_indr_tbl;
    3157                 :            : 
    3158                 :            :         /* The following function might return unsupported in case the
    3159                 :            :          * device doesn't support setting the key / hash function. We can safely
    3160                 :            :          * ignore this error and have indirection table support only.
    3161                 :            :          */
    3162                 :          0 :         rc = ena_com_hash_key_allocate(ena_dev);
    3163         [ #  # ]:          0 :         if (likely(!rc))
    3164                 :            :                 ena_com_hash_key_fill_default_key(ena_dev);
    3165         [ #  # ]:          0 :         else if (rc != ENA_COM_UNSUPPORTED)
    3166                 :          0 :                 goto err_hash_key;
    3167                 :            : 
    3168                 :          0 :         rc = ena_com_hash_ctrl_init(ena_dev);
    3169         [ #  # ]:          0 :         if (unlikely(rc))
    3170         [ #  # ]:          0 :                 goto err_hash_ctrl;
    3171                 :            : 
    3172                 :            :         return 0;
    3173                 :            : 
    3174                 :            : err_hash_ctrl:
    3175                 :            :         ena_com_hash_key_destroy(ena_dev);
    3176                 :          0 : err_hash_key:
    3177                 :          0 :         ena_com_indirect_table_destroy(ena_dev);
    3178                 :            : err_indr_tbl:
    3179                 :            : 
    3180                 :            :         return rc;
    3181                 :            : }
    3182                 :            : 
    3183                 :          0 : void ena_com_rss_destroy(struct ena_com_dev *ena_dev)
    3184                 :            : {
    3185                 :          0 :         ena_com_indirect_table_destroy(ena_dev);
    3186                 :            :         ena_com_hash_key_destroy(ena_dev);
    3187                 :            :         ena_com_hash_ctrl_destroy(ena_dev);
    3188                 :            : 
    3189                 :          0 :         memset(&ena_dev->rss, 0x0, sizeof(ena_dev->rss));
    3190                 :          0 : }
    3191                 :            : 
    3192                 :          0 : int ena_com_allocate_host_info(struct ena_com_dev *ena_dev)
    3193                 :            : {
    3194                 :            :         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
    3195                 :            : 
    3196                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    3197                 :            :                                SZ_4K,
    3198                 :            :                                host_attr->host_info,
    3199                 :            :                                host_attr->host_info_dma_addr,
    3200                 :            :                                host_attr->host_info_dma_handle);
    3201         [ #  # ]:          0 :         if (unlikely(!host_attr->host_info))
    3202                 :            :                 return ENA_COM_NO_MEM;
    3203                 :            : 
    3204                 :          0 :         host_attr->host_info->ena_spec_version = ((ENA_COMMON_SPEC_VERSION_MAJOR <<
    3205                 :            :                 ENA_REGS_VERSION_MAJOR_VERSION_SHIFT) |
    3206                 :            :                 (ENA_COMMON_SPEC_VERSION_MINOR));
    3207                 :            : 
    3208                 :          0 :         return 0;
    3209                 :            : }
    3210                 :            : 
    3211                 :          0 : int ena_com_allocate_debug_area(struct ena_com_dev *ena_dev,
    3212                 :            :                                 u32 debug_area_size)
    3213                 :            : {
    3214                 :            :         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
    3215                 :            : 
    3216                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    3217                 :            :                                debug_area_size,
    3218                 :            :                                host_attr->debug_area_virt_addr,
    3219                 :            :                                host_attr->debug_area_dma_addr,
    3220                 :            :                                host_attr->debug_area_dma_handle);
    3221         [ #  # ]:          0 :         if (unlikely(!host_attr->debug_area_virt_addr)) {
    3222                 :          0 :                 host_attr->debug_area_size = 0;
    3223                 :          0 :                 return ENA_COM_NO_MEM;
    3224                 :            :         }
    3225                 :            : 
    3226                 :          0 :         host_attr->debug_area_size = debug_area_size;
    3227                 :            : 
    3228                 :          0 :         return 0;
    3229                 :            : }
    3230                 :            : 
    3231                 :          0 : int ena_com_allocate_customer_metrics_buffer(struct ena_com_dev *ena_dev)
    3232                 :            : {
    3233                 :            :         struct ena_customer_metrics *customer_metrics = &ena_dev->customer_metrics;
    3234                 :            : 
    3235                 :          0 :         customer_metrics->buffer_len = ENA_CUSTOMER_METRICS_BUFFER_SIZE;
    3236                 :          0 :         customer_metrics->buffer_virt_addr = NULL;
    3237                 :            : 
    3238                 :          0 :         ENA_MEM_ALLOC_COHERENT(ena_dev->dmadev,
    3239                 :            :                                customer_metrics->buffer_len,
    3240                 :            :                                customer_metrics->buffer_virt_addr,
    3241                 :            :                                customer_metrics->buffer_dma_addr,
    3242                 :            :                                customer_metrics->buffer_dma_handle);
    3243         [ #  # ]:          0 :         if (unlikely(!customer_metrics->buffer_virt_addr)) {
    3244                 :          0 :                 customer_metrics->buffer_len = 0;
    3245                 :          0 :                 return ENA_COM_NO_MEM;
    3246                 :            :         }
    3247                 :            : 
    3248                 :            :         return 0;
    3249                 :            : }
    3250                 :            : 
    3251                 :          0 : void ena_com_delete_host_info(struct ena_com_dev *ena_dev)
    3252                 :            : {
    3253                 :            :         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
    3254                 :            : 
    3255         [ #  # ]:          0 :         if (host_attr->host_info) {
    3256                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    3257                 :            :                                       SZ_4K,
    3258                 :            :                                       host_attr->host_info,
    3259                 :            :                                       host_attr->host_info_dma_addr,
    3260                 :            :                                       host_attr->host_info_dma_handle);
    3261                 :          0 :                 host_attr->host_info = NULL;
    3262                 :            :         }
    3263                 :          0 : }
    3264                 :            : 
    3265                 :          0 : void ena_com_delete_debug_area(struct ena_com_dev *ena_dev)
    3266                 :            : {
    3267                 :            :         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
    3268                 :            : 
    3269         [ #  # ]:          0 :         if (host_attr->debug_area_virt_addr) {
    3270                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    3271                 :            :                                       host_attr->debug_area_size,
    3272                 :            :                                       host_attr->debug_area_virt_addr,
    3273                 :            :                                       host_attr->debug_area_dma_addr,
    3274                 :            :                                       host_attr->debug_area_dma_handle);
    3275                 :          0 :                 host_attr->debug_area_virt_addr = NULL;
    3276                 :            :         }
    3277                 :          0 : }
    3278                 :            : 
    3279                 :          0 : void ena_com_delete_customer_metrics_buffer(struct ena_com_dev *ena_dev)
    3280                 :            : {
    3281                 :            :         struct ena_customer_metrics *customer_metrics = &ena_dev->customer_metrics;
    3282                 :            : 
    3283         [ #  # ]:          0 :         if (customer_metrics->buffer_virt_addr) {
    3284                 :          0 :                 ENA_MEM_FREE_COHERENT(ena_dev->dmadev,
    3285                 :            :                                       customer_metrics->buffer_len,
    3286                 :            :                                       customer_metrics->buffer_virt_addr,
    3287                 :            :                                       customer_metrics->buffer_dma_addr,
    3288                 :            :                                       customer_metrics->buffer_dma_handle);
    3289                 :          0 :                 customer_metrics->buffer_virt_addr = NULL;
    3290                 :          0 :                 customer_metrics->buffer_len = 0;
    3291                 :            :         }
    3292                 :          0 : }
    3293                 :            : 
    3294                 :          0 : int ena_com_set_host_attributes(struct ena_com_dev *ena_dev)
    3295                 :            : {
    3296                 :            :         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
    3297                 :            :         struct ena_com_admin_queue *admin_queue;
    3298                 :            :         struct ena_admin_set_feat_cmd cmd;
    3299                 :            :         struct ena_admin_set_feat_resp resp;
    3300                 :            : 
    3301                 :            :         int ret;
    3302                 :            : 
    3303                 :            :         /* Host attribute config is called before ena_com_get_dev_attr_feat
    3304                 :            :          * so ena_com can't check if the feature is supported.
    3305                 :            :          */
    3306                 :            : 
    3307                 :            :         memset(&cmd, 0x0, sizeof(cmd));
    3308                 :          0 :         admin_queue = &ena_dev->admin_queue;
    3309                 :            : 
    3310                 :          0 :         cmd.aq_common_descriptor.opcode = ENA_ADMIN_SET_FEATURE;
    3311                 :          0 :         cmd.feat_common.feature_id = ENA_ADMIN_HOST_ATTR_CONFIG;
    3312                 :            : 
    3313                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    3314                 :            :                                    &cmd.u.host_attr.debug_ba,
    3315                 :            :                                    host_attr->debug_area_dma_addr);
    3316         [ #  # ]:          0 :         if (unlikely(ret)) {
    3317                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed\n");
    3318                 :          0 :                 return ret;
    3319                 :            :         }
    3320                 :            : 
    3321                 :          0 :         ret = ena_com_mem_addr_set(ena_dev,
    3322                 :            :                                    &cmd.u.host_attr.os_info_ba,
    3323                 :            :                                    host_attr->host_info_dma_addr);
    3324         [ #  # ]:          0 :         if (unlikely(ret)) {
    3325                 :          0 :                 ena_trc_err(ena_dev, "Memory address set failed\n");
    3326                 :          0 :                 return ret;
    3327                 :            :         }
    3328                 :            : 
    3329                 :          0 :         cmd.u.host_attr.debug_area_size = host_attr->debug_area_size;
    3330                 :            : 
    3331                 :          0 :         ret = ena_com_execute_admin_command(admin_queue,
    3332                 :            :                                             (struct ena_admin_aq_entry *)&cmd,
    3333                 :            :                                             sizeof(cmd),
    3334                 :            :                                             (struct ena_admin_acq_entry *)&resp,
    3335                 :            :                                             sizeof(resp));
    3336                 :            : 
    3337         [ #  # ]:          0 :         if (unlikely(ret))
    3338                 :          0 :                 ena_trc_err(ena_dev, "Failed to set host attributes: %d\n", ret);
    3339                 :            : 
    3340                 :            :         return ret;
    3341                 :            : }
    3342                 :            : 
    3343                 :            : /* Interrupt moderation */
    3344         [ #  # ]:          0 : bool ena_com_interrupt_moderation_supported(struct ena_com_dev *ena_dev)
    3345                 :            : {
    3346                 :          0 :         return ena_com_check_supported_feature_id(ena_dev,
    3347                 :            :                                                   ENA_ADMIN_INTERRUPT_MODERATION);
    3348                 :            : }
    3349                 :            : 
    3350                 :            : static int ena_com_update_nonadaptive_moderation_interval(struct ena_com_dev *ena_dev,
    3351                 :            :                                                           u32 coalesce_usecs,
    3352                 :            :                                                           u32 intr_delay_resolution,
    3353                 :            :                                                           u32 *intr_moder_interval)
    3354                 :            : {
    3355                 :          0 :         if (!intr_delay_resolution) {
    3356                 :          0 :                 ena_trc_err(ena_dev, "Illegal interrupt delay granularity value\n");
    3357                 :          0 :                 return ENA_COM_FAULT;
    3358                 :            :         }
    3359                 :            : 
    3360                 :          0 :         *intr_moder_interval = coalesce_usecs / intr_delay_resolution;
    3361                 :            : 
    3362                 :          0 :         return 0;
    3363                 :            : }
    3364                 :            : 
    3365                 :          0 : int ena_com_update_nonadaptive_moderation_interval_tx(struct ena_com_dev *ena_dev,
    3366                 :            :                                                       u32 tx_coalesce_usecs)
    3367                 :            : {
    3368                 :          0 :         return ena_com_update_nonadaptive_moderation_interval(ena_dev,
    3369                 :            :                                                               tx_coalesce_usecs,
    3370         [ #  # ]:          0 :                                                               ena_dev->intr_delay_resolution,
    3371                 :            :                                                               &ena_dev->intr_moder_tx_interval);
    3372                 :            : }
    3373                 :            : 
    3374                 :          0 : int ena_com_update_nonadaptive_moderation_interval_rx(struct ena_com_dev *ena_dev,
    3375                 :            :                                                       u32 rx_coalesce_usecs)
    3376                 :            : {
    3377                 :          0 :         return ena_com_update_nonadaptive_moderation_interval(ena_dev,
    3378                 :            :                                                               rx_coalesce_usecs,
    3379         [ #  # ]:          0 :                                                               ena_dev->intr_delay_resolution,
    3380                 :            :                                                               &ena_dev->intr_moder_rx_interval);
    3381                 :            : }
    3382                 :            : 
    3383                 :          0 : int ena_com_init_interrupt_moderation(struct ena_com_dev *ena_dev)
    3384                 :            : {
    3385                 :            :         struct ena_admin_get_feat_resp get_resp;
    3386                 :            :         u16 delay_resolution;
    3387                 :            :         int rc;
    3388                 :            : 
    3389                 :            :         rc = ena_com_get_feature(ena_dev, &get_resp,
    3390                 :            :                                  ENA_ADMIN_INTERRUPT_MODERATION, 0);
    3391                 :            : 
    3392         [ #  # ]:          0 :         if (rc) {
    3393         [ #  # ]:          0 :                 if (rc == ENA_COM_UNSUPPORTED) {
    3394                 :          0 :                         ena_trc_dbg(ena_dev, "Feature %d isn't supported\n",
    3395                 :            :                                     ENA_ADMIN_INTERRUPT_MODERATION);
    3396                 :            :                         rc = 0;
    3397                 :            :                 } else {
    3398                 :          0 :                         ena_trc_err(ena_dev,
    3399                 :            :                                     "Failed to get interrupt moderation admin cmd. rc: %d\n", rc);
    3400                 :            :                 }
    3401                 :            : 
    3402                 :            :                 /* no moderation supported, disable adaptive support */
    3403                 :            :                 ena_com_disable_adaptive_moderation(ena_dev);
    3404                 :          0 :                 return rc;
    3405                 :            :         }
    3406                 :            : 
    3407                 :            :         /* if moderation is supported by device we set adaptive moderation */
    3408                 :          0 :         delay_resolution = get_resp.u.intr_moderation.intr_delay_resolution;
    3409                 :          0 :         ena_com_update_intr_delay_resolution(ena_dev, delay_resolution);
    3410                 :            : 
    3411                 :            :         /* Disable adaptive moderation by default - can be enabled later */
    3412                 :            :         ena_com_disable_adaptive_moderation(ena_dev);
    3413                 :            : 
    3414                 :          0 :         return 0;
    3415                 :            : }
    3416                 :            : 
    3417                 :          0 : unsigned int ena_com_get_nonadaptive_moderation_interval_tx(struct ena_com_dev *ena_dev)
    3418                 :            : {
    3419                 :          0 :         return ena_dev->intr_moder_tx_interval;
    3420                 :            : }
    3421                 :            : 
    3422                 :          0 : unsigned int ena_com_get_nonadaptive_moderation_interval_rx(struct ena_com_dev *ena_dev)
    3423                 :            : {
    3424                 :          0 :         return ena_dev->intr_moder_rx_interval;
    3425                 :            : }
    3426                 :            : 
    3427                 :          0 : int ena_com_config_dev_mode(struct ena_com_dev *ena_dev,
    3428                 :            :                             struct ena_admin_feature_llq_desc *llq_features,
    3429                 :            :                             struct ena_llq_configurations *llq_default_cfg)
    3430                 :            : {
    3431                 :            :         struct ena_com_llq_info *llq_info = &ena_dev->llq_info;
    3432                 :            :         int rc;
    3433                 :            : 
    3434         [ #  # ]:          0 :         if (!llq_features->max_llq_num) {
    3435                 :          0 :                 ena_dev->tx_mem_queue_type = ENA_ADMIN_PLACEMENT_POLICY_HOST;
    3436                 :          0 :                 return 0;
    3437                 :            :         }
    3438                 :            : 
    3439                 :          0 :         rc = ena_com_config_llq_info(ena_dev, llq_features, llq_default_cfg);
    3440         [ #  # ]:          0 :         if (unlikely(rc))
    3441                 :            :                 return rc;
    3442                 :            : 
    3443                 :          0 :         ena_dev->tx_max_header_size = llq_info->desc_list_entry_size -
    3444                 :          0 :                 (llq_info->descs_num_before_header * sizeof(struct ena_eth_io_tx_desc));
    3445                 :            : 
    3446         [ #  # ]:          0 :         if (unlikely(ena_dev->tx_max_header_size == 0)) {
    3447                 :          0 :                 ena_trc_err(ena_dev, "The size of the LLQ entry is smaller than needed\n");
    3448                 :          0 :                 return ENA_COM_INVAL;
    3449                 :            :         }
    3450                 :            : 
    3451                 :          0 :         ena_dev->tx_mem_queue_type = ENA_ADMIN_PLACEMENT_POLICY_DEV;
    3452                 :            : 
    3453                 :          0 :         return 0;
    3454                 :            : }

Generated by: LCOV version 1.14