The driver acquires the required SGLs from the pre-allocated pool.
Unified · Split
| @@ -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 */ |
| @@ -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 | */ | ||
| 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 | |||
| 566 | /** | 594 | /** |
| 567 | * mpi3mr_bsg_build_sgl - SGL construction for MPI commands | 595 | * mpi3mr_bsg_build_sgl - SGL construction for MPI commands |
| 596 | * @mrioc: Adapter instance reference | ||
| 568 | * @mpi_req: MPI request | 597 | * @mpi_req: MPI request |
| 569 | * @sgl_offset: offset to start sgl in the MPI request | 598 | * @sgl_offset: offset to start sgl in the MPI request |
| 570 | * @drv_bufs: DMA address of the buffers to be placed in sgl | 599 | * @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 in | 605 | * 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: Nothing | 608 | * Return: 0 on success,-1 on failure |
| 580 | */ | 609 | */ |
| 581 | static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset, | 610 | static 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 | } else | 655 | } 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 | |||
| 690 | build_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 | else | 697 | 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 | |||
| 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; | ||
| 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 | */ | ||
| 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 | } | ||
| 938 | /** | 1114 | /** |
| 939 | * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler | 1115 | * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler |
| 940 | * @job: BSG job reference | 1116 | * @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 through | 1118 | * 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 failure | 1129 | * Return: 0 on success and proper error codes on failure |
| 955 | */ | 1130 | */ |
| 956 | 1131 | ||
| 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) |
| 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 | ||
| 1393 | out_unlock: | 1624 | out_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", |