[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: John Soni Jose <sony.john-n@emulex.com>
Signed-off-by: Jayamohan Kallickal <jayamohan.kallickal@emulex.com>
Reviewed-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 8a142ce..6aef05f 100644 (file)
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -2153,6 +2153,101 @@ static int be_iopoll(struct blk_iopoll *iop, int budget)
 }
 
 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 @@ free_hndls:
        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));
-       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);
+
+       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;
        }

diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index 2c9cba2..8632927 100644 (file)
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -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);