ena_com.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
/*
 * Copyright 2015-2020 Amazon.com, Inc. or its affiliates. All rights reserved.
 */

#include "ena_com.h"

/*****************************************************************************/
/*****************************************************************************/

/* Timeout in micro-sec */
#define ADMIN_CMD_TIMEOUT_US …

#define ENA_ASYNC_QUEUE_DEPTH …
#define ENA_ADMIN_QUEUE_DEPTH …


#define ENA_CTRL_MAJOR …
#define ENA_CTRL_MINOR …
#define ENA_CTRL_SUB_MINOR …

#define MIN_ENA_CTRL_VER …

#define ENA_DMA_ADDR_TO_UINT32_LOW(x) …
#define ENA_DMA_ADDR_TO_UINT32_HIGH(x) …

#define ENA_MMIO_READ_TIMEOUT …

#define ENA_COM_BOUNCE_BUFFER_CNTRL_CNT …

#define ENA_REGS_ADMIN_INTR_MASK …

#define ENA_MAX_BACKOFF_DELAY_EXP …

#define ENA_MIN_ADMIN_POLL_US …

#define ENA_MAX_ADMIN_POLL_US …

/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/

enum ena_cmd_status { … };

struct ena_comp_ctx { … };

struct ena_com_stats_ctx { … };

static int ena_com_mem_addr_set(struct ena_com_dev *ena_dev,
				       struct ena_common_mem_addr *ena_addr,
				       dma_addr_t addr)
{ … }

static int ena_com_admin_init_sq(struct ena_com_admin_queue *admin_queue)
{ … }

static int ena_com_admin_init_cq(struct ena_com_admin_queue *admin_queue)
{ … }

static int ena_com_admin_init_aenq(struct ena_com_dev *ena_dev,
				   struct ena_aenq_handlers *aenq_handlers)
{ … }

static void comp_ctxt_release(struct ena_com_admin_queue *queue,
				     struct ena_comp_ctx *comp_ctx)
{ … }

static struct ena_comp_ctx *get_comp_ctxt(struct ena_com_admin_queue *admin_queue,
					  u16 command_id, bool capture)
{ … }

static struct ena_comp_ctx *__ena_com_submit_admin_cmd(struct ena_com_admin_queue *admin_queue,
						       struct ena_admin_aq_entry *cmd,
						       size_t cmd_size_in_bytes,
						       struct ena_admin_acq_entry *comp,
						       size_t comp_size_in_bytes)
{ … }

static int ena_com_init_comp_ctxt(struct ena_com_admin_queue *admin_queue)
{ … }

static struct ena_comp_ctx *ena_com_submit_admin_cmd(struct ena_com_admin_queue *admin_queue,
						     struct ena_admin_aq_entry *cmd,
						     size_t cmd_size_in_bytes,
						     struct ena_admin_acq_entry *comp,
						     size_t comp_size_in_bytes)
{ … }

static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
			      struct ena_com_create_io_ctx *ctx,
			      struct ena_com_io_sq *io_sq)
{ … }

static int ena_com_init_io_cq(struct ena_com_dev *ena_dev,
			      struct ena_com_create_io_ctx *ctx,
			      struct ena_com_io_cq *io_cq)
{ … }

static void ena_com_handle_single_admin_completion(struct ena_com_admin_queue *admin_queue,
						   struct ena_admin_acq_entry *cqe)
{ … }

static void ena_com_handle_admin_completion(struct ena_com_admin_queue *admin_queue)
{ … }

static int ena_com_comp_status_to_errno(struct ena_com_admin_queue *admin_queue,
					u8 comp_status)
{ … }

static void ena_delay_exponential_backoff_us(u32 exp, u32 delay_us)
{ … }

static int ena_com_wait_and_process_admin_cq_polling(struct ena_comp_ctx *comp_ctx,
						     struct ena_com_admin_queue *admin_queue)
{ … }

/*
 * Set the LLQ configurations of the firmware
 *
 * The driver provides only the enabled feature values to the device,
 * which in turn, checks if they are supported.
 */
static int ena_com_set_llq(struct ena_com_dev *ena_dev)
{ … }

static int ena_com_config_llq_info(struct ena_com_dev *ena_dev,
				   struct ena_admin_feature_llq_desc *llq_features,
				   struct ena_llq_configurations *llq_default_cfg)
{ … }

static int ena_com_wait_and_process_admin_cq_interrupts(struct ena_comp_ctx *comp_ctx,
							struct ena_com_admin_queue *admin_queue)
{ … }

/* This method read the hardware device register through posting writes
 * and waiting for response
 * On timeout the function will return ENA_MMIO_READ_TIMEOUT
 */
static u32 ena_com_reg_bar_read32(struct ena_com_dev *ena_dev, u16 offset)
{ … }

/* There are two types to wait for completion.
 * Polling mode - wait until the completion is available.
 * Async mode - wait on wait queue until the completion is ready
 * (or the timeout expired).
 * It is expected that the IRQ called ena_com_handle_admin_completion
 * to mark the completions.
 */
static int ena_com_wait_and_process_admin_cq(struct ena_comp_ctx *comp_ctx,
					     struct ena_com_admin_queue *admin_queue)
{ … }

static int ena_com_destroy_io_sq(struct ena_com_dev *ena_dev,
				 struct ena_com_io_sq *io_sq)
{ … }

static void ena_com_io_queue_free(struct ena_com_dev *ena_dev,
				  struct ena_com_io_sq *io_sq,
				  struct ena_com_io_cq *io_cq)
{ … }

static int wait_for_reset_state(struct ena_com_dev *ena_dev, u32 timeout,
				u16 exp_state)
{ … }

static bool ena_com_check_supported_feature_id(struct ena_com_dev *ena_dev,
					       enum ena_admin_aq_feature_id feature_id)
{ … }

static int ena_com_get_feature_ex(struct ena_com_dev *ena_dev,
				  struct ena_admin_get_feat_resp *get_resp,
				  enum ena_admin_aq_feature_id feature_id,
				  dma_addr_t control_buf_dma_addr,
				  u32 control_buff_size,
				  u8 feature_ver)
{ … }

static int ena_com_get_feature(struct ena_com_dev *ena_dev,
			       struct ena_admin_get_feat_resp *get_resp,
			       enum ena_admin_aq_feature_id feature_id,
			       u8 feature_ver)
{ … }

int ena_com_get_current_hash_function(struct ena_com_dev *ena_dev)
{ … }

static void ena_com_hash_key_fill_default_key(struct ena_com_dev *ena_dev)
{ … }

static int ena_com_hash_key_allocate(struct ena_com_dev *ena_dev)
{ … }

static void ena_com_hash_key_destroy(struct ena_com_dev *ena_dev)
{ … }

static int ena_com_hash_ctrl_init(struct ena_com_dev *ena_dev)
{ … }

static void ena_com_hash_ctrl_destroy(struct ena_com_dev *ena_dev)
{ … }

static int ena_com_indirect_table_allocate(struct ena_com_dev *ena_dev,
					   u16 log_size)
{ … }

static void ena_com_indirect_table_destroy(struct ena_com_dev *ena_dev)
{ … }

static int ena_com_create_io_sq(struct ena_com_dev *ena_dev,
				struct ena_com_io_sq *io_sq, u16 cq_idx)
{ … }

static int ena_com_ind_tbl_convert_to_device(struct ena_com_dev *ena_dev)
{ … }

static void ena_com_update_intr_delay_resolution(struct ena_com_dev *ena_dev,
						 u16 intr_delay_resolution)
{ … }

/*****************************************************************************/
/*******************************      API       ******************************/
/*****************************************************************************/

int ena_com_execute_admin_command(struct ena_com_admin_queue *admin_queue,
				  struct ena_admin_aq_entry *cmd,
				  size_t cmd_size,
				  struct ena_admin_acq_entry *comp,
				  size_t comp_size)
{ … }

int ena_com_create_io_cq(struct ena_com_dev *ena_dev,
			 struct ena_com_io_cq *io_cq)
{ … }

int ena_com_get_io_handlers(struct ena_com_dev *ena_dev, u16 qid,
			    struct ena_com_io_sq **io_sq,
			    struct ena_com_io_cq **io_cq)
{ … }

void ena_com_abort_admin_commands(struct ena_com_dev *ena_dev)
{ … }

void ena_com_wait_for_abort_completion(struct ena_com_dev *ena_dev)
{ … }

int ena_com_destroy_io_cq(struct ena_com_dev *ena_dev,
			  struct ena_com_io_cq *io_cq)
{ … }

bool ena_com_get_admin_running_state(struct ena_com_dev *ena_dev)
{ … }

void ena_com_set_admin_running_state(struct ena_com_dev *ena_dev, bool state)
{ … }

void ena_com_admin_aenq_enable(struct ena_com_dev *ena_dev)
{ … }

int ena_com_set_aenq_config(struct ena_com_dev *ena_dev, u32 groups_flag)
{ … }

int ena_com_get_dma_width(struct ena_com_dev *ena_dev)
{ … }

int ena_com_validate_version(struct ena_com_dev *ena_dev)
{ … }

static void
ena_com_free_ena_admin_queue_comp_ctx(struct ena_com_dev *ena_dev,
				      struct ena_com_admin_queue *admin_queue)

{ … }

void ena_com_admin_destroy(struct ena_com_dev *ena_dev)
{ … }

void ena_com_set_admin_polling_mode(struct ena_com_dev *ena_dev, bool polling)
{ … }

void ena_com_set_admin_auto_polling_mode(struct ena_com_dev *ena_dev,
					 bool polling)
{ … }

int ena_com_mmio_reg_read_request_init(struct ena_com_dev *ena_dev)
{ … }

void ena_com_set_mmio_read_mode(struct ena_com_dev *ena_dev, bool readless_supported)
{ … }

void ena_com_mmio_reg_read_request_destroy(struct ena_com_dev *ena_dev)
{ … }

void ena_com_mmio_reg_read_request_write_dev_addr(struct ena_com_dev *ena_dev)
{ … }

int ena_com_admin_init(struct ena_com_dev *ena_dev,
		       struct ena_aenq_handlers *aenq_handlers)
{ … }

int ena_com_create_io_queue(struct ena_com_dev *ena_dev,
			    struct ena_com_create_io_ctx *ctx)
{ … }

void ena_com_destroy_io_queue(struct ena_com_dev *ena_dev, u16 qid)
{ … }

int ena_com_get_link_params(struct ena_com_dev *ena_dev,
			    struct ena_admin_get_feat_resp *resp)
{ … }

int ena_com_get_dev_attr_feat(struct ena_com_dev *ena_dev,
			      struct ena_com_dev_get_features_ctx *get_feat_ctx)
{ … }

void ena_com_admin_q_comp_intr_handler(struct ena_com_dev *ena_dev)
{ … }

/* ena_handle_specific_aenq_event:
 * return the handler that is relevant to the specific event group
 */
static ena_aenq_handler ena_com_get_specific_aenq_cb(struct ena_com_dev *ena_dev,
						     u16 group)
{ … }

/* ena_aenq_intr_handler:
 * handles the aenq incoming events.
 * pop events from the queue and apply the specific handler
 */
void ena_com_aenq_intr_handler(struct ena_com_dev *ena_dev, void *data)
{ … }

int ena_com_dev_reset(struct ena_com_dev *ena_dev,
		      enum ena_regs_reset_reason_types reset_reason)
{ … }

static int ena_get_dev_stats(struct ena_com_dev *ena_dev,
			     struct ena_com_stats_ctx *ctx,
			     enum ena_admin_get_stats_type type)
{ … }

int ena_com_get_eni_stats(struct ena_com_dev *ena_dev,
			  struct ena_admin_eni_stats *stats)
{ … }

int ena_com_get_dev_basic_stats(struct ena_com_dev *ena_dev,
				struct ena_admin_basic_stats *stats)
{ … }

int ena_com_set_dev_mtu(struct ena_com_dev *ena_dev, u32 mtu)
{ … }

int ena_com_get_offload_settings(struct ena_com_dev *ena_dev,
				 struct ena_admin_feature_offload_desc *offload)
{ … }

int ena_com_set_hash_function(struct ena_com_dev *ena_dev)
{ … }

int ena_com_fill_hash_function(struct ena_com_dev *ena_dev,
			       enum ena_admin_hash_functions func,
			       const u8 *key, u16 key_len, u32 init_val)
{ … }

int ena_com_get_hash_function(struct ena_com_dev *ena_dev,
			      enum ena_admin_hash_functions *func)
{ … }

int ena_com_get_hash_key(struct ena_com_dev *ena_dev, u8 *key)
{ … }

int ena_com_get_hash_ctrl(struct ena_com_dev *ena_dev,
			  enum ena_admin_flow_hash_proto proto,
			  u16 *fields)
{ … }

int ena_com_set_hash_ctrl(struct ena_com_dev *ena_dev)
{ … }

int ena_com_set_default_hash_ctrl(struct ena_com_dev *ena_dev)
{ … }

int ena_com_fill_hash_ctrl(struct ena_com_dev *ena_dev,
			   enum ena_admin_flow_hash_proto proto,
			   u16 hash_fields)
{ … }

int ena_com_indirect_table_fill_entry(struct ena_com_dev *ena_dev,
				      u16 entry_idx, u16 entry_value)
{ … }

int ena_com_indirect_table_set(struct ena_com_dev *ena_dev)
{ … }

int ena_com_indirect_table_get(struct ena_com_dev *ena_dev, u32 *ind_tbl)
{ … }

int ena_com_rss_init(struct ena_com_dev *ena_dev, u16 indr_tbl_log_size)
{ … }

void ena_com_rss_destroy(struct ena_com_dev *ena_dev)
{ … }

int ena_com_allocate_host_info(struct ena_com_dev *ena_dev)
{ … }

int ena_com_allocate_debug_area(struct ena_com_dev *ena_dev,
				u32 debug_area_size)
{ … }

void ena_com_delete_host_info(struct ena_com_dev *ena_dev)
{ … }

void ena_com_delete_debug_area(struct ena_com_dev *ena_dev)
{ … }

int ena_com_set_host_attributes(struct ena_com_dev *ena_dev)
{ … }

/* Interrupt moderation */
bool ena_com_interrupt_moderation_supported(struct ena_com_dev *ena_dev)
{ … }

static int ena_com_update_nonadaptive_moderation_interval(struct ena_com_dev *ena_dev,
							  u32 coalesce_usecs,
							  u32 intr_delay_resolution,
							  u32 *intr_moder_interval)
{ … }

int ena_com_update_nonadaptive_moderation_interval_tx(struct ena_com_dev *ena_dev,
						      u32 tx_coalesce_usecs)
{ … }

int ena_com_update_nonadaptive_moderation_interval_rx(struct ena_com_dev *ena_dev,
						      u32 rx_coalesce_usecs)
{ … }

int ena_com_init_interrupt_moderation(struct ena_com_dev *ena_dev)
{ … }

unsigned int ena_com_get_nonadaptive_moderation_interval_tx(struct ena_com_dev *ena_dev)
{ … }

unsigned int ena_com_get_nonadaptive_moderation_interval_rx(struct ena_com_dev *ena_dev)
{ … }

int ena_com_config_dev_mode(struct ena_com_dev *ena_dev,
			    struct ena_admin_feature_llq_desc *llq_features,
			    struct ena_llq_configurations *llq_default_cfg)
{ … }
linux/drivers/net/ethernet/amazon/ena/ena_com.c
