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
247 u32 kern_buf_len;247 u32 kern_buf_len;
248 dma_addr_t kern_buf_dma;248 dma_addr_t kern_buf_dma;
249 u8 data_dir;249 u8 data_dir;
250 u16 num_dma_desc;
251 struct dma_memory_desc *dma_desc;
250};252};
251 253
252/* IOC State definitions */254/* 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
563 return rval;563 return rval;
564}564}
565 565
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 */
578static 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
566/**594/**
567 * mpi3mr_bsg_build_sgl - SGL construction for MPI commands595 * mpi3mr_bsg_build_sgl - SGL construction for MPI commands
596 * @mrioc: Adapter instance reference
568 * @mpi_req: MPI request597 * @mpi_req: MPI request
569 * @sgl_offset: offset to start sgl in the MPI request598 * @sgl_offset: offset to start sgl in the MPI request
570 * @drv_bufs: DMA address of the buffers to be placed in sgl599 * @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
576 * This function places the DMA address of the given buffers in605 * This function places the DMA address of the given buffers in
577 * proper format as SGEs in the given MPI request.606 * proper format as SGEs in the given MPI request.
578 *607 *
579 * Return: Nothing608 * Return: 0 on success,-1 on failure
580 */609 */
581static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset,610static int mpi3mr_bsg_build_sgl(struct mpi3mr_ioc *mrioc, u8 *mpi_req,
582 struct mpi3mr_buf_map *drv_bufs, u8 bufcnt, u8 is_rmc,611 u32 sgl_offset, struct mpi3mr_buf_map *drv_bufs,
583 u8 is_rmr, u8 num_datasges)612 u8 bufcnt, u8 is_rmc, u8 is_rmr, u8 num_datasges)
584{613{
614 struct mpi3_request_header *mpi_header =
615 (struct mpi3_request_header *)mpi_req;
585 u8 *sgl = (mpi_req + sgl_offset), count = 0;616 u8 *sgl = (mpi_req + sgl_offset), count = 0;
586 struct mpi3_mgmt_passthrough_request *rmgmt_req =617 struct mpi3_mgmt_passthrough_request *rmgmt_req =
587 (struct mpi3_mgmt_passthrough_request *)mpi_req;618 (struct mpi3_mgmt_passthrough_request *)mpi_req;
588 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;619 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;
590 624
591 sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE |625 sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE |
592 MPI3_SGE_FLAGS_DLAS_SYSTEM | MPI3_SGE_FLAGS_END_OF_BUFFER;626 MPI3_SGE_FLAGS_DLAS_SYSTEM;
593 sgl_flags_last = sgl_flags | MPI3_SGE_FLAGS_END_OF_LIST;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);
594 633
595 if (is_rmc) {634 if (is_rmc) {
596 mpi3mr_add_sg_single(&rmgmt_req->command_sgl,635 mpi3mr_add_sg_single(&rmgmt_req->command_sgl,
597 sgl_flags_last, drv_buf_iter->kern_buf_len,636 sgl_flags_last, drv_buf_iter->kern_buf_len,
598 drv_buf_iter->kern_buf_dma);637 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;
600 drv_buf_iter++;647 drv_buf_iter++;
601 count++;648 count++;
602 if (is_rmr) {649 if (is_rmr) {
@@ -608,23 +655,95 @@ static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset, · 5 unmodified lines
608 } else655 } else
609 mpi3mr_build_zero_len_sge(656 mpi3mr_build_zero_len_sge(
610 &rmgmt_req->response_sgl);657 &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;
611 }669 }
612 if (!num_datasges) {670 if (!num_datasges) {
613 mpi3mr_build_zero_len_sge(sgl);671 mpi3mr_build_zero_len_sge(sgl);
614 return;672 return 0;
615 }673 }
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
690build_sges:
616 for (; count < bufcnt; count++, drv_buf_iter++) {691 for (; count < bufcnt; count++, drv_buf_iter++) {
617 if (drv_buf_iter->data_dir == DMA_NONE)692 if (drv_buf_iter->data_dir == DMA_NONE)
618 continue;693 continue;
619 if (num_datasges == 1 || !is_rmc)694 if (!drv_buf_iter->num_dma_desc) {
620 mpi3mr_add_sg_single(sgl, sgl_flags_last,695 if (chain_used && !available_sges)
621 drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma);696 return -1;
622 else697 if (!chain_used && (available_sges == 1) &&
623 mpi3mr_add_sg_single(sgl, sgl_flags,698 (sges_needed > 1))
624 drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma);699 goto setup_chain;
625 sgl += sizeof(struct mpi3_sge_common);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 }
626 num_datasges--;731 num_datasges--;
732 i = 0;
627 }733 }
734 return 0;
735
736setup_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;
628}747}
629 748
630/**749/**
@@ -935,10 +1054,66 @@ err_out: · 304 unmodified lines
935 }1054 }
936 return -1;1055 return -1;
937}1056}
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 */
1074static 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}
938/**1114/**
939 * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler1115 * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler
940 * @job: BSG job reference1116 * @job: BSG job reference
941 * @reply_payload_rcv_len: length of payload recvd
942 *1117 *
943 * This function is the top level handler for MPI Pass through1118 * This function is the top level handler for MPI Pass through
944 * command, this does basic validation of the input data buffers,1119 * command, this does basic validation of the input data buffers,
@@ -954,10 +1129,9 @@ err_out: · 9 unmodified lines
954 * Return: 0 on success and proper error codes on failure1129 * Return: 0 on success and proper error codes on failure
955 */1130 */
956 1131
957static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply_payload_rcv_len)1132static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
958{1133{
959 long rval = -EINVAL;1134 long rval = -EINVAL;
960
961 struct mpi3mr_ioc *mrioc = NULL;1135 struct mpi3mr_ioc *mrioc = NULL;
962 u8 *mpi_req = NULL, *sense_buff_k = NULL;1136 u8 *mpi_req = NULL, *sense_buff_k = NULL;
963 u8 mpi_msg_size = 0;1137 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
965 struct mpi3mr_bsg_mptcmd *karg;1139 struct mpi3mr_bsg_mptcmd *karg;
966 struct mpi3mr_buf_entry *buf_entries = NULL;1140 struct mpi3mr_buf_entry *buf_entries = NULL;
967 struct mpi3mr_buf_map *drv_bufs = NULL, *drv_buf_iter = NULL;1141 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;1142 u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0;
969 u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF, sg_entries = 0;1143 u8 din_cnt = 0, dout_cnt = 0;
970 u8 block_io = 0, resp_code = 0, nvme_fmt = 0;1144 u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF;
1145 u8 block_io = 0, nvme_fmt = 0, resp_code = 0;
971 struct mpi3_request_header *mpi_header = NULL;1146 struct mpi3_request_header *mpi_header = NULL;
972 struct mpi3_status_reply_descriptor *status_desc;1147 struct mpi3_status_reply_descriptor *status_desc;
973 struct mpi3_scsi_task_mgmt_request *tm_req;1148 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
979 u32 din_size = 0, dout_size = 0;1154 u32 din_size = 0, dout_size = 0;
980 u8 *din_buf = NULL, *dout_buf = NULL;1155 u8 *din_buf = NULL, *dout_buf = NULL;
981 u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL;1156 u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL;
1157 u16 rmc_size = 0, desc_count = 0;
982 1158
983 bsg_req = job->request;1159 bsg_req = job->request;
984 karg = (struct mpi3mr_bsg_mptcmd *)&bsg_req->cmd.mptcmd;1160 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
987 if (!mrioc)1163 if (!mrioc)
988 return -ENODEV;1164 return -ENODEV;
989 1165
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
990 if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT)1172 if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT)
991 karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT;1173 karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT;
992 1174
@@ -1027,26 +1209,13 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 34 unmodified lines
1027 1209
1028 for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) {1210 for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) {
1029 1211
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
1043 switch (buf_entries->buf_type) {1212 switch (buf_entries->buf_type) {
1044 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD:1213 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD:
1045 sgl_iter = sgl_dout_iter;1214 sgl_iter = sgl_dout_iter;
1046 sgl_dout_iter += buf_entries->buf_len;1215 sgl_dout_iter += buf_entries->buf_len;
1047 drv_buf_iter->data_dir = DMA_TO_DEVICE;1216 drv_buf_iter->data_dir = DMA_TO_DEVICE;
1048 is_rmcb = 1;1217 is_rmcb = 1;
1049 if (count != 0)1218 if ((count != 0) || !buf_entries->buf_len)
1050 invalid_be = 1;1219 invalid_be = 1;
1051 break;1220 break;
1052 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP:1221 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
1054 sgl_din_iter += buf_entries->buf_len;1223 sgl_din_iter += buf_entries->buf_len;
1055 drv_buf_iter->data_dir = DMA_FROM_DEVICE;1224 drv_buf_iter->data_dir = DMA_FROM_DEVICE;
1056 is_rmrb = 1;1225 is_rmrb = 1;
1057 if (count != 1 || !is_rmcb)1226 if (count != 1 || !is_rmcb || !buf_entries->buf_len)
1058 invalid_be = 1;1227 invalid_be = 1;
1059 break;1228 break;
1060 case MPI3MR_BSG_BUFTYPE_DATA_IN:1229 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
1062 sgl_din_iter += buf_entries->buf_len;1231 sgl_din_iter += buf_entries->buf_len;
1063 drv_buf_iter->data_dir = DMA_FROM_DEVICE;1232 drv_buf_iter->data_dir = DMA_FROM_DEVICE;
1064 din_cnt++;1233 din_cnt++;
1065 din_size += drv_buf_iter->bsg_buf_len;1234 din_size += buf_entries->buf_len;
1066 if ((din_cnt > 1) && !is_rmcb)1235 if ((din_cnt > 1) && !is_rmcb)
1067 invalid_be = 1;1236 invalid_be = 1;
1068 break;1237 break;
@@ -1071,7 +1240,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines
1071 sgl_dout_iter += buf_entries->buf_len;1240 sgl_dout_iter += buf_entries->buf_len;
1072 drv_buf_iter->data_dir = DMA_TO_DEVICE;1241 drv_buf_iter->data_dir = DMA_TO_DEVICE;
1073 dout_cnt++;1242 dout_cnt++;
1074 dout_size += drv_buf_iter->bsg_buf_len;1243 dout_size += buf_entries->buf_len;
1075 if ((dout_cnt > 1) && !is_rmcb)1244 if ((dout_cnt > 1) && !is_rmcb)
1076 invalid_be = 1;1245 invalid_be = 1;
1077 break;1246 break;
@@ -1080,12 +1249,16 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 2 unmodified lines
1080 sgl_din_iter += buf_entries->buf_len;1249 sgl_din_iter += buf_entries->buf_len;
1081 drv_buf_iter->data_dir = DMA_NONE;1250 drv_buf_iter->data_dir = DMA_NONE;
1082 mpirep_offset = count;1251 mpirep_offset = count;
1252 if (!buf_entries->buf_len)
1253 invalid_be = 1;
1083 break;1254 break;
1084 case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE:1255 case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE:
1085 sgl_iter = sgl_din_iter;1256 sgl_iter = sgl_din_iter;
1086 sgl_din_iter += buf_entries->buf_len;1257 sgl_din_iter += buf_entries->buf_len;
1087 drv_buf_iter->data_dir = DMA_NONE;1258 drv_buf_iter->data_dir = DMA_NONE;
1088 erb_offset = count;1259 erb_offset = count;
1260 if (!buf_entries->buf_len)
1261 invalid_be = 1;
1089 break;1262 break;
1090 case MPI3MR_BSG_BUFTYPE_MPI_REQUEST:1263 case MPI3MR_BSG_BUFTYPE_MPI_REQUEST:
1091 sgl_iter = sgl_dout_iter;1264 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
1112 goto out;1285 goto out;
1113 }1286 }
1114 1287
1115 drv_buf_iter->bsg_buf = sgl_iter;1288 if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) {
1116 drv_buf_iter->bsg_buf_len = buf_entries->buf_len;1289 dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n",
1117 1290 __func__);
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__);
1126 rval = -EINVAL;1291 rval = -EINVAL;
1127 goto out;1292 goto out;
1128 }1293 }
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;
1129 }1303 }
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
1130 if (din_size > MPI3MR_MAX_APP_XFER_SIZE) {1313 if (din_size > MPI3MR_MAX_APP_XFER_SIZE) {
1131 dprint_bsg_err(mrioc,1314 dprint_bsg_err(mrioc,
1132 "%s:%d: invalid data transfer size passed for function 0x%x din_size=%d\n",1315 "%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
1142 goto out;1325 goto out;
1143 }1326 }
1144 1327
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
1145 drv_buf_iter = drv_bufs;1339 drv_buf_iter = drv_bufs;
1146 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {1340 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1147 if (drv_buf_iter->data_dir == DMA_NONE)1341 if (drv_buf_iter->data_dir == DMA_NONE)
1148 continue;1342 continue;
1149 1343
1150 drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len;1344 drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len;
1151 if (is_rmcb && !count)1345 if (is_rmcb && !count) {
1152 drv_buf_iter->kern_buf_len += ((dout_cnt + din_cnt) *1346 drv_buf_iter->kern_buf_len =
1153 sizeof(struct mpi3_sge_common));1347 mrioc->ioctl_chain_sge.size;
1154 1348 drv_buf_iter->kern_buf =
1155 if (!drv_buf_iter->kern_buf_len)1349 mrioc->ioctl_chain_sge.addr;
1156 continue;1350 drv_buf_iter->kern_buf_dma =
1157 1351 mrioc->ioctl_chain_sge.dma_addr;
1158 drv_buf_iter->kern_buf = dma_alloc_coherent(&mrioc->pdev->dev,1352 drv_buf_iter->dma_desc = NULL;
1159 drv_buf_iter->kern_buf_len, &drv_buf_iter->kern_buf_dma,1353 drv_buf_iter->num_dma_desc = 0;
1160 GFP_KERNEL);1354 memset(drv_buf_iter->kern_buf, 0,
1161 if (!drv_buf_iter->kern_buf) {1355 drv_buf_iter->kern_buf_len);
1162 rval = -ENOMEM;
1163 goto out;
1164 }
1165 if (drv_buf_iter->data_dir == DMA_TO_DEVICE) {
1166 tmplen = min(drv_buf_iter->kern_buf_len,1356 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;
1168 memcpy(drv_buf_iter->kern_buf, drv_buf_iter->bsg_buf, tmplen);1359 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;
1169 }1386 }
1170 }1387 }
1171 1388
@@ -1235,9 +1452,14 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 63 unmodified lines
1235 goto out;1452 goto out;
1236 }1453 }
1237 } else {1454 } else {
1238 mpi3mr_bsg_build_sgl(mpi_req, (mpi_msg_size),1455 if (mpi3mr_bsg_build_sgl(mrioc, mpi_req, mpi_msg_size,
1239 drv_bufs, bufcnt, is_rmcb, is_rmrb,1456 drv_bufs, bufcnt, is_rmcb, is_rmrb,
1240 (dout_cnt + din_cnt));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 }
1241 }1463 }
1242 1464
1243 if (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_TASK_MGMT) {1465 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
1273 if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {1495 if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
1274 drv_buf_iter = &drv_bufs[0];1496 drv_buf_iter = &drv_bufs[0];
1275 dprint_dump(drv_buf_iter->kern_buf,1497 dprint_dump(drv_buf_iter->kern_buf,
1276 drv_buf_iter->kern_buf_len, "mpi3_mgmt_req");1498 rmc_size, "mpi3_mgmt_req");
1277 }1499 }
1278 }1500 }
1279 1501
@@ -1308,10 +1530,9 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply · 28 unmodified lines
1308 MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {1530 MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
1309 drv_buf_iter = &drv_bufs[0];1531 drv_buf_iter = &drv_bufs[0];
1310 dprint_dump(drv_buf_iter->kern_buf,1532 dprint_dump(drv_buf_iter->kern_buf,
1311 drv_buf_iter->kern_buf_len, "mpi3_mgmt_req");1533 rmc_size, "mpi3_mgmt_req");
1312 }1534 }
1313 }1535 }
1314
1315 if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) ||1536 if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) ||
1316 (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO))1537 (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO))
1317 mpi3mr_issue_tm(mrioc,1538 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
1382 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {1603 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1383 if (drv_buf_iter->data_dir == DMA_NONE)1604 if (drv_buf_iter->data_dir == DMA_NONE)
1384 continue;1605 continue;
1385 if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) {1606 if ((count == 1) && is_rmrb) {
1386 tmplen = min(drv_buf_iter->kern_buf_len,
1387 drv_buf_iter->bsg_buf_len);
1388 memcpy(drv_buf_iter->bsg_buf,1607 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;
1390 }1620 }
1391 }1621 }
1622 }
1392 1623
1393out_unlock:1624out_unlock:
1394 if (din_buf) {1625 if (din_buf) {
1395 *reply_payload_rcv_len =1626 job->reply_payload_rcv_len =
1396 sg_copy_from_buffer(job->reply_payload.sg_list,1627 sg_copy_from_buffer(job->reply_payload.sg_list,
1397 job->reply_payload.sg_cnt,1628 job->reply_payload.sg_cnt,
1398 din_buf, job->reply_payload.payload_len);1629 din_buf, job->reply_payload.payload_len);
@@ -1408,13 +1639,8 @@ out: · 9 unmodified lines
1408 kfree(mpi_req);1639 kfree(mpi_req);
1409 if (drv_bufs) {1640 if (drv_bufs) {
1410 drv_buf_iter = drv_bufs;1641 drv_buf_iter = drv_bufs;
1411 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {1642 for (count = 0; count < bufcnt; count++, drv_buf_iter++)
1412 if (drv_buf_iter->kern_buf && drv_buf_iter->kern_buf_dma)1643 kfree(drv_buf_iter->dma_desc);
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 }
1418 kfree(drv_bufs);1644 kfree(drv_bufs);
1419 }1645 }
1420 kfree(bsg_reply_buf);1646 kfree(bsg_reply_buf);
@@ -1473,7 +1699,7 @@ static int mpi3mr_bsg_request(struct bsg_job *job) · 52 unmodified lines
1473 rval = mpi3mr_bsg_process_drv_cmds(job);1699 rval = mpi3mr_bsg_process_drv_cmds(job);
1474 break;1700 break;
1475 case MPI3MR_MPT_CMD:1701 case MPI3MR_MPT_CMD:
1476 rval = mpi3mr_bsg_process_mpt_cmds(job, &reply_payload_rcv_len);1702 rval = mpi3mr_bsg_process_mpt_cmds(job);
1477 break;1703 break;
1478 default:1704 default:
1479 pr_err("%s: unsupported BSG command(0x%08x)\n",1705 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