Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 09a1093a authored by John Soni Jose's avatar John Soni Jose Committed by James Bottomley
Browse files

[SCSI] be2iscsi: Fix support for V2 version of WRB. 



Latest adapters use the V2 version of WRB. This fix checks for the
adapter type and uses appropriate version of WRB.

Signed-off-by: default avatarJohn Soni Jose <sony.john-n@emulex.com>
Signed-off-by: default avatarJayamohan Kallickal <jayamohan.kallickal@emulex.com>
Reviewed-by: default avatarMike Christie <michaelc@cs.wisc.edu>
Signed-off-by: default avatarJames Bottomley <JBottomley@Parallels.com>
parent eaae5267

drivers/scsi/be2iscsi/be_main.c

+227 −38
Original line number Diff line number Diff line
@@ -2152,6 +2152,101 @@ static int be_iopoll(struct blk_iopoll *iop, int budget) 
	return ret;

}



static void

hwi_write_sgl_v2(struct iscsi_wrb *pwrb, struct scatterlist *sg,

		  unsigned int num_sg, struct beiscsi_io_task *io_task)

{

	struct iscsi_sge *psgl;

	unsigned int sg_len, index;

	unsigned int sge_len = 0;

	unsigned long long addr;

	struct scatterlist *l_sg;

	unsigned int offset;



	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, iscsi_bhs_addr_lo, pwrb,

		      io_task->bhs_pa.u.a32.address_lo);

	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, iscsi_bhs_addr_hi, pwrb,

		      io_task->bhs_pa.u.a32.address_hi);



	l_sg = sg;

	for (index = 0; (index < num_sg) && (index < 2); index++,

			sg = sg_next(sg)) {

		if (index == 0) {

			sg_len = sg_dma_len(sg);

			addr = (u64) sg_dma_address(sg);

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

				      sge0_addr_lo, pwrb,

				      lower_32_bits(addr));

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

				      sge0_addr_hi, pwrb,

				      upper_32_bits(addr));

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

				      sge0_len, pwrb,

				      sg_len);

			sge_len = sg_len;

		} else {

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_r2t_offset,

				      pwrb, sge_len);

			sg_len = sg_dma_len(sg);

			addr = (u64) sg_dma_address(sg);

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

				      sge1_addr_lo, pwrb,

				      lower_32_bits(addr));

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

				      sge1_addr_hi, pwrb,

				      upper_32_bits(addr));

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

				      sge1_len, pwrb,

				      sg_len);

		}

	}

	psgl = (struct iscsi_sge *)io_task->psgl_handle->pfrag;

	memset(psgl, 0, sizeof(*psgl) * BE2_SGE);



	AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, io_task->bhs_len - 2);



	AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,

		      io_task->bhs_pa.u.a32.address_hi);

	AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,

		      io_task->bhs_pa.u.a32.address_lo);



	if (num_sg == 1) {

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge0_last, pwrb,

			      1);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_last, pwrb,

			      0);

	} else if (num_sg == 2) {

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge0_last, pwrb,

			      0);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_last, pwrb,

			      1);

	} else {

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge0_last, pwrb,

			      0);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_last, pwrb,

			      0);

	}



	sg = l_sg;

	psgl++;

	psgl++;

	offset = 0;

	for (index = 0; index < num_sg; index++, sg = sg_next(sg), psgl++) {

		sg_len = sg_dma_len(sg);

		addr = (u64) sg_dma_address(sg);

		AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,

			      lower_32_bits(addr));

		AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,

			      upper_32_bits(addr));

		AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, sg_len);

		AMAP_SET_BITS(struct amap_iscsi_sge, sge_offset, psgl, offset);

		AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 0);

		offset += sg_len;

	}

	psgl--;

	AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 1);

}



static void

hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,

	      unsigned int num_sg, struct beiscsi_io_task *io_task)
@@ -2251,6 +2346,7 @@ static void hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task) 
	struct beiscsi_io_task *io_task = task->dd_data;

	struct beiscsi_conn *beiscsi_conn = io_task->conn;

	struct beiscsi_hba *phba = beiscsi_conn->phba;

	uint8_t dsp_value = 0;



	io_task->bhs_len = sizeof(struct be_nonio_bhs) - 2;

	AMAP_SET_BITS(struct amap_iscsi_wrb, iscsi_bhs_addr_lo, pwrb,
@@ -2259,18 +2355,27 @@ static void hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task) 
				io_task->bhs_pa.u.a32.address_hi);



	if (task->data) {

		if (task->data_count) {

			AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);



		/* Check for the data_count */

		dsp_value = (task->data_count) ? 1 : 0;



		if (chip_skh_r(phba->pcidev))

			AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp,

				      pwrb, dsp_value);

		else

			AMAP_SET_BITS(struct amap_iscsi_wrb, dsp,

				      pwrb, dsp_value);



		/* Map addr only if there is data_count */

		if (dsp_value) {

			io_task->mtask_addr = pci_map_single(phba->pcidev,

							     task->data,

							     task->data_count,

							     PCI_DMA_TODEVICE);



			io_task->mtask_data_count = task->data_count;

		} else {

			AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 0);

		} else

			io_task->mtask_addr = 0;

		}



		AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_lo, pwrb,

			      lower_32_bits(io_task->mtask_addr));

		AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_hi, pwrb,
@@ -4241,6 +4346,62 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode) 
	io_task->cmd_bhs = NULL;

	return -ENOMEM;

}

int beiscsi_iotask_v2(struct iscsi_task *task, struct scatterlist *sg,

		       unsigned int num_sg, unsigned int xferlen,

		       unsigned int writedir)

{



	struct beiscsi_io_task *io_task = task->dd_data;

	struct iscsi_conn *conn = task->conn;

	struct beiscsi_conn *beiscsi_conn = conn->dd_data;

	struct beiscsi_hba *phba = beiscsi_conn->phba;

	struct iscsi_wrb *pwrb = NULL;

	unsigned int doorbell = 0;



	pwrb = io_task->pwrb_handle->pwrb;

	memset(pwrb, 0, sizeof(*pwrb));



	io_task->cmd_bhs->iscsi_hdr.exp_statsn = 0;

	io_task->bhs_len = sizeof(struct be_cmd_bhs);



	if (writedir) {

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, type, pwrb,

			      INI_WR_CMD);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp, pwrb, 1);

	} else {

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, type, pwrb,

			      INI_RD_CMD);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp, pwrb, 0);

	}



	io_task->wrb_type = AMAP_GET_BITS(struct amap_iscsi_wrb_v2,

					  type, pwrb);



	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, lun, pwrb,

		      cpu_to_be16(*(unsigned short *)

		      &io_task->cmd_bhs->iscsi_hdr.lun));

	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, r2t_exp_dtl, pwrb, xferlen);

	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, wrb_idx, pwrb,

		      io_task->pwrb_handle->wrb_index);

	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, cmdsn_itt, pwrb,

		      be32_to_cpu(task->cmdsn));

	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sgl_idx, pwrb,

		      io_task->psgl_handle->sgl_index);



	hwi_write_sgl_v2(pwrb, sg, num_sg, io_task);

	AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb, pwrb,

		      io_task->pwrb_handle->nxt_wrb_index);



	be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));



	doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;

	doorbell |= (io_task->pwrb_handle->wrb_index &

		     DB_DEF_PDU_WRB_INDEX_MASK) <<

		     DB_DEF_PDU_WRB_INDEX_SHIFT;

	doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;

	iowrite32(doorbell, phba->db_va + DB_TXULP0_OFFSET);

	return 0;

}



static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,

			  unsigned int num_sg, unsigned int xferlen,
@@ -4268,6 +4429,9 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg, 
		AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 0);

	}



	io_task->wrb_type = AMAP_GET_BITS(struct amap_iscsi_wrb,

					  type, pwrb);



	AMAP_SET_BITS(struct amap_iscsi_wrb, lun, pwrb,

		      cpu_to_be16(*(unsigned short *)

				  &io_task->cmd_bhs->iscsi_hdr.lun));
@@ -4303,55 +4467,75 @@ static int beiscsi_mtask(struct iscsi_task *task) 
	struct iscsi_wrb *pwrb = NULL;

	unsigned int doorbell = 0;

	unsigned int cid;

	unsigned int pwrb_typeoffset = 0;



	cid = beiscsi_conn->beiscsi_conn_cid;

	pwrb = io_task->pwrb_handle->pwrb;

	memset(pwrb, 0, sizeof(*pwrb));



	if (chip_skh_r(phba->pcidev)) {

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, cmdsn_itt, pwrb,

			      be32_to_cpu(task->cmdsn));

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, wrb_idx, pwrb,

			      io_task->pwrb_handle->wrb_index);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sgl_idx, pwrb,

			      io_task->psgl_handle->sgl_index);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, r2t_exp_dtl, pwrb,

			      task->data_count);

		AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb, pwrb,

			      io_task->pwrb_handle->nxt_wrb_index);

		pwrb_typeoffset = SKH_WRB_TYPE_OFFSET;

	} else {

		AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb,

			      be32_to_cpu(task->cmdsn));

		AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,

			      io_task->pwrb_handle->wrb_index);

		AMAP_SET_BITS(struct amap_iscsi_wrb, sgl_icd_idx, pwrb,

			      io_task->psgl_handle->sgl_index);

		AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb,

			      task->data_count);

		AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb, pwrb,

			      io_task->pwrb_handle->nxt_wrb_index);

		pwrb_typeoffset = BE_WRB_TYPE_OFFSET;

	}





	switch (task->hdr->opcode & ISCSI_OPCODE_MASK) {

	case ISCSI_OP_LOGIN:

		AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,

			      TGT_DM_CMD);

		AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);

		AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb, 1);

		ADAPTER_SET_WRB_TYPE(pwrb, TGT_DM_CMD, pwrb_typeoffset);

		hwi_write_buffer(pwrb, task);

		break;

	case ISCSI_OP_NOOP_OUT:

		if (task->hdr->ttt != ISCSI_RESERVED_TAG) {

			AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,

				      TGT_DM_CMD);

			AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt,

				      pwrb, 0);

			AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 1);

			ADAPTER_SET_WRB_TYPE(pwrb, TGT_DM_CMD, pwrb_typeoffset);

			if (chip_skh_r(phba->pcidev))

				AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

					      dmsg, pwrb, 1);

			else

				AMAP_SET_BITS(struct amap_iscsi_wrb,

					      dmsg, pwrb, 1);

		} else {

			AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,

				      INI_RD_CMD);

			AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);

			ADAPTER_SET_WRB_TYPE(pwrb, INI_RD_CMD, pwrb_typeoffset);

			if (chip_skh_r(phba->pcidev))

				AMAP_SET_BITS(struct amap_iscsi_wrb_v2,

					      dmsg, pwrb, 0);

			else

				AMAP_SET_BITS(struct amap_iscsi_wrb,

					      dmsg, pwrb, 0);

		}

		hwi_write_buffer(pwrb, task);

		break;

	case ISCSI_OP_TEXT:

		AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,

			      TGT_DM_CMD);

		AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);

		ADAPTER_SET_WRB_TYPE(pwrb, TGT_DM_CMD, pwrb_typeoffset);

		hwi_write_buffer(pwrb, task);

		break;

	case ISCSI_OP_SCSI_TMFUNC:

		AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,

			      INI_TMF_CMD);

		AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);

		ADAPTER_SET_WRB_TYPE(pwrb, INI_TMF_CMD, pwrb_typeoffset);

		hwi_write_buffer(pwrb, task);

		break;

	case ISCSI_OP_LOGOUT:

		AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);

		AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,

			      HWH_TYPE_LOGOUT);

		ADAPTER_SET_WRB_TYPE(pwrb, HWH_TYPE_LOGOUT, pwrb_typeoffset);

		hwi_write_buffer(pwrb, task);

		break;
@@ -4363,11 +4547,10 @@ static int beiscsi_mtask(struct iscsi_task *task) 
		return -EINVAL;

	}



	AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb,

		      task->data_count);

	AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb, pwrb,

		      io_task->pwrb_handle->nxt_wrb_index);

	be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));

	/* Set the task type */

	io_task->wrb_type = (chip_skh_r(phba->pcidev)) ?

		AMAP_GET_BITS(struct amap_iscsi_wrb_v2, type, pwrb) :

		AMAP_GET_BITS(struct amap_iscsi_wrb, type, pwrb);



	doorbell |= cid & DB_WRB_POST_CID_MASK;

	doorbell |= (io_task->pwrb_handle->wrb_index &
@@ -4381,10 +4564,13 @@ static int beiscsi_task_xmit(struct iscsi_task *task) 
{

	struct beiscsi_io_task *io_task = task->dd_data;

	struct scsi_cmnd *sc = task->sc;

	struct beiscsi_hba *phba = NULL;

	struct scatterlist *sg;

	int num_sg;

	unsigned int  writedir = 0, xferlen = 0;



	phba = ((struct beiscsi_conn *)task->conn->dd_data)->phba;



	if (!sc)

		return beiscsi_mtask(task);
@@ -4407,7 +4593,7 @@ static int beiscsi_task_xmit(struct iscsi_task *task) 
	 else

		writedir = 0;



	return beiscsi_iotask(task, sg, num_sg, xferlen, writedir);

	 return phba->iotask_fn(task, sg, num_sg, xferlen, writedir);

}



/**
@@ -4618,13 +4804,16 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev, 
	case OC_DEVICE_ID1:

	case OC_DEVICE_ID2:

		phba->generation = BE_GEN2;

		phba->iotask_fn = beiscsi_iotask;

		break;

	case BE_DEVICE_ID2:

	case OC_DEVICE_ID3:

		phba->generation = BE_GEN3;

		phba->iotask_fn = beiscsi_iotask;

		break;

	case OC_SKH_ID1:

		phba->generation = BE_GEN4;

		phba->iotask_fn = beiscsi_iotask_v2;

	default:

		phba->generation = 0;

	}

drivers/scsi/be2iscsi/be_main.h

+50 −1
Original line number Diff line number Diff line
@@ -344,7 +344,10 @@ struct beiscsi_hba { 
	struct invalidate_command_table inv_tbl[128];



	unsigned int attr_log_enable;



	int (*iotask_fn)(struct iscsi_task *,

			struct scatterlist *sg,

			uint32_t num_sg, uint32_t xferlen,

			uint32_t writedir);

};



struct beiscsi_session {
@@ -418,6 +421,7 @@ struct beiscsi_io_task { 
	unsigned short bhs_len;

	dma_addr_t mtask_addr;

	uint32_t mtask_data_count;

	uint8_t wrb_type;

};



struct be_nonio_bhs {
@@ -625,6 +629,11 @@ struct iscsi_wrb { 
} __packed;



#define WRB_TYPE_MASK 0xF0000000

#define SKH_WRB_TYPE_OFFSET 27

#define BE_WRB_TYPE_OFFSET  28



#define ADAPTER_SET_WRB_TYPE(pwrb, wrb_type, type_offset) \

		(pwrb->dw[0] |= (wrb_type << type_offset))



/**

 * Pseudo amap definition in which each bit of the actual structure is defined
@@ -671,6 +680,46 @@ struct amap_iscsi_wrb { 


} __packed;



struct amap_iscsi_wrb_v2 {

	u8 r2t_exp_dtl[25]; /* DWORD 0 */

	u8 rsvd0[2];    /* DWORD 0*/

	u8 type[5];     /* DWORD 0 */

	u8 ptr2nextwrb[8];  /* DWORD 1 */

	u8 wrb_idx[8];      /* DWORD 1 */

	u8 lun[16];     /* DWORD 1 */

	u8 sgl_idx[16]; /* DWORD 2 */

	u8 ref_sgl_icd_idx[16]; /* DWORD 2 */

	u8 exp_data_sn[32]; /* DWORD 3 */

	u8 iscsi_bhs_addr_hi[32];   /* DWORD 4 */

	u8 iscsi_bhs_addr_lo[32];   /* DWORD 5 */

	u8 cq_id[16];   /* DWORD 6 */

	u8 rsvd1[16];   /* DWORD 6 */

	u8 cmdsn_itt[32];   /* DWORD 7 */

	u8 sge0_addr_hi[32];    /* DWORD 8 */

	u8 sge0_addr_lo[32];    /* DWORD 9 */

	u8 sge0_offset[24]; /* DWORD 10 */

	u8 rsvd2[7];    /* DWORD 10 */

	u8 sge0_last;   /* DWORD 10 */

	u8 sge0_len[17];    /* DWORD 11 */

	u8 rsvd3[7];    /* DWORD 11 */

	u8 diff_enbl;   /* DWORD 11 */

	u8 u_run;       /* DWORD 11 */

	u8 o_run;       /* DWORD 11 */

	u8 invalid;     /* DWORD 11 */

	u8 dsp;         /* DWORD 11 */

	u8 dmsg;        /* DWORD 11 */

	u8 rsvd4;       /* DWORD 11 */

	u8 lt;          /* DWORD 11 */

	u8 sge1_addr_hi[32];    /* DWORD 12 */

	u8 sge1_addr_lo[32];    /* DWORD 13 */

	u8 sge1_r2t_offset[24]; /* DWORD 14 */

	u8 rsvd5[7];    /* DWORD 14 */

	u8 sge1_last;   /* DWORD 14 */

	u8 sge1_len[17];    /* DWORD 15 */

	u8 rsvd6[15];   /* DWORD 15 */

} __packed;





struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid);

void

free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle);