[SCSI] be2iscsi: Adding msix and mcc_rings V3 (bfead3b2) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/scsi/be2iscsi/be.h

+9 −15

Original line number	Original line	Diff line number	Diff line
	@@ -20,8 +20,10 @@

	#include <linux/pci.h>		#include <linux/pci.h>
	#include <linux/if_vlan.h>		#include <linux/if_vlan.h>
			#include <linux/blk-iopoll.h>
	#define FW_VER_LEN 32		#define FW_VER_LEN 32
			#define MCC_Q_LEN 128
			#define MCC_CQ_LEN 256

	struct be_dma_mem {		struct be_dma_mem {
	void *va;		void *va;
	@@ -74,18 +76,14 @@ static inline void queue_tail_inc(struct be_queue_info *q)

	struct be_eq_obj {		struct be_eq_obj {
	struct be_queue_info q;		struct be_queue_info q;
	char desc[32];		struct beiscsi_hba *phba;
			struct be_queue_info *cq;
	/* Adaptive interrupt coalescing (AIC) info */		struct blk_iopoll iopoll;
	bool enable_aic;
	u16 min_eqd; /* in usecs */
	u16 max_eqd; /* in usecs */
	u16 cur_eqd; /* in usecs */
	};		};

	struct be_mcc_obj {		struct be_mcc_obj {
	struct be_queue_info *q;		struct be_queue_info q;
	struct be_queue_info *cq;		struct be_queue_info cq;
	};		};

	struct be_ctrl_info {		struct be_ctrl_info {
	@@ -176,8 +174,4 @@ static inline void swap_dws(void *wrb, int len)
	} while (len);		} while (len);
	#endif /* __BIG_ENDIAN */		#endif /* __BIG_ENDIAN */
	}		}

	extern void beiscsi_cq_notify(struct be_ctrl_info *ctrl, u16 qid, bool arm,
	u16 num_popped);

	#endif /* BEISCSI_H */		#endif /* BEISCSI_H */

drivers/scsi/be2iscsi/be_cmds.c

+234 −29

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,16 @@
	#include "be_mgmt.h"		#include "be_mgmt.h"
	#include "be_main.h"		#include "be_main.h"

			static void be_mcc_notify(struct beiscsi_hba *phba)
			{
			struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
			u32 val = 0;

			val \|= mccq->id & DB_MCCQ_RING_ID_MASK;
			val \|= 1 << DB_MCCQ_NUM_POSTED_SHIFT;
			iowrite32(val, phba->db_va + DB_MCCQ_OFFSET);
			}

	static inline bool be_mcc_compl_is_new(struct be_mcc_compl *compl)		static inline bool be_mcc_compl_is_new(struct be_mcc_compl *compl)
	{		{
	if (compl->flags != 0) {		if (compl->flags != 0) {
	@@ -54,13 +64,56 @@ static int be_mcc_compl_process(struct be_ctrl_info *ctrl,
	return 0;		return 0;
	}		}


	static inline bool is_link_state_evt(u32 trailer)		static inline bool is_link_state_evt(u32 trailer)
	{		{
	return (((trailer >> ASYNC_TRAILER_EVENT_CODE_SHIFT) &		return (((trailer >> ASYNC_TRAILER_EVENT_CODE_SHIFT) &
	ASYNC_TRAILER_EVENT_CODE_MASK) == ASYNC_EVENT_CODE_LINK_STATE);		ASYNC_TRAILER_EVENT_CODE_MASK) ==
			ASYNC_EVENT_CODE_LINK_STATE);
	}		}

	void beiscsi_cq_notify(struct be_ctrl_info *ctrl, u16 qid, bool arm,		static struct be_mcc_compl be_mcc_compl_get(struct beiscsi_hba phba)
			{
			struct be_queue_info *mcc_cq = &phba->ctrl.mcc_obj.cq;
			struct be_mcc_compl *compl = queue_tail_node(mcc_cq);

			if (be_mcc_compl_is_new(compl)) {
			queue_tail_inc(mcc_cq);
			return compl;
			}
			return NULL;
			}

			static void be2iscsi_fail_session(struct iscsi_cls_session *cls_session)
			{
			iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
			}

			static void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
			struct be_async_event_link_state *evt)
			{
			switch (evt->port_link_status) {
			case ASYNC_EVENT_LINK_DOWN:
			SE_DEBUG(DBG_LVL_1, "Link Down on Physical Port %d \n",
			evt->physical_port);
			phba->state \|= BE_ADAPTER_LINK_DOWN;
			break;
			case ASYNC_EVENT_LINK_UP:
			phba->state = BE_ADAPTER_UP;
			SE_DEBUG(DBG_LVL_1, "Link UP on Physical Port %d \n",
			evt->physical_port);
			iscsi_host_for_each_session(phba->shost,
			be2iscsi_fail_session);
			break;
			default:
			SE_DEBUG(DBG_LVL_1, "Unexpected Async Notification %d on"
			"Physical Port %d \n",
			evt->port_link_status,
			evt->physical_port);
			}
			}

			static void beiscsi_cq_notify(struct beiscsi_hba *phba, u16 qid, bool arm,
	u16 num_popped)		u16 num_popped)
	{		{
	u32 val = 0;		u32 val = 0;
	@@ -68,7 +121,66 @@ void beiscsi_cq_notify(struct be_ctrl_info *ctrl, u16 qid, bool arm,
	if (arm)		if (arm)
	val \|= 1 << DB_CQ_REARM_SHIFT;		val \|= 1 << DB_CQ_REARM_SHIFT;
	val \|= num_popped << DB_CQ_NUM_POPPED_SHIFT;		val \|= num_popped << DB_CQ_NUM_POPPED_SHIFT;
	iowrite32(val, ctrl->db + DB_CQ_OFFSET);		iowrite32(val, phba->db_va + DB_CQ_OFFSET);
			}


			int be_process_mcc(struct beiscsi_hba *phba)
			{
			struct be_mcc_compl *compl;
			int num = 0, status = 0;
			struct be_ctrl_info *ctrl = &phba->ctrl;

			spin_lock_bh(&phba->ctrl.mcc_cq_lock);
			while ((compl = be_mcc_compl_get(phba))) {
			if (compl->flags & CQE_FLAGS_ASYNC_MASK) {
			/* Interpret flags as an async trailer */
			BUG_ON(!is_link_state_evt(compl->flags));

			/* Interpret compl as a async link evt */
			beiscsi_async_link_state_process(phba,
			(struct be_async_event_link_state *) compl);
			} else if (compl->flags & CQE_FLAGS_COMPLETED_MASK) {
			status = be_mcc_compl_process(ctrl, compl);
			atomic_dec(&phba->ctrl.mcc_obj.q.used);
			}
			be_mcc_compl_use(compl);
			num++;
			}

			if (num)
			beiscsi_cq_notify(phba, phba->ctrl.mcc_obj.cq.id, true, num);

			spin_unlock_bh(&phba->ctrl.mcc_cq_lock);
			return status;
			}

			/* Wait till no more pending mcc requests are present */
			static int be_mcc_wait_compl(struct beiscsi_hba *phba)
			{
			#define mcc_timeout 120000 /* 5s timeout */
			int i, status;
			for (i = 0; i < mcc_timeout; i++) {
			status = be_process_mcc(phba);
			if (status)
			return status;

			if (atomic_read(&phba->ctrl.mcc_obj.q.used) == 0)
			break;
			udelay(100);
			}
			if (i == mcc_timeout) {
			dev_err(&phba->pcidev->dev, "mccq poll timed out\n");
			return -1;
			}
			return 0;
			}

			/* Notify MCC requests and wait for completion */
			int be_mcc_notify_wait(struct beiscsi_hba *phba)
			{
			be_mcc_notify(phba);
			return be_mcc_wait_compl(phba);
	}		}

	static int be_mbox_db_ready_wait(struct be_ctrl_info *ctrl)		static int be_mbox_db_ready_wait(struct be_ctrl_info *ctrl)
	@@ -142,6 +254,52 @@ int be_mbox_notify(struct be_ctrl_info *ctrl)
	return 0;		return 0;
	}		}

			/*
			* Insert the mailbox address into the doorbell in two steps
			* Polls on the mbox doorbell till a command completion (or a timeout) occurs
			*/
			static int be_mbox_notify_wait(struct beiscsi_hba *phba)
			{
			int status;
			u32 val = 0;
			void __iomem *db = phba->ctrl.db + MPU_MAILBOX_DB_OFFSET;
			struct be_dma_mem *mbox_mem = &phba->ctrl.mbox_mem;
			struct be_mcc_mailbox *mbox = mbox_mem->va;
			struct be_mcc_compl *compl = &mbox->compl;
			struct be_ctrl_info *ctrl = &phba->ctrl;

			val \|= MPU_MAILBOX_DB_HI_MASK;
			/* at bits 2 - 31 place mbox dma addr msb bits 34 - 63 */
			val \|= (upper_32_bits(mbox_mem->dma) >> 2) << 2;
			iowrite32(val, db);

			/* wait for ready to be set */
			status = be_mbox_db_ready_wait(ctrl);
			if (status != 0)
			return status;

			val = 0;
			/* at bits 2 - 31 place mbox dma addr lsb bits 4 - 33 */
			val \|= (u32)(mbox_mem->dma >> 4) << 2;
			iowrite32(val, db);

			status = be_mbox_db_ready_wait(ctrl);
			if (status != 0)
			return status;

			/* A cq entry has been made now */
			if (be_mcc_compl_is_new(compl)) {
			status = be_mcc_compl_process(ctrl, &mbox->compl);
			be_mcc_compl_use(compl);
			if (status)
			return status;
			} else {
			dev_err(&phba->pcidev->dev, "invalid mailbox completion\n");
			return -1;
			}
			return 0;
			}

	void be_wrb_hdr_prepare(struct be_mcc_wrb *wrb, int payload_len,		void be_wrb_hdr_prepare(struct be_mcc_wrb *wrb, int payload_len,
	bool embedded, u8 sge_cnt)		bool embedded, u8 sge_cnt)
	{		{
	@@ -203,6 +361,20 @@ struct be_mcc_wrb wrb_from_mbox(struct be_dma_mem mbox_mem)
	return &((struct be_mcc_mailbox *)(mbox_mem->va))->wrb;		return &((struct be_mcc_mailbox *)(mbox_mem->va))->wrb;
	}		}

			struct be_mcc_wrb wrb_from_mccq(struct beiscsi_hba phba)
			{
			struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
			struct be_mcc_wrb *wrb;

			BUG_ON(atomic_read(&mccq->used) >= mccq->len);
			wrb = queue_head_node(mccq);
			queue_head_inc(mccq);
			atomic_inc(&mccq->used);
			memset(wrb, 0, sizeof(*wrb));
			return wrb;
			}


	int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,		int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,
	struct be_queue_info *eq, int eq_delay)		struct be_queue_info *eq, int eq_delay)
	{		{
	@@ -212,6 +384,7 @@ int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,
	struct be_dma_mem *q_mem = &eq->dma_mem;		struct be_dma_mem *q_mem = &eq->dma_mem;
	int status;		int status;

			SE_DEBUG(DBG_LVL_8, "In beiscsi_cmd_eq_create\n");
	spin_lock(&ctrl->mbox_lock);		spin_lock(&ctrl->mbox_lock);
	memset(wrb, 0, sizeof(*wrb));		memset(wrb, 0, sizeof(*wrb));

	@@ -249,6 +422,7 @@ int be_cmd_fw_initialize(struct be_ctrl_info *ctrl)
	int status;		int status;
	u8 *endian_check;		u8 *endian_check;

			SE_DEBUG(DBG_LVL_8, "In be_cmd_fw_initialize\n");
	spin_lock(&ctrl->mbox_lock);		spin_lock(&ctrl->mbox_lock);
	memset(wrb, 0, sizeof(*wrb));		memset(wrb, 0, sizeof(*wrb));

	@@ -282,6 +456,7 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
	void *ctxt = &req->context;		void *ctxt = &req->context;
	int status;		int status;

			SE_DEBUG(DBG_LVL_8, "In beiscsi_cmd_cq_create \n");
	spin_lock(&ctrl->mbox_lock);		spin_lock(&ctrl->mbox_lock);
	memset(wrb, 0, sizeof(*wrb));		memset(wrb, 0, sizeof(*wrb));

	@@ -289,7 +464,6 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,

	be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,		be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
	OPCODE_COMMON_CQ_CREATE, sizeof(*req));		OPCODE_COMMON_CQ_CREATE, sizeof(*req));

	if (!q_mem->va)		if (!q_mem->va)
	SE_DEBUG(DBG_LVL_1, "uninitialized q_mem->va\n");		SE_DEBUG(DBG_LVL_1, "uninitialized q_mem->va\n");

	@@ -329,6 +503,53 @@ static u32 be_encoded_q_len(int q_len)
	len_encoded = 0;		len_encoded = 0;
	return len_encoded;		return len_encoded;
	}		}

			int be_cmd_mccq_create(struct beiscsi_hba *phba,
			struct be_queue_info *mccq,
			struct be_queue_info *cq)
			{
			struct be_mcc_wrb *wrb;
			struct be_cmd_req_mcc_create *req;
			struct be_dma_mem *q_mem = &mccq->dma_mem;
			struct be_ctrl_info *ctrl;
			void *ctxt;
			int status;

			spin_lock(&phba->ctrl.mbox_lock);
			ctrl = &phba->ctrl;
			wrb = wrb_from_mbox(&ctrl->mbox_mem);
			req = embedded_payload(wrb);
			ctxt = &req->context;

			be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);

			be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
			OPCODE_COMMON_MCC_CREATE, sizeof(*req));

			req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);

			AMAP_SET_BITS(struct amap_mcc_context, fid, ctxt,
			PCI_FUNC(phba->pcidev->devfn));
			AMAP_SET_BITS(struct amap_mcc_context, valid, ctxt, 1);
			AMAP_SET_BITS(struct amap_mcc_context, ring_size, ctxt,
			be_encoded_q_len(mccq->len));
			AMAP_SET_BITS(struct amap_mcc_context, cq_id, ctxt, cq->id);

			be_dws_cpu_to_le(ctxt, sizeof(req->context));

			be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);

			status = be_mbox_notify_wait(phba);
			if (!status) {
			struct be_cmd_resp_mcc_create *resp = embedded_payload(wrb);
			mccq->id = le16_to_cpu(resp->id);
			mccq->created = true;
			}
			spin_unlock(&phba->ctrl.mbox_lock);

			return status;
			}

	int beiscsi_cmd_q_destroy(struct be_ctrl_info ctrl, struct be_queue_info q,		int beiscsi_cmd_q_destroy(struct be_ctrl_info ctrl, struct be_queue_info q,
	int queue_type)		int queue_type)
	{		{
	@@ -337,6 +558,7 @@ int beiscsi_cmd_q_destroy(struct be_ctrl_info ctrl, struct be_queue_info q,
	u8 subsys = 0, opcode = 0;		u8 subsys = 0, opcode = 0;
	int status;		int status;

			SE_DEBUG(DBG_LVL_8, "In beiscsi_cmd_q_destroy \n");
	spin_lock(&ctrl->mbox_lock);		spin_lock(&ctrl->mbox_lock);
	memset(wrb, 0, sizeof(*wrb));		memset(wrb, 0, sizeof(*wrb));
	be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);		be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
	@@ -350,6 +572,10 @@ int beiscsi_cmd_q_destroy(struct be_ctrl_info ctrl, struct be_queue_info q,
	subsys = CMD_SUBSYSTEM_COMMON;		subsys = CMD_SUBSYSTEM_COMMON;
	opcode = OPCODE_COMMON_CQ_DESTROY;		opcode = OPCODE_COMMON_CQ_DESTROY;
	break;		break;
			case QTYPE_MCCQ:
			subsys = CMD_SUBSYSTEM_COMMON;
			opcode = OPCODE_COMMON_MCC_DESTROY;
			break;
	case QTYPE_WRBQ:		case QTYPE_WRBQ:
	subsys = CMD_SUBSYSTEM_ISCSI;		subsys = CMD_SUBSYSTEM_ISCSI;
	opcode = OPCODE_COMMON_ISCSI_WRBQ_DESTROY;		opcode = OPCODE_COMMON_ISCSI_WRBQ_DESTROY;
	@@ -377,30 +603,6 @@ int beiscsi_cmd_q_destroy(struct be_ctrl_info ctrl, struct be_queue_info q,
	return status;		return status;
	}		}

	int be_cmd_get_mac_addr(struct be_ctrl_info ctrl, u8 mac_addr)
	{
	struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
	struct be_cmd_req_get_mac_addr *req = embedded_payload(wrb);
	int status;

	spin_lock(&ctrl->mbox_lock);
	memset(wrb, 0, sizeof(*wrb));
	be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
	be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
	OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
	sizeof(*req));

	status = be_mbox_notify(ctrl);
	if (!status) {
	struct be_cmd_resp_get_mac_addr *resp = embedded_payload(wrb);

	memcpy(mac_addr, resp->mac_address, ETH_ALEN);
	}

	spin_unlock(&ctrl->mbox_lock);
	return status;
	}

	int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,		int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,
	struct be_queue_info *cq,		struct be_queue_info *cq,
	struct be_queue_info *dq, int length,		struct be_queue_info *dq, int length,
	@@ -412,6 +614,7 @@ int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,
	void *ctxt = &req->context;		void *ctxt = &req->context;
	int status;		int status;

			SE_DEBUG(DBG_LVL_8, "In be_cmd_create_default_pdu_queue\n");
	spin_lock(&ctrl->mbox_lock);		spin_lock(&ctrl->mbox_lock);
	memset(wrb, 0, sizeof(*wrb));		memset(wrb, 0, sizeof(*wrb));

	@@ -468,8 +671,10 @@ int be_cmd_wrbq_create(struct be_ctrl_info ctrl, struct be_dma_mem q_mem,
	be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);		be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);

	status = be_mbox_notify(ctrl);		status = be_mbox_notify(ctrl);
	if (!status)		if (!status) {
	wrbq->id = le16_to_cpu(resp->cid);		wrbq->id = le16_to_cpu(resp->cid);
			wrbq->created = true;
			}
	spin_unlock(&ctrl->mbox_lock);		spin_unlock(&ctrl->mbox_lock);
	return status;		return status;
	}		}

drivers/scsi/be2iscsi/be_cmds.h

+31 −6

Original line number	Original line	Diff line number	Diff line
	@@ -47,6 +47,8 @@ struct be_mcc_wrb {

	#define CQE_FLAGS_VALID_MASK (1 << 31)		#define CQE_FLAGS_VALID_MASK (1 << 31)
	#define CQE_FLAGS_ASYNC_MASK (1 << 30)		#define CQE_FLAGS_ASYNC_MASK (1 << 30)
			#define CQE_FLAGS_COMPLETED_MASK (1 << 28)
			#define CQE_FLAGS_CONSUMED_MASK (1 << 27)

	/* Completion Status */		/* Completion Status */
	#define MCC_STATUS_SUCCESS 0x0		#define MCC_STATUS_SUCCESS 0x0
	@@ -173,7 +175,7 @@ struct be_cmd_req_hdr {
	u8 domain; /* dword 0 */		u8 domain; /* dword 0 */
	u32 timeout; /* dword 1 */		u32 timeout; /* dword 1 */
	u32 request_length; /* dword 2 */		u32 request_length; /* dword 2 */
	u32 rsvd; /* dword 3 */		u32 rsvd0; /* dword 3 */
	};		};

	struct be_cmd_resp_hdr {		struct be_cmd_resp_hdr {
	@@ -382,7 +384,6 @@ struct be_cmd_req_modify_eq_delay {

	#define ETH_ALEN 6		#define ETH_ALEN 6


	struct be_cmd_req_get_mac_addr {		struct be_cmd_req_get_mac_addr {
	struct be_cmd_req_hdr hdr;		struct be_cmd_req_hdr hdr;
	u32 nic_port_count;		u32 nic_port_count;
	@@ -417,14 +418,21 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,

	int beiscsi_cmd_q_destroy(struct be_ctrl_info ctrl, struct be_queue_info q,		int beiscsi_cmd_q_destroy(struct be_ctrl_info ctrl, struct be_queue_info q,
	int type);		int type);
			int be_cmd_mccq_create(struct beiscsi_hba *phba,
			struct be_queue_info *mccq,
			struct be_queue_info *cq);

	int be_poll_mcc(struct be_ctrl_info *ctrl);		int be_poll_mcc(struct be_ctrl_info *ctrl);
	unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl);		unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
	int be_cmd_get_mac_addr(struct be_ctrl_info ctrl, u8 mac_addr);		struct beiscsi_hba *phba);
			int be_cmd_get_mac_addr(struct beiscsi_hba phba, u8 mac_addr);

	/ISCSI Functuions /		/ISCSI Functuions /
	int be_cmd_fw_initialize(struct be_ctrl_info *ctrl);		int be_cmd_fw_initialize(struct be_ctrl_info *ctrl);

	struct be_mcc_wrb wrb_from_mbox(struct be_dma_mem mbox_mem);		struct be_mcc_wrb wrb_from_mbox(struct be_dma_mem mbox_mem);
			struct be_mcc_wrb wrb_from_mccq(struct beiscsi_hba phba);
			int be_mcc_notify_wait(struct beiscsi_hba *phba);

	int be_mbox_notify(struct be_ctrl_info *ctrl);		int be_mbox_notify(struct be_ctrl_info *ctrl);

	@@ -531,6 +539,23 @@ struct amap_sol_cqe {
	u8 valid; /* dword 3 */		u8 valid; /* dword 3 */
	} __packed;		} __packed;

			#define SOL_ICD_INDEX_MASK 0x0003FFC0
			struct amap_sol_cqe_ring {
			u8 hw_sts[8]; /* dword 0 */
			u8 i_sts[8]; /* dword 0 */
			u8 i_resp[8]; /* dword 0 */
			u8 i_flags[7]; /* dword 0 */
			u8 s; /* dword 0 */
			u8 i_exp_cmd_sn[32]; /* dword 1 */
			u8 code[6]; /* dword 2 */
			u8 icd_index[12]; /* dword 2 */
			u8 rsvd[6]; /* dword 2 */
			u8 i_cmd_wnd[8]; /* dword 2 */
			u8 i_res_cnt[31]; /* dword 3 */
			u8 valid; /* dword 3 */
			} __packed;



	/**		/**
	* Post WRB Queue Doorbell Register used by the host Storage		* Post WRB Queue Doorbell Register used by the host Storage
	@@ -664,8 +689,8 @@ struct be_fw_cfg {
	#define OPCODE_COMMON_TCP_UPLOAD 56		#define OPCODE_COMMON_TCP_UPLOAD 56
	#define OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS 1		#define OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS 1
	/* --- CMD_ISCSI_INVALIDATE_CONNECTION_TYPE --- */		/* --- CMD_ISCSI_INVALIDATE_CONNECTION_TYPE --- */
	#define CMD_ISCSI_CONNECTION_INVALIDATE 1		#define CMD_ISCSI_CONNECTION_INVALIDATE 0x8001
	#define CMD_ISCSI_CONNECTION_ISSUE_TCP_RST 2		#define CMD_ISCSI_CONNECTION_ISSUE_TCP_RST 0x8002
	#define OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION 42		#define OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION 42

	#define INI_WR_CMD 1 /* Initiator write command */		#define INI_WR_CMD 1 /* Initiator write command */

drivers/scsi/be2iscsi/be_iscsi.c

+13 −10

Original line number	Original line	Diff line number	Diff line
	@@ -297,7 +297,7 @@ int beiscsi_get_host_param(struct Scsi_Host *shost,

	switch (param) {		switch (param) {
	case ISCSI_HOST_PARAM_HWADDRESS:		case ISCSI_HOST_PARAM_HWADDRESS:
	be_cmd_get_mac_addr(&phba->ctrl, phba->mac_address);		be_cmd_get_mac_addr(phba, phba->mac_address);
	len = sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);		len = sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
	break;		break;
	default:		default:
	@@ -377,16 +377,12 @@ int beiscsi_conn_start(struct iscsi_cls_conn *cls_conn)
	struct beiscsi_conn *beiscsi_conn = conn->dd_data;		struct beiscsi_conn *beiscsi_conn = conn->dd_data;
	struct beiscsi_endpoint *beiscsi_ep;		struct beiscsi_endpoint *beiscsi_ep;
	struct beiscsi_offload_params params;		struct beiscsi_offload_params params;
	struct iscsi_session *session = conn->session;
	struct Scsi_Host *shost = iscsi_session_to_shost(session->cls_session);
	struct beiscsi_hba *phba = iscsi_host_priv(shost);

	memset(&params, 0, sizeof(struct beiscsi_offload_params));		memset(&params, 0, sizeof(struct beiscsi_offload_params));
	beiscsi_ep = beiscsi_conn->ep;		beiscsi_ep = beiscsi_conn->ep;
	if (!beiscsi_ep)		if (!beiscsi_ep)
	SE_DEBUG(DBG_LVL_1, "In beiscsi_conn_start , no beiscsi_ep\n");		SE_DEBUG(DBG_LVL_1, "In beiscsi_conn_start , no beiscsi_ep\n");

	free_mgmt_sgl_handle(phba, beiscsi_conn->plogin_sgl_handle);
	beiscsi_conn->login_in_progress = 0;		beiscsi_conn->login_in_progress = 0;
	beiscsi_set_params_for_offld(beiscsi_conn, &params);		beiscsi_set_params_for_offld(beiscsi_conn, &params);
	beiscsi_offload_connection(beiscsi_conn, &params);		beiscsi_offload_connection(beiscsi_conn, &params);
	@@ -498,6 +494,13 @@ beiscsi_ep_connect(struct Scsi_Host shost, struct sockaddr dst_addr,
	SE_DEBUG(DBG_LVL_1, "shost is NULL \n");		SE_DEBUG(DBG_LVL_1, "shost is NULL \n");
	return ERR_PTR(ret);		return ERR_PTR(ret);
	}		}

			if (phba->state) {
			ret = -EBUSY;
			SE_DEBUG(DBG_LVL_1, "The Adapet state is Not UP \n");
			return ERR_PTR(ret);
			}

	ep = iscsi_create_endpoint(sizeof(struct beiscsi_endpoint));		ep = iscsi_create_endpoint(sizeof(struct beiscsi_endpoint));
	if (!ep) {		if (!ep) {
	ret = -ENOMEM;		ret = -ENOMEM;

drivers/scsi/be2iscsi/be_main.c

+656 −232

File changed.

Preview size limit exceeded, changes collapsed.