[mirror_ubuntu-eoan-kernel.git] / drivers / infiniband / hw / i40iw / i40iw.h

/*******************************************************************************
*
* Copyright (c) 2015-2016 Intel Corporation.  All rights reserved.
*
* This software is available to you under a choice of one of two
* licenses.  You may choose to be licensed under the terms of the GNU
* General Public License (GPL) Version 2, available from the file
* COPYING in the main directory of this source tree, or the
* OpenFabrics.org BSD license below:
*
*   Redistribution and use in source and binary forms, with or
*   without modification, are permitted provided that the following
*   conditions are met:
*
*    - Redistributions of source code must retain the above
*	copyright notice, this list of conditions and the following
*	disclaimer.
*
*    - Redistributions in binary form must reproduce the above
*	copyright notice, this list of conditions and the following
*	disclaimer in the documentation and/or other materials
*	provided with the distribution.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/

#ifndef I40IW_IW_H
#define I40IW_IW_H
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
#include <linux/spinlock.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/dma-mapping.h>
#include <linux/workqueue.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/crc32c.h>
#include <rdma/ib_smi.h>
#include <rdma/ib_verbs.h>
#include <rdma/ib_pack.h>
#include <rdma/rdma_cm.h>
#include <rdma/iw_cm.h>
#include <crypto/hash.h>

#include "i40iw_status.h"
#include "i40iw_osdep.h"
#include "i40iw_d.h"
#include "i40iw_hmc.h"

#include <i40e_client.h>
#include "i40iw_type.h"
#include "i40iw_p.h"
#include "i40iw_ucontext.h"
#include "i40iw_pble.h"
#include "i40iw_verbs.h"
#include "i40iw_cm.h"
#include "i40iw_user.h"
#include "i40iw_puda.h"

#define I40IW_FW_VERSION  2
#define I40IW_HW_VERSION  2

#define I40IW_ARP_ADD     1
#define I40IW_ARP_DELETE  2
#define I40IW_ARP_RESOLVE 3

#define I40IW_MACIP_ADD     1
#define I40IW_MACIP_DELETE  2

#define IW_CCQ_SIZE         (I40IW_CQP_SW_SQSIZE_2048 + 1)
#define IW_CEQ_SIZE         2048
#define IW_AEQ_SIZE         2048

#define RX_BUF_SIZE            (1536 + 8)
#define IW_REG0_SIZE           (4 * 1024)
#define IW_TX_TIMEOUT          (6 * HZ)
#define IW_FIRST_QPN           1
#define IW_SW_CONTEXT_ALIGN    1024

#define MAX_DPC_ITERATIONS		128

#define I40IW_EVENT_TIMEOUT		100000
#define I40IW_VCHNL_EVENT_TIMEOUT	100000

#define	I40IW_NO_VLAN			0xffff
#define	I40IW_NO_QSET			0xffff

/* access to mcast filter list */
#define IW_ADD_MCAST false
#define IW_DEL_MCAST true

#define I40IW_DRV_OPT_ENABLE_MPA_VER_0     0x00000001
#define I40IW_DRV_OPT_DISABLE_MPA_CRC      0x00000002
#define I40IW_DRV_OPT_DISABLE_FIRST_WRITE  0x00000004
#define I40IW_DRV_OPT_DISABLE_INTF         0x00000008
#define I40IW_DRV_OPT_ENABLE_MSI           0x00000010
#define I40IW_DRV_OPT_DUAL_LOGICAL_PORT    0x00000020
#define I40IW_DRV_OPT_NO_INLINE_DATA       0x00000080
#define I40IW_DRV_OPT_DISABLE_INT_MOD      0x00000100
#define I40IW_DRV_OPT_DISABLE_VIRT_WQ      0x00000200
#define I40IW_DRV_OPT_ENABLE_PAU           0x00000400
#define I40IW_DRV_OPT_MCAST_LOGPORT_MAP    0x00000800

#define IW_HMC_OBJ_TYPE_NUM ARRAY_SIZE(iw_hmc_obj_types)
#define IW_CFG_FPM_QP_COUNT               32768
#define I40IW_MAX_PAGES_PER_FMR           512
#define I40IW_MIN_PAGES_PER_FMR           1
#define I40IW_CQP_COMPL_RQ_WQE_FLUSHED    2
#define I40IW_CQP_COMPL_SQ_WQE_FLUSHED    3
#define I40IW_CQP_COMPL_RQ_SQ_WQE_FLUSHED 4

#define I40IW_MTU_TO_MSS		40
#define I40IW_DEFAULT_MSS		1460

struct i40iw_cqp_compl_info {
	u32 op_ret_val;
	u16 maj_err_code;
	u16 min_err_code;
	bool error;
	u8 op_code;
};

#define i40iw_pr_err(fmt, args ...) pr_err("%s: "fmt, __func__, ## args)

#define i40iw_pr_info(fmt, args ...) pr_info("%s: " fmt, __func__, ## args)

#define i40iw_pr_warn(fmt, args ...) pr_warn("%s: " fmt, __func__, ## args)

struct i40iw_cqp_request {
	struct cqp_commands_info info;
	wait_queue_head_t waitq;
	struct list_head list;
	atomic_t refcount;
	void (*callback_fcn)(struct i40iw_cqp_request*, u32);
	void *param;
	struct i40iw_cqp_compl_info compl_info;
	bool waiting;
	bool request_done;
	bool dynamic;
};

struct i40iw_cqp {
	struct i40iw_sc_cqp sc_cqp;
	spinlock_t req_lock; /*cqp request list */
	wait_queue_head_t waitq;
	struct i40iw_dma_mem sq;
	struct i40iw_dma_mem host_ctx;
	u64 *scratch_array;
	struct i40iw_cqp_request *cqp_requests;
	struct list_head cqp_avail_reqs;
	struct list_head cqp_pending_reqs;
};

struct i40iw_device;

struct i40iw_ccq {
	struct i40iw_sc_cq sc_cq;
	spinlock_t lock; /* ccq control */
	wait_queue_head_t waitq;
	struct i40iw_dma_mem mem_cq;
	struct i40iw_dma_mem shadow_area;
};

struct i40iw_ceq {
	struct i40iw_sc_ceq sc_ceq;
	struct i40iw_dma_mem mem;
	u32 irq;
	u32 msix_idx;
	struct i40iw_device *iwdev;
	struct tasklet_struct dpc_tasklet;
};

struct i40iw_aeq {
	struct i40iw_sc_aeq sc_aeq;
	struct i40iw_dma_mem mem;
};

struct i40iw_arp_entry {
	u32 ip_addr[4];
	u8 mac_addr[ETH_ALEN];
};

enum init_completion_state {
	INVALID_STATE = 0,
	INITIAL_STATE,
	CQP_CREATED,
	HMC_OBJS_CREATED,
	PBLE_CHUNK_MEM,
	CCQ_CREATED,
	AEQ_CREATED,
	CEQ_CREATED,
	ILQ_CREATED,
	IEQ_CREATED,
	INET_NOTIFIER,
	IP_ADDR_REGISTERED,
	RDMA_DEV_REGISTERED
};

struct i40iw_msix_vector {
	u32 idx;
	u32 irq;
	u32 cpu_affinity;
	u32 ceq_id;
};

struct l2params_work {
	struct work_struct work;
	struct i40iw_device *iwdev;
	struct i40iw_l2params l2params;
};

#define I40IW_MSIX_TABLE_SIZE   65

struct virtchnl_work {
	struct work_struct work;
	union {
		struct i40iw_cqp_request *cqp_request;
		struct i40iw_virtchnl_work_info work_info;
	};
};

struct i40e_qvlist_info;

struct i40iw_device {
	struct i40iw_ib_device *iwibdev;
	struct net_device *netdev;
	wait_queue_head_t vchnl_waitq;
	struct i40iw_sc_dev sc_dev;
	struct i40iw_sc_vsi vsi;
	struct i40iw_handler *hdl;
	struct i40e_info *ldev;
	struct i40e_client *client;
	struct i40iw_hw hw;
	struct i40iw_cm_core cm_core;
	u8 *mem_resources;
	unsigned long *allocated_qps;
	unsigned long *allocated_cqs;
	unsigned long *allocated_mrs;
	unsigned long *allocated_pds;
	unsigned long *allocated_arps;
	struct i40iw_qp **qp_table;
	bool msix_shared;
	u32 msix_count;
	struct i40iw_msix_vector *iw_msixtbl;
	struct i40e_qvlist_info *iw_qvlist;

	struct i40iw_hmc_pble_rsrc *pble_rsrc;
	struct i40iw_arp_entry *arp_table;
	struct i40iw_cqp cqp;
	struct i40iw_ccq ccq;
	u32 ceqs_count;
	struct i40iw_ceq *ceqlist;
	struct i40iw_aeq aeq;
	u32 arp_table_size;
	u32 next_arp_index;
	spinlock_t resource_lock; /* hw resource access */
	spinlock_t qptable_lock;
	u32 vendor_id;
	u32 vendor_part_id;
	u32 of_device_registered;

	u32 device_cap_flags;
	unsigned long db_start;
	u8 resource_profile;
	u8 max_rdma_vfs;
	u8 max_enabled_vfs;
	u8 max_sge;
	u8 iw_status;
	u8 send_term_ok;
	bool push_mode;		/* Initialized from parameter passed to driver */

	/* x710 specific */
	struct mutex pbl_mutex;
	struct tasklet_struct dpc_tasklet;
	struct workqueue_struct *virtchnl_wq;
	struct virtchnl_work virtchnl_w[I40IW_MAX_PE_ENABLED_VF_COUNT];
	struct i40iw_dma_mem obj_mem;
	struct i40iw_dma_mem obj_next;
	u8 *hmc_info_mem;
	u32 sd_type;
	struct workqueue_struct *param_wq;
	atomic_t params_busy;
	enum init_completion_state init_state;
	u16 mac_ip_table_idx;
	atomic_t vchnl_msgs;
	u32 max_mr;
	u32 max_qp;
	u32 max_cq;
	u32 max_pd;
	u32 next_qp;
	u32 next_cq;
	u32 next_pd;
	u32 max_mr_size;
	u32 max_qp_wr;
	u32 max_cqe;
	u32 mr_stagmask;
	u32 mpa_version;
	bool dcb;
	bool closing;
	bool reset;
	u32 used_pds;
	u32 used_cqs;
	u32 used_mrs;
	u32 used_qps;
	wait_queue_head_t close_wq;
	atomic64_t use_count;
};

struct i40iw_ib_device {
	struct ib_device ibdev;
	struct i40iw_device *iwdev;
};

struct i40iw_handler {
	struct list_head list;
	struct i40e_client *client;
	struct i40iw_device device;
	struct i40e_info ldev;
};

/**
 * to_iwdev - get device
 * @ibdev: ib device
 **/
static inline struct i40iw_device *to_iwdev(struct ib_device *ibdev)
{
	return container_of(ibdev, struct i40iw_ib_device, ibdev)->iwdev;
}

/**
 * to_ucontext - get user context
 * @ibucontext: ib user context
 **/
static inline struct i40iw_ucontext *to_ucontext(struct ib_ucontext *ibucontext)
{
	return container_of(ibucontext, struct i40iw_ucontext, ibucontext);
}

/**
 * to_iwpd - get protection domain
 * @ibpd: ib pd
 **/
static inline struct i40iw_pd *to_iwpd(struct ib_pd *ibpd)
{
	return container_of(ibpd, struct i40iw_pd, ibpd);
}

/**
 * to_iwmr - get device memory region
 * @ibdev: ib memory region
 **/
static inline struct i40iw_mr *to_iwmr(struct ib_mr *ibmr)
{
	return container_of(ibmr, struct i40iw_mr, ibmr);
}

/**
 * to_iwmr_from_ibfmr - get device memory region
 * @ibfmr: ib fmr
 **/
static inline struct i40iw_mr *to_iwmr_from_ibfmr(struct ib_fmr *ibfmr)
{
	return container_of(ibfmr, struct i40iw_mr, ibfmr);
}

/**
 * to_iwmw - get device memory window
 * @ibmw: ib memory window
 **/
static inline struct i40iw_mr *to_iwmw(struct ib_mw *ibmw)
{
	return container_of(ibmw, struct i40iw_mr, ibmw);
}

/**
 * to_iwcq - get completion queue
 * @ibcq: ib cqdevice
 **/
static inline struct i40iw_cq *to_iwcq(struct ib_cq *ibcq)
{
	return container_of(ibcq, struct i40iw_cq, ibcq);
}

/**
 * to_iwqp - get device qp
 * @ibqp: ib qp
 **/
static inline struct i40iw_qp *to_iwqp(struct ib_qp *ibqp)
{
	return container_of(ibqp, struct i40iw_qp, ibqp);
}

/* i40iw.c */
void i40iw_add_ref(struct ib_qp *);
void i40iw_rem_ref(struct ib_qp *);
struct ib_qp *i40iw_get_qp(struct ib_device *, int);

void i40iw_flush_wqes(struct i40iw_device *iwdev,
		      struct i40iw_qp *qp);

void i40iw_manage_arp_cache(struct i40iw_device *iwdev,
			    unsigned char *mac_addr,
			    u32 *ip_addr,
			    bool ipv4,
			    u32 action);

int i40iw_manage_apbvt(struct i40iw_device *iwdev,
		       u16 accel_local_port,
		       bool add_port);

struct i40iw_cqp_request *i40iw_get_cqp_request(struct i40iw_cqp *cqp, bool wait);
void i40iw_free_cqp_request(struct i40iw_cqp *cqp, struct i40iw_cqp_request *cqp_request);
void i40iw_put_cqp_request(struct i40iw_cqp *cqp, struct i40iw_cqp_request *cqp_request);

/**
 * i40iw_alloc_resource - allocate a resource
 * @iwdev: device pointer
 * @resource_array: resource bit array:
 * @max_resources: maximum resource number
 * @req_resources_num: Allocated resource number
 * @next: next free id
 **/
static inline int i40iw_alloc_resource(struct i40iw_device *iwdev,
				       unsigned long *resource_array,
				       u32 max_resources,
				       u32 *req_resource_num,
				       u32 *next)
{
	u32 resource_num;
	unsigned long flags;

	spin_lock_irqsave(&iwdev->resource_lock, flags);
	resource_num = find_next_zero_bit(resource_array, max_resources, *next);
	if (resource_num >= max_resources) {
		resource_num = find_first_zero_bit(resource_array, max_resources);
		if (resource_num >= max_resources) {
			spin_unlock_irqrestore(&iwdev->resource_lock, flags);
			return -EOVERFLOW;
		}
	}
	set_bit(resource_num, resource_array);
	*next = resource_num + 1;
	if (*next == max_resources)
		*next = 0;
	*req_resource_num = resource_num;
	spin_unlock_irqrestore(&iwdev->resource_lock, flags);

	return 0;
}

/**
 * i40iw_is_resource_allocated - detrmine if resource is
 * allocated
 * @iwdev: device pointer
 * @resource_array: resource array for the resource_num
 * @resource_num: resource number to check
 **/
static inline bool i40iw_is_resource_allocated(struct i40iw_device *iwdev,
					       unsigned long *resource_array,
					       u32 resource_num)
{
	bool bit_is_set;
	unsigned long flags;

	spin_lock_irqsave(&iwdev->resource_lock, flags);

	bit_is_set = test_bit(resource_num, resource_array);
	spin_unlock_irqrestore(&iwdev->resource_lock, flags);

	return bit_is_set;
}

/**
 * i40iw_free_resource - free a resource
 * @iwdev: device pointer
 * @resource_array: resource array for the resource_num
 * @resource_num: resource number to free
 **/
static inline void i40iw_free_resource(struct i40iw_device *iwdev,
				       unsigned long *resource_array,
				       u32 resource_num)
{
	unsigned long flags;

	spin_lock_irqsave(&iwdev->resource_lock, flags);
	clear_bit(resource_num, resource_array);
	spin_unlock_irqrestore(&iwdev->resource_lock, flags);
}

/**
 * to_iwhdl - Get the handler from the device pointer
 * @iwdev: device pointer
 **/
static inline struct i40iw_handler *to_iwhdl(struct i40iw_device *iw_dev)
{
	return container_of(iw_dev, struct i40iw_handler, device);
}

struct i40iw_handler *i40iw_find_netdev(struct net_device *netdev);

/**
 * iw_init_resources -
 */
u32 i40iw_initialize_hw_resources(struct i40iw_device *iwdev);

int i40iw_register_rdma_device(struct i40iw_device *iwdev);
void i40iw_port_ibevent(struct i40iw_device *iwdev);
void i40iw_cm_disconn(struct i40iw_qp *iwqp);
void i40iw_cm_disconn_worker(void *);
int mini_cm_recv_pkt(struct i40iw_cm_core *, struct i40iw_device *,
		     struct sk_buff *);

enum i40iw_status_code i40iw_handle_cqp_op(struct i40iw_device *iwdev,
					   struct i40iw_cqp_request *cqp_request);
enum i40iw_status_code i40iw_add_mac_addr(struct i40iw_device *iwdev,
					  u8 *mac_addr, u8 *mac_index);
int i40iw_modify_qp(struct ib_qp *, struct ib_qp_attr *, int, struct ib_udata *);
void i40iw_cq_wq_destroy(struct i40iw_device *iwdev, struct i40iw_sc_cq *cq);

void i40iw_cleanup_pending_cqp_op(struct i40iw_device *iwdev);
void i40iw_rem_pdusecount(struct i40iw_pd *iwpd, struct i40iw_device *iwdev);
void i40iw_add_pdusecount(struct i40iw_pd *iwpd);
void i40iw_rem_devusecount(struct i40iw_device *iwdev);
void i40iw_add_devusecount(struct i40iw_device *iwdev);
void i40iw_hw_modify_qp(struct i40iw_device *iwdev, struct i40iw_qp *iwqp,
			struct i40iw_modify_qp_info *info, bool wait);

void i40iw_qp_suspend_resume(struct i40iw_sc_dev *dev,
			     struct i40iw_sc_qp *qp,
			     bool suspend);
enum i40iw_status_code i40iw_manage_qhash(struct i40iw_device *iwdev,
					  struct i40iw_cm_info *cminfo,
					  enum i40iw_quad_entry_type etype,
					  enum i40iw_quad_hash_manage_type mtype,
					  void *cmnode,
					  bool wait);
void i40iw_receive_ilq(struct i40iw_sc_vsi *vsi, struct i40iw_puda_buf *rbuf);
void i40iw_free_sqbuf(struct i40iw_sc_vsi *vsi, void *bufp);
void i40iw_free_qp_resources(struct i40iw_device *iwdev,
			     struct i40iw_qp *iwqp,
			     u32 qp_num);
enum i40iw_status_code i40iw_obj_aligned_mem(struct i40iw_device *iwdev,
					     struct i40iw_dma_mem *memptr,
					     u32 size, u32 mask);

void i40iw_request_reset(struct i40iw_device *iwdev);
void i40iw_destroy_rdma_device(struct i40iw_ib_device *iwibdev);
void i40iw_setup_cm_core(struct i40iw_device *iwdev);
void i40iw_cleanup_cm_core(struct i40iw_cm_core *cm_core);
void i40iw_process_ceq(struct i40iw_device *, struct i40iw_ceq *iwceq);
void i40iw_process_aeq(struct i40iw_device *);
void i40iw_next_iw_state(struct i40iw_qp *iwqp,
			 u8 state, u8 del_hash,
			 u8 term, u8 term_len);
int i40iw_send_syn(struct i40iw_cm_node *cm_node, u32 sendack);
struct i40iw_cm_node *i40iw_find_node(struct i40iw_cm_core *cm_core,
				      u16 rem_port,
				      u32 *rem_addr,
				      u16 loc_port,
				      u32 *loc_addr,
				      bool add_refcnt);

enum i40iw_status_code i40iw_hw_flush_wqes(struct i40iw_device *iwdev,
					   struct i40iw_sc_qp *qp,
					   struct i40iw_qp_flush_info *info,
					   bool wait);

void i40iw_copy_ip_ntohl(u32 *dst, __be32 *src);
struct ib_mr *i40iw_reg_phys_mr(struct ib_pd *ib_pd,
				u64 addr,
				u64 size,
				int acc,
				u64 *iova_start);

int i40iw_inetaddr_event(struct notifier_block *notifier,
			 unsigned long event,
			 void *ptr);
int i40iw_inet6addr_event(struct notifier_block *notifier,
			  unsigned long event,
			  void *ptr);
int i40iw_net_event(struct notifier_block *notifier,
		    unsigned long event,
		    void *ptr);

#endif
Commit	Line	Data
8e06af71 FL	1	/*******************************************************************************
	2	*
	3	* Copyright (c) 2015-2016 Intel Corporation. All rights reserved.
	4	*
	5	* This software is available to you under a choice of one of two
	6	* licenses. You may choose to be licensed under the terms of the GNU
	7	* General Public License (GPL) Version 2, available from the file
	8	* COPYING in the main directory of this source tree, or the
	9	* OpenFabrics.org BSD license below:
	10	*
	11	* Redistribution and use in source and binary forms, with or
	12	* without modification, are permitted provided that the following
	13	* conditions are met:
	14	*
	15	* - Redistributions of source code must retain the above
	16	* copyright notice, this list of conditions and the following
	17	* disclaimer.
	18	*
	19	* - Redistributions in binary form must reproduce the above
	20	* copyright notice, this list of conditions and the following
	21	* disclaimer in the documentation and/or other materials
	22	* provided with the distribution.
	23	*
	24	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	25	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	26	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	27	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	28	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	29	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	30	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	31	* SOFTWARE.
	32	*
	33	*******************************************************************************/
	34
	35	#ifndef I40IW_IW_H
	36	#define I40IW_IW_H
	37	#include <linux/netdevice.h>
	38	#include <linux/inetdevice.h>
	39	#include <linux/spinlock.h>
	40	#include <linux/kernel.h>
	41	#include <linux/delay.h>
	42	#include <linux/pci.h>
	43	#include <linux/dma-mapping.h>
	44	#include <linux/workqueue.h>
	45	#include <linux/slab.h>
	46	#include <linux/io.h>
	47	#include <linux/crc32c.h>
	48	#include <rdma/ib_smi.h>
	49	#include <rdma/ib_verbs.h>
	50	#include <rdma/ib_pack.h>
	51	#include <rdma/rdma_cm.h>
	52	#include <rdma/iw_cm.h>
34abf9ed	53	#include <crypto/hash.h>
8e06af71 FL	54
	55	#include "i40iw_status.h"
	56	#include "i40iw_osdep.h"
	57	#include "i40iw_d.h"
	58	#include "i40iw_hmc.h"
	59
	60	#include <i40e_client.h>
	61	#include "i40iw_type.h"
	62	#include "i40iw_p.h"
	63	#include "i40iw_ucontext.h"
	64	#include "i40iw_pble.h"
	65	#include "i40iw_verbs.h"
	66	#include "i40iw_cm.h"
	67	#include "i40iw_user.h"
	68	#include "i40iw_puda.h"
	69
	70	#define I40IW_FW_VERSION 2
	71	#define I40IW_HW_VERSION 2
	72
	73	#define I40IW_ARP_ADD 1
	74	#define I40IW_ARP_DELETE 2
	75	#define I40IW_ARP_RESOLVE 3
	76
	77	#define I40IW_MACIP_ADD 1
	78	#define I40IW_MACIP_DELETE 2
	79
	80	#define IW_CCQ_SIZE (I40IW_CQP_SW_SQSIZE_2048 + 1)
	81	#define IW_CEQ_SIZE 2048
	82	#define IW_AEQ_SIZE 2048
	83
	84	#define RX_BUF_SIZE (1536 + 8)
	85	#define IW_REG0_SIZE (4 * 1024)
	86	#define IW_TX_TIMEOUT (6 * HZ)
	87	#define IW_FIRST_QPN 1
	88	#define IW_SW_CONTEXT_ALIGN 1024
	89
	90	#define MAX_DPC_ITERATIONS 128
	91
	92	#define I40IW_EVENT_TIMEOUT 100000
	93	#define I40IW_VCHNL_EVENT_TIMEOUT 100000
	94
	95	#define I40IW_NO_VLAN 0xffff
	96	#define I40IW_NO_QSET 0xffff
	97
	98	/* access to mcast filter list */
	99	#define IW_ADD_MCAST false
	100	#define IW_DEL_MCAST true
	101
	102	#define I40IW_DRV_OPT_ENABLE_MPA_VER_0 0x00000001
	103	#define I40IW_DRV_OPT_DISABLE_MPA_CRC 0x00000002
	104	#define I40IW_DRV_OPT_DISABLE_FIRST_WRITE 0x00000004
	105	#define I40IW_DRV_OPT_DISABLE_INTF 0x00000008
	106	#define I40IW_DRV_OPT_ENABLE_MSI 0x00000010
	107	#define I40IW_DRV_OPT_DUAL_LOGICAL_PORT 0x00000020
	108	#define I40IW_DRV_OPT_NO_INLINE_DATA 0x00000080
	109	#define I40IW_DRV_OPT_DISABLE_INT_MOD 0x00000100
	110	#define I40IW_DRV_OPT_DISABLE_VIRT_WQ 0x00000200
	111	#define I40IW_DRV_OPT_ENABLE_PAU 0x00000400
	112	#define I40IW_DRV_OPT_MCAST_LOGPORT_MAP 0x00000800
	113
	114	#define IW_HMC_OBJ_TYPE_NUM ARRAY_SIZE(iw_hmc_obj_types)
1cda28bb SS	115	#define IW_CFG_FPM_QP_COUNT 32768
	116	#define I40IW_MAX_PAGES_PER_FMR 512
	117	#define I40IW_MIN_PAGES_PER_FMR 1
	118	#define I40IW_CQP_COMPL_RQ_WQE_FLUSHED 2
	119	#define I40IW_CQP_COMPL_SQ_WQE_FLUSHED 3
	120	#define I40IW_CQP_COMPL_RQ_SQ_WQE_FLUSHED 4
8e06af71 FL	121
	122	#define I40IW_MTU_TO_MSS 40
	123	#define I40IW_DEFAULT_MSS 1460
	124
	125	struct i40iw_cqp_compl_info {
	126	u32 op_ret_val;
	127	u16 maj_err_code;
	128	u16 min_err_code;
	129	bool error;
	130	u8 op_code;
	131	};
	132
	133	#define i40iw_pr_err(fmt, args ...) pr_err("%s: "fmt, __func__, ## args)
	134
	135	#define i40iw_pr_info(fmt, args ...) pr_info("%s: " fmt, __func__, ## args)
	136
	137	#define i40iw_pr_warn(fmt, args ...) pr_warn("%s: " fmt, __func__, ## args)
	138
	139	struct i40iw_cqp_request {
	140	struct cqp_commands_info info;
	141	wait_queue_head_t waitq;
	142	struct list_head list;
	143	atomic_t refcount;
	144	void (callback_fcn)(struct i40iw_cqp_request, u32);
	145	void *param;
	146	struct i40iw_cqp_compl_info compl_info;
	147	bool waiting;
	148	bool request_done;
	149	bool dynamic;
	150	};
	151
	152	struct i40iw_cqp {
	153	struct i40iw_sc_cqp sc_cqp;
	154	spinlock_t req_lock; /cqp request list /
	155	wait_queue_head_t waitq;
	156	struct i40iw_dma_mem sq;
	157	struct i40iw_dma_mem host_ctx;
	158	u64 *scratch_array;
	159	struct i40iw_cqp_request *cqp_requests;
	160	struct list_head cqp_avail_reqs;
	161	struct list_head cqp_pending_reqs;
	162	};
	163
	164	struct i40iw_device;
	165
	166	struct i40iw_ccq {
	167	struct i40iw_sc_cq sc_cq;
	168	spinlock_t lock; /* ccq control */
	169	wait_queue_head_t waitq;
	170	struct i40iw_dma_mem mem_cq;
	171	struct i40iw_dma_mem shadow_area;
	172	};
	173
	174	struct i40iw_ceq {
	175	struct i40iw_sc_ceq sc_ceq;
	176	struct i40iw_dma_mem mem;
	177	u32 irq;
	178	u32 msix_idx;
	179	struct i40iw_device *iwdev;
	180	struct tasklet_struct dpc_tasklet;
	181	};
	182
	183	struct i40iw_aeq {
	184	struct i40iw_sc_aeq sc_aeq;
185	struct i40iw_dma_mem mem;
186	};
187
188	struct i40iw_arp_entry {
189	u32 ip_addr[4];
190	u8 mac_addr[ETH_ALEN];
191	};
192
193	enum init_completion_state {
194	INVALID_STATE = 0,
195	INITIAL_STATE,
196	CQP_CREATED,
197	HMC_OBJS_CREATED,
198	PBLE_CHUNK_MEM,
199	CCQ_CREATED,
200	AEQ_CREATED,
201	CEQ_CREATED,
202	ILQ_CREATED,
203	IEQ_CREATED,
204	INET_NOTIFIER,
205	IP_ADDR_REGISTERED,
206	RDMA_DEV_REGISTERED
207	};
208
209	struct i40iw_msix_vector {
210	u32 idx;
211	u32 irq;
212	u32 cpu_affinity;
213	u32 ceq_id;
214	};
215
0fc2dc58 HO	216	struct l2params_work {
	217	struct work_struct work;
	218	struct i40iw_device *iwdev;
	219	struct i40iw_l2params l2params;
	220	};
	221
8e06af71 FL	222	#define I40IW_MSIX_TABLE_SIZE 65
	223
	224	struct virtchnl_work {
	225	struct work_struct work;
	226	union {
	227	struct i40iw_cqp_request *cqp_request;
	228	struct i40iw_virtchnl_work_info work_info;
	229	};
	230	};
	231
	232	struct i40e_qvlist_info;
	233
	234	struct i40iw_device {
	235	struct i40iw_ib_device *iwibdev;
	236	struct net_device *netdev;
	237	wait_queue_head_t vchnl_waitq;
	238	struct i40iw_sc_dev sc_dev;
d6f7bbcc	239	struct i40iw_sc_vsi vsi;
8e06af71 FL	240	struct i40iw_handler *hdl;
	241	struct i40e_info *ldev;
	242	struct i40e_client *client;
	243	struct i40iw_hw hw;
	244	struct i40iw_cm_core cm_core;
6c7d46fd	245	u8 *mem_resources;
8e06af71 FL	246	unsigned long *allocated_qps;
	247	unsigned long *allocated_cqs;
	248	unsigned long *allocated_mrs;
	249	unsigned long *allocated_pds;
	250	unsigned long *allocated_arps;
	251	struct i40iw_qp **qp_table;
	252	bool msix_shared;
	253	u32 msix_count;
	254	struct i40iw_msix_vector *iw_msixtbl;
	255	struct i40e_qvlist_info *iw_qvlist;
	256
	257	struct i40iw_hmc_pble_rsrc *pble_rsrc;
	258	struct i40iw_arp_entry *arp_table;
	259	struct i40iw_cqp cqp;
	260	struct i40iw_ccq ccq;
	261	u32 ceqs_count;
	262	struct i40iw_ceq *ceqlist;
	263	struct i40iw_aeq aeq;
	264	u32 arp_table_size;
	265	u32 next_arp_index;
	266	spinlock_t resource_lock; /* hw resource access */
996abf0a	267	spinlock_t qptable_lock;
8e06af71 FL	268	u32 vendor_id;
	269	u32 vendor_part_id;
	270	u32 of_device_registered;
	271
	272	u32 device_cap_flags;
	273	unsigned long db_start;
	274	u8 resource_profile;
	275	u8 max_rdma_vfs;
	276	u8 max_enabled_vfs;
	277	u8 max_sge;
	278	u8 iw_status;
	279	u8 send_term_ok;
	280	bool push_mode; /* Initialized from parameter passed to driver */
	281
	282	/* x710 specific */
	283	struct mutex pbl_mutex;
	284	struct tasklet_struct dpc_tasklet;
	285	struct workqueue_struct *virtchnl_wq;
	286	struct virtchnl_work virtchnl_w[I40IW_MAX_PE_ENABLED_VF_COUNT];
	287	struct i40iw_dma_mem obj_mem;
	288	struct i40iw_dma_mem obj_next;
	289	u8 *hmc_info_mem;
	290	u32 sd_type;
	291	struct workqueue_struct *param_wq;
	292	atomic_t params_busy;
8e06af71 FL	293	enum init_completion_state init_state;
	294	u16 mac_ip_table_idx;
	295	atomic_t vchnl_msgs;
	296	u32 max_mr;
	297	u32 max_qp;
	298	u32 max_cq;
	299	u32 max_pd;
	300	u32 next_qp;
	301	u32 next_cq;
	302	u32 next_pd;
	303	u32 max_mr_size;
	304	u32 max_qp_wr;
	305	u32 max_cqe;
	306	u32 mr_stagmask;
	307	u32 mpa_version;
	308	bool dcb;
d5965934	309	bool closing;
78300cf8	310	bool reset;
85a87c90 HO	311	u32 used_pds;
	312	u32 used_cqs;
	313	u32 used_mrs;
	314	u32 used_qps;
d5965934 MI	315	wait_queue_head_t close_wq;
d5965934 MI	316	atomic64_t use_count;
8e06af71 FL	317	};
	318
	319	struct i40iw_ib_device {
	320	struct ib_device ibdev;
	321	struct i40iw_device *iwdev;
	322	};
	323
	324	struct i40iw_handler {
	325	struct list_head list;
	326	struct i40e_client *client;
	327	struct i40iw_device device;
	328	struct i40e_info ldev;
	329	};
	330
	331	/**
	332	* to_iwdev - get device
	333	* @ibdev: ib device
	334	**/
	335	static inline struct i40iw_device to_iwdev(struct ib_device ibdev)
	336	{
	337	return container_of(ibdev, struct i40iw_ib_device, ibdev)->iwdev;
	338	}
	339
	340	/**
	341	* to_ucontext - get user context
	342	* @ibucontext: ib user context
	343	**/
	344	static inline struct i40iw_ucontext to_ucontext(struct ib_ucontext ibucontext)
	345	{
	346	return container_of(ibucontext, struct i40iw_ucontext, ibucontext);
	347	}
	348
	349	/**
	350	* to_iwpd - get protection domain
	351	* @ibpd: ib pd
	352	**/
	353	static inline struct i40iw_pd to_iwpd(struct ib_pd ibpd)
	354	{
	355	return container_of(ibpd, struct i40iw_pd, ibpd);
	356	}
	357
	358	/**
	359	* to_iwmr - get device memory region
	360	* @ibdev: ib memory region
	361	**/
	362	static inline struct i40iw_mr to_iwmr(struct ib_mr ibmr)
	363	{
	364	return container_of(ibmr, struct i40iw_mr, ibmr);
	365	}
	366
	367	/**
	368	* to_iwmr_from_ibfmr - get device memory region
	369	* @ibfmr: ib fmr
	370	**/
	371	static inline struct i40iw_mr to_iwmr_from_ibfmr(struct ib_fmr ibfmr)
	372	{
	373	return container_of(ibfmr, struct i40iw_mr, ibfmr);
	374	}
	375
	376	/**
	377	* to_iwmw - get device memory window
	378	* @ibmw: ib memory window
	379	**/
	380	static inline struct i40iw_mr to_iwmw(struct ib_mw ibmw)
381	{
382	return container_of(ibmw, struct i40iw_mr, ibmw);
383	}
384
385	/**
386	* to_iwcq - get completion queue
387	* @ibcq: ib cqdevice
388	**/
389	static inline struct i40iw_cq to_iwcq(struct ib_cq ibcq)
390	{
391	return container_of(ibcq, struct i40iw_cq, ibcq);
392	}
393
394	/**
395	* to_iwqp - get device qp
396	* @ibqp: ib qp
397	**/
398	static inline struct i40iw_qp to_iwqp(struct ib_qp ibqp)
399	{
400	return container_of(ibqp, struct i40iw_qp, ibqp);
401	}
402
403	/* i40iw.c */
404	void i40iw_add_ref(struct ib_qp *);
405	void i40iw_rem_ref(struct ib_qp *);
406	struct ib_qp i40iw_get_qp(struct ib_device , int);
407
408	void i40iw_flush_wqes(struct i40iw_device *iwdev,
409	struct i40iw_qp *qp);
410
411	void i40iw_manage_arp_cache(struct i40iw_device *iwdev,
412	unsigned char *mac_addr,
20c61f7e	413	u32 *ip_addr,
8e06af71 FL	414	bool ipv4,
	415	u32 action);
	416
	417	int i40iw_manage_apbvt(struct i40iw_device *iwdev,
	418	u16 accel_local_port,
	419	bool add_port);
	420
	421	struct i40iw_cqp_request i40iw_get_cqp_request(struct i40iw_cqp cqp, bool wait);
	422	void i40iw_free_cqp_request(struct i40iw_cqp cqp, struct i40iw_cqp_request cqp_request);
	423	void i40iw_put_cqp_request(struct i40iw_cqp cqp, struct i40iw_cqp_request cqp_request);
	424
	425	/**
	426	* i40iw_alloc_resource - allocate a resource
	427	* @iwdev: device pointer
	428	* @resource_array: resource bit array:
	429	* @max_resources: maximum resource number
	430	* @req_resources_num: Allocated resource number
	431	* @next: next free id
	432	**/
	433	static inline int i40iw_alloc_resource(struct i40iw_device *iwdev,
	434	unsigned long *resource_array,
	435	u32 max_resources,
	436	u32 *req_resource_num,
	437	u32 *next)
	438	{
	439	u32 resource_num;
	440	unsigned long flags;
	441
	442	spin_lock_irqsave(&iwdev->resource_lock, flags);
	443	resource_num = find_next_zero_bit(resource_array, max_resources, *next);
	444	if (resource_num >= max_resources) {
	445	resource_num = find_first_zero_bit(resource_array, max_resources);
	446	if (resource_num >= max_resources) {
	447	spin_unlock_irqrestore(&iwdev->resource_lock, flags);
	448	return -EOVERFLOW;
	449	}
	450	}
	451	set_bit(resource_num, resource_array);
	452	*next = resource_num + 1;
	453	if (*next == max_resources)
	454	*next = 0;
8e06af71	455	*req_resource_num = resource_num;
44856be3	456	spin_unlock_irqrestore(&iwdev->resource_lock, flags);
8e06af71 FL	457
	458	return 0;
	459	}
	460
	461	/**
	462	* i40iw_is_resource_allocated - detrmine if resource is
	463	* allocated
	464	* @iwdev: device pointer
	465	* @resource_array: resource array for the resource_num
	466	* @resource_num: resource number to check
	467	**/
	468	static inline bool i40iw_is_resource_allocated(struct i40iw_device *iwdev,
	469	unsigned long *resource_array,
	470	u32 resource_num)
	471	{
	472	bool bit_is_set;
	473	unsigned long flags;
	474
	475	spin_lock_irqsave(&iwdev->resource_lock, flags);
	476
	477	bit_is_set = test_bit(resource_num, resource_array);
	478	spin_unlock_irqrestore(&iwdev->resource_lock, flags);
	479
	480	return bit_is_set;
	481	}
	482
	483	/**
	484	* i40iw_free_resource - free a resource
	485	* @iwdev: device pointer
	486	* @resource_array: resource array for the resource_num
	487	* @resource_num: resource number to free
	488	**/
	489	static inline void i40iw_free_resource(struct i40iw_device *iwdev,
	490	unsigned long *resource_array,
	491	u32 resource_num)
	492	{
	493	unsigned long flags;
	494
	495	spin_lock_irqsave(&iwdev->resource_lock, flags);
	496	clear_bit(resource_num, resource_array);
	497	spin_unlock_irqrestore(&iwdev->resource_lock, flags);
	498	}
	499
	500	/**
	501	* to_iwhdl - Get the handler from the device pointer
	502	* @iwdev: device pointer
	503	**/
	504	static inline struct i40iw_handler to_iwhdl(struct i40iw_device iw_dev)
	505	{
	506	return container_of(iw_dev, struct i40iw_handler, device);
	507	}
	508
	509	struct i40iw_handler i40iw_find_netdev(struct net_device netdev);
	510
	511	/**
	512	* iw_init_resources -
	513	*/
	514	u32 i40iw_initialize_hw_resources(struct i40iw_device *iwdev);
	515
	516	int i40iw_register_rdma_device(struct i40iw_device *iwdev);
	517	void i40iw_port_ibevent(struct i40iw_device *iwdev);
f4a87ca1	518	void i40iw_cm_disconn(struct i40iw_qp *iwqp);
8e06af71 FL	519	void i40iw_cm_disconn_worker(void *);
	520	int mini_cm_recv_pkt(struct i40iw_cm_core , struct i40iw_device ,
	521	struct sk_buff *);
	522
	523	enum i40iw_status_code i40iw_handle_cqp_op(struct i40iw_device *iwdev,
	524	struct i40iw_cqp_request *cqp_request);
	525	enum i40iw_status_code i40iw_add_mac_addr(struct i40iw_device *iwdev,
	526	u8 mac_addr, u8 mac_index);
	527	int i40iw_modify_qp(struct ib_qp , struct ib_qp_attr , int, struct ib_udata *);
d6f7bbcc	528	void i40iw_cq_wq_destroy(struct i40iw_device iwdev, struct i40iw_sc_cq cq);
8e06af71	529
44b99f88	530	void i40iw_cleanup_pending_cqp_op(struct i40iw_device *iwdev);
8e06af71 FL	531	void i40iw_rem_pdusecount(struct i40iw_pd iwpd, struct i40iw_device iwdev);
8e06af71 FL	532	void i40iw_add_pdusecount(struct i40iw_pd *iwpd);
d5965934 MI	533	void i40iw_rem_devusecount(struct i40iw_device *iwdev);
d5965934 MI	534	void i40iw_add_devusecount(struct i40iw_device *iwdev);
8e06af71 FL	535	void i40iw_hw_modify_qp(struct i40iw_device iwdev, struct i40iw_qp iwqp,
	536	struct i40iw_modify_qp_info *info, bool wait);
	537
0fc2dc58 HO	538	void i40iw_qp_suspend_resume(struct i40iw_sc_dev *dev,
	539	struct i40iw_sc_qp *qp,
	540	bool suspend);
8e06af71 FL	541	enum i40iw_status_code i40iw_manage_qhash(struct i40iw_device *iwdev,
	542	struct i40iw_cm_info *cminfo,
	543	enum i40iw_quad_entry_type etype,
	544	enum i40iw_quad_hash_manage_type mtype,
	545	void *cmnode,
	546	bool wait);
d6f7bbcc HO	547	void i40iw_receive_ilq(struct i40iw_sc_vsi vsi, struct i40iw_puda_buf rbuf);
d6f7bbcc HO	548	void i40iw_free_sqbuf(struct i40iw_sc_vsi vsi, void bufp);
8e06af71 FL	549	void i40iw_free_qp_resources(struct i40iw_device *iwdev,
	550	struct i40iw_qp *iwqp,
	551	u32 qp_num);
	552	enum i40iw_status_code i40iw_obj_aligned_mem(struct i40iw_device *iwdev,
	553	struct i40iw_dma_mem *memptr,
	554	u32 size, u32 mask);
	555
	556	void i40iw_request_reset(struct i40iw_device *iwdev);
	557	void i40iw_destroy_rdma_device(struct i40iw_ib_device *iwibdev);
	558	void i40iw_setup_cm_core(struct i40iw_device *iwdev);
	559	void i40iw_cleanup_cm_core(struct i40iw_cm_core *cm_core);
	560	void i40iw_process_ceq(struct i40iw_device , struct i40iw_ceq iwceq);
	561	void i40iw_process_aeq(struct i40iw_device *);
	562	void i40iw_next_iw_state(struct i40iw_qp *iwqp,
	563	u8 state, u8 del_hash,
	564	u8 term, u8 term_len);
	565	int i40iw_send_syn(struct i40iw_cm_node *cm_node, u32 sendack);
	566	struct i40iw_cm_node i40iw_find_node(struct i40iw_cm_core cm_core,
	567	u16 rem_port,
	568	u32 *rem_addr,
	569	u16 loc_port,
	570	u32 *loc_addr,
	571	bool add_refcnt);
	572
	573	enum i40iw_status_code i40iw_hw_flush_wqes(struct i40iw_device *iwdev,
	574	struct i40iw_sc_qp *qp,
	575	struct i40iw_qp_flush_info *info,
	576	bool wait);
	577
20c61f7e	578	void i40iw_copy_ip_ntohl(u32 dst, __be32 src);
8e06af71 FL	579	struct ib_mr i40iw_reg_phys_mr(struct ib_pd ib_pd,
	580	u64 addr,
	581	u64 size,
	582	int acc,
	583	u64 *iova_start);
	584
	585	int i40iw_inetaddr_event(struct notifier_block *notifier,
	586	unsigned long event,
	587	void *ptr);
	588	int i40iw_inet6addr_event(struct notifier_block *notifier,
	589	unsigned long event,
	590	void *ptr);
	591	int i40iw_net_event(struct notifier_block *notifier,
	592	unsigned long event,
	593	void *ptr);
	594
	595	#endif