History

scsi: mpi3mr: Support for preallocation of SGL BSG data buffers part-2

The driver acquires the required SGLs from the pre-allocated pool.

Chandrakanth patil committed 2 years ago

Commit fb231d71 parent c432e162 files · +313 −85Browse files

Unified · Split

2 files
  1. drivers/scsi/mpi3mr/mpi3mr.h +2 −0
  2. drivers/scsi/mpi3mr/mpi3mr_app.c +311 −85
drivers/scsi/mpi3mr/mpi3mr.h+2−0
@@ -247,6 +247,8 @@ struct mpi3mr_buf_map { · 246 unmodified lines
247247 u32 kern_buf_len;
248248 dma_addr_t kern_buf_dma;
249249 u8 data_dir;
250+ u16 num_dma_desc;
251+ struct dma_memory_desc *dma_desc;
250252 };
251253
252254 /* IOC State definitions */
drivers/scsi/mpi3mr/mpi3mr_app.c+311−85
@@ -563,8 +563,37 @@ static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job) · 562 unmodified lines
563563 return rval;
564564 }
565565
566+/**
567+ * mpi3mr_total_num_ioctl_sges - Count number of SGEs required
568+ * @drv_bufs: DMA address of the buffers to be placed in sgl
569+ * @bufcnt: Number of DMA buffers
570+ *
571+ * This function returns total number of data SGEs required
572+ * including zero length SGEs and excluding management request
573+ * and response buffer for the given list of data buffer
574+ * descriptors
575+ *
576+ * Return: Number of SGE elements needed
577+ */
578+static inline u16 mpi3mr_total_num_ioctl_sges(struct mpi3mr_buf_map *drv_bufs,
579+ u8 bufcnt)
580+{
581+ u16 i, sge_count = 0;
582+
583+ for (i = 0; i < bufcnt; i++, drv_bufs++) {
584+ if (drv_bufs->data_dir == DMA_NONE ||
585+ drv_bufs->kern_buf)
586+ continue;
587+ sge_count += drv_bufs->num_dma_desc;
588+ if (!drv_bufs->num_dma_desc)
589+ sge_count++;
590+ }
591+ return sge_count;
592+}
593+
566594 /**
567595 * mpi3mr_bsg_build_sgl - SGL construction for MPI commands
596+ * @mrioc: Adapter instance reference
568597 * @mpi_req: MPI request
569598 * @sgl_offset: offset to start sgl in the MPI request
570599 * @drv_bufs: DMA address of the buffers to be placed in sgl
@@ -576,27 +605,45 @@ static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job) · 5 unmodified lines
576605 * This function places the DMA address of the given buffers in
577606 * proper format as SGEs in the given MPI request.
578607 *
579− * Return: Nothing
608+ * Return: 0 on success,-1 on failure
580609 */
581−static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset,
582− struct mpi3mr_buf_map *drv_bufs, u8 bufcnt, u8 is_rmc,
583− u8 is_rmr, u8 num_datasges)
610+static int mpi3mr_bsg_build_sgl(struct mpi3mr_ioc *mrioc, u8 *mpi_req,
611+ u32 sgl_offset, struct mpi3mr_buf_map *drv_bufs,
612+ u8 bufcnt, u8 is_rmc, u8 is_rmr, u8 num_datasges)
584613 {
614+ struct mpi3_request_header *mpi_header =
615+ (struct mpi3_request_header *)mpi_req;
585616 u8 *sgl = (mpi_req + sgl_offset), count = 0;
586617 struct mpi3_mgmt_passthrough_request *rmgmt_req =
587618 (struct mpi3_mgmt_passthrough_request *)mpi_req;
588619 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
589− u8 sgl_flags, sgl_flags_last;
620+ u8 flag, sgl_flags, sgl_flag_eob, sgl_flags_last, last_chain_sgl_flag;
621+ u16 available_sges, i, sges_needed;
622+ u32 sge_element_size = sizeof(struct mpi3_sge_common);
623+ bool chain_used = false;
590624
591625 sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE |
592− MPI3_SGE_FLAGS_DLAS_SYSTEM | MPI3_SGE_FLAGS_END_OF_BUFFER;
593− sgl_flags_last = sgl_flags | MPI3_SGE_FLAGS_END_OF_LIST;
626+ MPI3_SGE_FLAGS_DLAS_SYSTEM;
627+ sgl_flag_eob = sgl_flags | MPI3_SGE_FLAGS_END_OF_BUFFER;
628+ sgl_flags_last = sgl_flag_eob | MPI3_SGE_FLAGS_END_OF_LIST;
629+ last_chain_sgl_flag = MPI3_SGE_FLAGS_ELEMENT_TYPE_LAST_CHAIN |
630+ MPI3_SGE_FLAGS_DLAS_SYSTEM;
631+
632+ sges_needed = mpi3mr_total_num_ioctl_sges(drv_bufs, bufcnt);
594633
595634 if (is_rmc) {
596635 mpi3mr_add_sg_single(&rmgmt_req->command_sgl,
597636 sgl_flags_last, drv_buf_iter->kern_buf_len,
598637 drv_buf_iter->kern_buf_dma);
599− sgl = (u8 *)drv_buf_iter->kern_buf + drv_buf_iter->bsg_buf_len;
638+ sgl = (u8 *)drv_buf_iter->kern_buf +
639+ drv_buf_iter->bsg_buf_len;
640+ available_sges = (drv_buf_iter->kern_buf_len -
641+ drv_buf_iter->bsg_buf_len) / sge_element_size;
642+
643+ if (sges_needed > available_sges)
644+ return -1;
645+
646+ chain_used = true;
600647 drv_buf_iter++;
601648 count++;
602649 if (is_rmr) {
@@ -608,23 +655,95 @@ static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset, · 5 unmodified lines
608655 } else
609656 mpi3mr_build_zero_len_sge(
610657 &rmgmt_req->response_sgl);
658+ if (num_datasges) {
659+ i = 0;
660+ goto build_sges;
661+ }
662+ } else {
663+ if (sgl_offset >= MPI3MR_ADMIN_REQ_FRAME_SZ)
664+ return -1;
665+ available_sges = (MPI3MR_ADMIN_REQ_FRAME_SZ - sgl_offset) /
666+ sge_element_size;
667+ if (!available_sges)
668+ return -1;
611669 }
612670 if (!num_datasges) {
613671 mpi3mr_build_zero_len_sge(sgl);
614− return;
672+ return 0;
615673 }
674+ if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) {
675+ if ((sges_needed > 2) || (sges_needed > available_sges))
676+ return -1;
677+ for (; count < bufcnt; count++, drv_buf_iter++) {
678+ if (drv_buf_iter->data_dir == DMA_NONE ||
679+ !drv_buf_iter->num_dma_desc)
680+ continue;
681+ mpi3mr_add_sg_single(sgl, sgl_flags_last,
682+ drv_buf_iter->dma_desc[0].size,
683+ drv_buf_iter->dma_desc[0].dma_addr);
684+ sgl += sge_element_size;
685+ }
686+ return 0;
687+ }
688+ i = 0;
689+
690+build_sges:
616691 for (; count < bufcnt; count++, drv_buf_iter++) {
617692 if (drv_buf_iter->data_dir == DMA_NONE)
618693 continue;
619− if (num_datasges == 1 || !is_rmc)
620− mpi3mr_add_sg_single(sgl, sgl_flags_last,
621− drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma);
622− else
623− mpi3mr_add_sg_single(sgl, sgl_flags,
624− drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma);
625− sgl += sizeof(struct mpi3_sge_common);
694+ if (!drv_buf_iter->num_dma_desc) {
695+ if (chain_used && !available_sges)
696+ return -1;
697+ if (!chain_used && (available_sges == 1) &&
698+ (sges_needed > 1))
699+ goto setup_chain;
700+ flag = sgl_flag_eob;
701+ if (num_datasges == 1)
702+ flag = sgl_flags_last;
703+ mpi3mr_add_sg_single(sgl, flag, 0, 0);
704+ sgl += sge_element_size;
705+ sges_needed--;
706+ available_sges--;
707+ num_datasges--;
708+ continue;
709+ }
710+ for (; i < drv_buf_iter->num_dma_desc; i++) {
711+ if (chain_used && !available_sges)
712+ return -1;
713+ if (!chain_used && (available_sges == 1) &&
714+ (sges_needed > 1))
715+ goto setup_chain;
716+ flag = sgl_flags;
717+ if (i == (drv_buf_iter->num_dma_desc - 1)) {
718+ if (num_datasges == 1)
719+ flag = sgl_flags_last;
720+ else
721+ flag = sgl_flag_eob;
722+ }
723+
724+ mpi3mr_add_sg_single(sgl, flag,
725+ drv_buf_iter->dma_desc[i].size,
726+ drv_buf_iter->dma_desc[i].dma_addr);
727+ sgl += sge_element_size;
728+ available_sges--;
729+ sges_needed--;
730+ }
626731 num_datasges--;
732+ i = 0;
627733 }
734+ return 0;
735+
736+setup_chain:
737+ available_sges = mrioc->ioctl_chain_sge.size / sge_element_size;
738+ if (sges_needed > available_sges)
739+ return -1;
740+ mpi3mr_add_sg_single(sgl, last_chain_sgl_flag,
741+ (sges_needed * sge_element_size),
742+ mrioc->ioctl_chain_sge.dma_addr);
743+ memset(mrioc->ioctl_chain_sge.addr, 0, mrioc->ioctl_chain_sge.size);
744+ sgl = (u8 *)mrioc->ioctl_chain_sge.addr;
745+ chain_used = true;
746+ goto build_sges;
628747 }
629748
630749 /**
@@ -935,10 +1054,66 @@ err_out: · 304 unmodified lines
9351054 }
9361055 return -1;
9371056 }
1057+
1058+/**
1059+ * mpi3mr_map_data_buffer_dma - build dma descriptors for data
1060+ * buffers
1061+ * @mrioc: Adapter instance reference
1062+ * @drv_buf: buffer map descriptor
1063+ * @desc_count: Number of already consumed dma descriptors
1064+ *
1065+ * This function computes how many pre-allocated DMA descriptors
1066+ * are required for the given data buffer and if those number of
1067+ * descriptors are free, then setup the mapping of the scattered
1068+ * DMA address to the given data buffer, if the data direction
1069+ * of the buffer is DMA_TO_DEVICE then the actual data is copied to
1070+ * the DMA buffers
1071+ *
1072+ * Return: 0 on success, -1 on failure
1073+ */
1074+static int mpi3mr_map_data_buffer_dma(struct mpi3mr_ioc *mrioc,
1075+ struct mpi3mr_buf_map *drv_buf,
1076+ u16 desc_count)
1077+{
1078+ u16 i, needed_desc = drv_buf->kern_buf_len / MPI3MR_IOCTL_SGE_SIZE;
1079+ u32 buf_len = drv_buf->kern_buf_len, copied_len = 0;
1080+
1081+ if (drv_buf->kern_buf_len % MPI3MR_IOCTL_SGE_SIZE)
1082+ needed_desc++;
1083+ if ((needed_desc + desc_count) > MPI3MR_NUM_IOCTL_SGE) {
1084+ dprint_bsg_err(mrioc, "%s: DMA descriptor mapping error %d:%d:%d\n",
1085+ __func__, needed_desc, desc_count, MPI3MR_NUM_IOCTL_SGE);
1086+ return -1;
1087+ }
1088+ drv_buf->dma_desc = kzalloc(sizeof(*drv_buf->dma_desc) * needed_desc,
1089+ GFP_KERNEL);
1090+ if (!drv_buf->dma_desc)
1091+ return -1;
1092+ for (i = 0; i < needed_desc; i++, desc_count++) {
1093+ drv_buf->dma_desc[i].addr = mrioc->ioctl_sge[desc_count].addr;
1094+ drv_buf->dma_desc[i].dma_addr =
1095+ mrioc->ioctl_sge[desc_count].dma_addr;
1096+ if (buf_len < mrioc->ioctl_sge[desc_count].size)
1097+ drv_buf->dma_desc[i].size = buf_len;
1098+ else
1099+ drv_buf->dma_desc[i].size =
1100+ mrioc->ioctl_sge[desc_count].size;
1101+ buf_len -= drv_buf->dma_desc[i].size;
1102+ memset(drv_buf->dma_desc[i].addr, 0,
1103+ mrioc->ioctl_sge[desc_count].size);
1104+ if (drv_buf->data_dir == DMA_TO_DEVICE) {
1105+ memcpy(drv_buf->dma_desc[i].addr,
1106+ drv_buf->bsg_buf + copied_len,
1107+ drv_buf->dma_desc[i].size);
1108+ copied_len += drv_buf->dma_desc[i].size;
1109+ }
1110+ }
1111+ drv_buf->num_dma_desc = needed_desc;
1112+ return 0;
1113+}
9381114 /**
9391115 * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler
9401116 * @job: BSG job reference
941− * @reply_payload_rcv_len: length of payload recvd
9421117 *
9431118 * This function is the top level handler for MPI Pass through
9441119 * command, this does basic validation of the input data buffers,
@@ -954,10 +1129,9 @@ err_out: · 9 unmodified lines
9541129 * Return: 0 on success and proper error codes on failure
9551130 */
9561131
957−static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply_payload_rcv_len)
1132+static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
9581133 {
9591134 long rval = -EINVAL;
960−
9611135 struct mpi3mr_ioc *mrioc = NULL;
9621136 u8 *mpi_req = NULL, *sense_buff_k = NULL;
9631137 u8 mpi_msg_size = 0;
@@ -965,9 +1139,10 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 1 unmodified line
9651139 struct mpi3mr_bsg_mptcmd *karg;
9661140 struct mpi3mr_buf_entry *buf_entries = NULL;
9671141 struct mpi3mr_buf_map *drv_bufs = NULL, *drv_buf_iter = NULL;
968− u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0, din_cnt = 0, dout_cnt = 0;
969− u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF, sg_entries = 0;
970− u8 block_io = 0, resp_code = 0, nvme_fmt = 0;
1142+ u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0;
1143+ u8 din_cnt = 0, dout_cnt = 0;
1144+ u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF;
1145+ u8 block_io = 0, nvme_fmt = 0, resp_code = 0;
9711146 struct mpi3_request_header *mpi_header = NULL;
9721147 struct mpi3_status_reply_descriptor *status_desc;
9731148 struct mpi3_scsi_task_mgmt_request *tm_req;
@@ -979,6 +1154,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 5 unmodified lines
9791154 u32 din_size = 0, dout_size = 0;
9801155 u8 *din_buf = NULL, *dout_buf = NULL;
9811156 u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL;
1157+ u16 rmc_size = 0, desc_count = 0;
9821158
9831159 bsg_req = job->request;
9841160 karg = (struct mpi3mr_bsg_mptcmd *)&bsg_req->cmd.mptcmd;
@@ -987,6 +1163,12 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines
9871163 if (!mrioc)
9881164 return -ENODEV;
9891165
1166+ if (!mrioc->ioctl_sges_allocated) {
1167+ dprint_bsg_err(mrioc, "%s: DMA memory was not allocated\n",
1168+ __func__);
1169+ return -ENOMEM;
1170+ }
1171+
9901172 if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT)
9911173 karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT;
9921174
@@ -1027,26 +1209,13 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 34 unmodified lines
10271209
10281210 for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) {
10291211
1030− if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) {
1031− dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n",
1032− __func__);
1033− rval = -EINVAL;
1034− goto out;
1035− }
1036− if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) {
1037− dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n",
1038− __func__);
1039− rval = -EINVAL;
1040− goto out;
1041− }
1042−
10431212 switch (buf_entries->buf_type) {
10441213 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD:
10451214 sgl_iter = sgl_dout_iter;
10461215 sgl_dout_iter += buf_entries->buf_len;
10471216 drv_buf_iter->data_dir = DMA_TO_DEVICE;
10481217 is_rmcb = 1;
1049− if (count != 0)
1218+ if ((count != 0) || !buf_entries->buf_len)
10501219 invalid_be = 1;
10511220 break;
10521221 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP:
@@ -1054,7 +1223,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 1 unmodified line
10541223 sgl_din_iter += buf_entries->buf_len;
10551224 drv_buf_iter->data_dir = DMA_FROM_DEVICE;
10561225 is_rmrb = 1;
1057− if (count != 1 || !is_rmcb)
1226+ if (count != 1 || !is_rmcb || !buf_entries->buf_len)
10581227 invalid_be = 1;
10591228 break;
10601229 case MPI3MR_BSG_BUFTYPE_DATA_IN:
@@ -1062,7 +1231,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 1 unmodified line
10621231 sgl_din_iter += buf_entries->buf_len;
10631232 drv_buf_iter->data_dir = DMA_FROM_DEVICE;
10641233 din_cnt++;
1065− din_size += drv_buf_iter->bsg_buf_len;
1234+ din_size += buf_entries->buf_len;
10661235 if ((din_cnt > 1) && !is_rmcb)
10671236 invalid_be = 1;
10681237 break;
@@ -1071,7 +1240,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines
10711240 sgl_dout_iter += buf_entries->buf_len;
10721241 drv_buf_iter->data_dir = DMA_TO_DEVICE;
10731242 dout_cnt++;
1074− dout_size += drv_buf_iter->bsg_buf_len;
1243+ dout_size += buf_entries->buf_len;
10751244 if ((dout_cnt > 1) && !is_rmcb)
10761245 invalid_be = 1;
10771246 break;
@@ -1080,12 +1249,16 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines
10801249 sgl_din_iter += buf_entries->buf_len;
10811250 drv_buf_iter->data_dir = DMA_NONE;
10821251 mpirep_offset = count;
1252+ if (!buf_entries->buf_len)
1253+ invalid_be = 1;
10831254 break;
10841255 case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE:
10851256 sgl_iter = sgl_din_iter;
10861257 sgl_din_iter += buf_entries->buf_len;
10871258 drv_buf_iter->data_dir = DMA_NONE;
10881259 erb_offset = count;
1260+ if (!buf_entries->buf_len)
1261+ invalid_be = 1;
10891262 break;
10901263 case MPI3MR_BSG_BUFTYPE_MPI_REQUEST:
10911264 sgl_iter = sgl_dout_iter;
@@ -1112,21 +1285,31 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 20 unmodified lines
11121285 goto out;
11131286 }
11141287
1115− drv_buf_iter->bsg_buf = sgl_iter;
1116− drv_buf_iter->bsg_buf_len = buf_entries->buf_len;
1117−
1118− }
1119− if (!is_rmcb && (dout_cnt || din_cnt)) {
1120− sg_entries = dout_cnt + din_cnt;
1121− if (((mpi_msg_size) + (sg_entries *
1122− sizeof(struct mpi3_sge_common))) > MPI3MR_ADMIN_REQ_FRAME_SZ) {
1123− dprint_bsg_err(mrioc,
1124− "%s:%d: invalid message size passed\n",
1125− __func__, __LINE__);
1288+ if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) {
1289+ dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n",
1290+ __func__);
11261291 rval = -EINVAL;
11271292 goto out;
11281293 }
1294+ if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) {
1295+ dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n",
1296+ __func__);
1297+ rval = -EINVAL;
1298+ goto out;
1299+ }
1300+
1301+ drv_buf_iter->bsg_buf = sgl_iter;
1302+ drv_buf_iter->bsg_buf_len = buf_entries->buf_len;
11291303 }
1304+
1305+ if (is_rmcb && ((din_size + dout_size) > MPI3MR_MAX_APP_XFER_SIZE)) {
1306+ dprint_bsg_err(mrioc, "%s:%d: invalid data transfer size passed for function 0x%x din_size = %d, dout_size = %d\n",
1307+ __func__, __LINE__, mpi_header->function, din_size,
1308+ dout_size);
1309+ rval = -EINVAL;
1310+ goto out;
1311+ }
1312+
11301313 if (din_size > MPI3MR_MAX_APP_XFER_SIZE) {
11311314 dprint_bsg_err(mrioc,
11321315 "%s:%d: invalid data transfer size passed for function 0x%x din_size=%d\n",
@@ -1142,30 +1325,64 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 9 unmodified lines
11421325 goto out;
11431326 }
11441327
1328+ if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) {
1329+ if (din_size > MPI3MR_IOCTL_SGE_SIZE ||
1330+ dout_size > MPI3MR_IOCTL_SGE_SIZE) {
1331+ dprint_bsg_err(mrioc, "%s:%d: invalid message size passed:%d:%d:%d:%d\n",
1332+ __func__, __LINE__, din_cnt, dout_cnt, din_size,
1333+ dout_size);
1334+ rval = -EINVAL;
1335+ goto out;
1336+ }
1337+ }
1338+
11451339 drv_buf_iter = drv_bufs;
11461340 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
11471341 if (drv_buf_iter->data_dir == DMA_NONE)
11481342 continue;
11491343
11501344 drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len;
1151− if (is_rmcb && !count)
1152− drv_buf_iter->kern_buf_len += ((dout_cnt + din_cnt) *
1153− sizeof(struct mpi3_sge_common));
1154−
1155− if (!drv_buf_iter->kern_buf_len)
1156− continue;
1157−
1158− drv_buf_iter->kern_buf = dma_alloc_coherent(&mrioc->pdev->dev,
1159− drv_buf_iter->kern_buf_len, &drv_buf_iter->kern_buf_dma,
1160− GFP_KERNEL);
1161− if (!drv_buf_iter->kern_buf) {
1162− rval = -ENOMEM;
1163− goto out;
1164− }
1165− if (drv_buf_iter->data_dir == DMA_TO_DEVICE) {
1345+ if (is_rmcb && !count) {
1346+ drv_buf_iter->kern_buf_len =
1347+ mrioc->ioctl_chain_sge.size;
1348+ drv_buf_iter->kern_buf =
1349+ mrioc->ioctl_chain_sge.addr;
1350+ drv_buf_iter->kern_buf_dma =
1351+ mrioc->ioctl_chain_sge.dma_addr;
1352+ drv_buf_iter->dma_desc = NULL;
1353+ drv_buf_iter->num_dma_desc = 0;
1354+ memset(drv_buf_iter->kern_buf, 0,
1355+ drv_buf_iter->kern_buf_len);
11661356 tmplen = min(drv_buf_iter->kern_buf_len,
1167− drv_buf_iter->bsg_buf_len);
1357+ drv_buf_iter->bsg_buf_len);
1358+ rmc_size = tmplen;
11681359 memcpy(drv_buf_iter->kern_buf, drv_buf_iter->bsg_buf, tmplen);
1360+ } else if (is_rmrb && (count == 1)) {
1361+ drv_buf_iter->kern_buf_len =
1362+ mrioc->ioctl_resp_sge.size;
1363+ drv_buf_iter->kern_buf =
1364+ mrioc->ioctl_resp_sge.addr;
1365+ drv_buf_iter->kern_buf_dma =
1366+ mrioc->ioctl_resp_sge.dma_addr;
1367+ drv_buf_iter->dma_desc = NULL;
1368+ drv_buf_iter->num_dma_desc = 0;
1369+ memset(drv_buf_iter->kern_buf, 0,
1370+ drv_buf_iter->kern_buf_len);
1371+ tmplen = min(drv_buf_iter->kern_buf_len,
1372+ drv_buf_iter->bsg_buf_len);
1373+ drv_buf_iter->kern_buf_len = tmplen;
1374+ memset(drv_buf_iter->bsg_buf, 0,
1375+ drv_buf_iter->bsg_buf_len);
1376+ } else {
1377+ if (!drv_buf_iter->kern_buf_len)
1378+ continue;
1379+ if (mpi3mr_map_data_buffer_dma(mrioc, drv_buf_iter, desc_count)) {
1380+ rval = -ENOMEM;
1381+ dprint_bsg_err(mrioc, "%s:%d: mapping data buffers failed\n",
1382+ __func__, __LINE__);
1383+ goto out;
1384+ }
1385+ desc_count += drv_buf_iter->num_dma_desc;
11691386 }
11701387 }
11711388
@@ -1235,9 +1452,14 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 63 unmodified lines
12351452 goto out;
12361453 }
12371454 } else {
1238− mpi3mr_bsg_build_sgl(mpi_req, (mpi_msg_size),
1239− drv_bufs, bufcnt, is_rmcb, is_rmrb,
1240− (dout_cnt + din_cnt));
1455+ if (mpi3mr_bsg_build_sgl(mrioc, mpi_req, mpi_msg_size,
1456+ drv_bufs, bufcnt, is_rmcb, is_rmrb,
1457+ (dout_cnt + din_cnt))) {
1458+ dprint_bsg_err(mrioc, "%s: sgl build failed\n", __func__);
1459+ rval = -EAGAIN;
1460+ mutex_unlock(&mrioc->bsg_cmds.mutex);
1461+ goto out;
1462+ }
12411463 }
12421464
12431465 if (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_TASK_MGMT) {
@@ -1273,7 +1495,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 29 unmodified lines
12731495 if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
12741496 drv_buf_iter = &drv_bufs[0];
12751497 dprint_dump(drv_buf_iter->kern_buf,
1276− drv_buf_iter->kern_buf_len, "mpi3_mgmt_req");
1498+ rmc_size, "mpi3_mgmt_req");
12771499 }
12781500 }
12791501
@@ -1308,10 +1530,9 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 28 unmodified lines
13081530 MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
13091531 drv_buf_iter = &drv_bufs[0];
13101532 dprint_dump(drv_buf_iter->kern_buf,
1311− drv_buf_iter->kern_buf_len, "mpi3_mgmt_req");
1533+ rmc_size, "mpi3_mgmt_req");
13121534 }
13131535 }
1314−
13151536 if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) ||
13161537 (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO))
13171538 mpi3mr_issue_tm(mrioc,
@@ -1382,17 +1603,27 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 64 unmodified lines
13821603 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
13831604 if (drv_buf_iter->data_dir == DMA_NONE)
13841605 continue;
1385− if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) {
1386− tmplen = min(drv_buf_iter->kern_buf_len,
1387− drv_buf_iter->bsg_buf_len);
1606+ if ((count == 1) && is_rmrb) {
13881607 memcpy(drv_buf_iter->bsg_buf,
1389− drv_buf_iter->kern_buf, tmplen);
1608+ drv_buf_iter->kern_buf,
1609+ drv_buf_iter->kern_buf_len);
1610+ } else if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) {
1611+ tmplen = 0;
1612+ for (desc_count = 0;
1613+ desc_count < drv_buf_iter->num_dma_desc;
1614+ desc_count++) {
1615+ memcpy(((u8 *)drv_buf_iter->bsg_buf + tmplen),
1616+ drv_buf_iter->dma_desc[desc_count].addr,
1617+ drv_buf_iter->dma_desc[desc_count].size);
1618+ tmplen +=
1619+ drv_buf_iter->dma_desc[desc_count].size;
13901620 }
13911621 }
1622+ }
13921623
13931624 out_unlock:
13941625 if (din_buf) {
1395− *reply_payload_rcv_len =
1626+ job->reply_payload_rcv_len =
13961627 sg_copy_from_buffer(job->reply_payload.sg_list,
13971628 job->reply_payload.sg_cnt,
13981629 din_buf, job->reply_payload.payload_len);
@@ -1408,13 +1639,8 @@ out: · 9 unmodified lines
14081639 kfree(mpi_req);
14091640 if (drv_bufs) {
14101641 drv_buf_iter = drv_bufs;
1411− for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1412− if (drv_buf_iter->kern_buf && drv_buf_iter->kern_buf_dma)
1413− dma_free_coherent(&mrioc->pdev->dev,
1414− drv_buf_iter->kern_buf_len,
1415− drv_buf_iter->kern_buf,
1416− drv_buf_iter->kern_buf_dma);
1417− }
1642+ for (count = 0; count < bufcnt; count++, drv_buf_iter++)
1643+ kfree(drv_buf_iter->dma_desc);
14181644 kfree(drv_bufs);
14191645 }
14201646 kfree(bsg_reply_buf);
@@ -1473,7 +1699,7 @@ static int mpi3mr_bsg_request(struct bsg_job *job) · 52 unmodified lines
14731699 rval = mpi3mr_bsg_process_drv_cmds(job);
14741700 break;
14751701 case MPI3MR_MPT_CMD:
1476− rval = mpi3mr_bsg_process_mpt_cmds(job, &reply_payload_rcv_len);
1702+ rval = mpi3mr_bsg_process_mpt_cmds(job);
14771703 break;
14781704 default:
14791705 pr_err("%s: unsupported BSG command(0x%08x)\n",

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t