scsi: be2iscsi: switch to generic DMA API

Switch from the legacy PCI DMA API to the generic DMA API.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index c10aac4dbc5ee6a9138bff2e885e879af679afda..0a6972ee94d7e4c9d89b4497418f23881e5311ef 100644 (file)
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -520,7 +520,7 @@ int beiscsi_process_mcc_compl(struct be_ctrl_info *ctrl,
                 **/
                tag_mem = &ctrl->ptag_state[tag].tag_mem_state;
                if (tag_mem->size) {
-                       pci_free_consistent(ctrl->pdev, tag_mem->size,
+                       dma_free_coherent(&ctrl->pdev->dev, tag_mem->size,
                                        tag_mem->va, tag_mem->dma);
                        tag_mem->size = 0;
                }
@@ -1269,12 +1269,12 @@ int beiscsi_check_supported_fw(struct be_ctrl_info *ctrl,
        struct be_sge *sge = nonembedded_sgl(wrb);
        int status = 0;
 
-       nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev,
+       nonemb_cmd.va = dma_alloc_coherent(&ctrl->pdev->dev,
                                sizeof(struct be_mgmt_controller_attributes),
-                               &nonemb_cmd.dma);
+                               &nonemb_cmd.dma, GFP_KERNEL);
        if (nonemb_cmd.va == NULL) {
                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
-                           "BG_%d : pci_alloc_consistent failed in %s\n",
+                           "BG_%d : dma_alloc_coherent failed in %s\n",
                            __func__);
                return -ENOMEM;
        }
@@ -1314,7 +1314,7 @@ int beiscsi_check_supported_fw(struct be_ctrl_info *ctrl,
                            "BG_%d :  Failed in beiscsi_check_supported_fw\n");
        mutex_unlock(&ctrl->mbox_lock);
        if (nonemb_cmd.va)
-               pci_free_consistent(ctrl->pdev, nonemb_cmd.size,
+               dma_free_coherent(&ctrl->pdev->dev, nonemb_cmd.size,
                                    nonemb_cmd.va, nonemb_cmd.dma);
 
        return status;

diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 6dfdf9cee8a987b54377505d984cf0ae34ee1f6a..96b96e2ab91aff7b96b8b160e3e18bd0e0d6a537 100644 (file)
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -1071,9 +1071,9 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
        else
                req_memsize = sizeof(struct tcp_connect_and_offload_in_v1);
 
-       nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+       nonemb_cmd.va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
                                req_memsize,
-                               &nonemb_cmd.dma);
+                               &nonemb_cmd.dma, GFP_KERNEL);
        if (nonemb_cmd.va == NULL) {
 
                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
@@ -1091,7 +1091,7 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
                            "BS_%d : mgmt_open_connection Failed for cid=%d\n",
                            beiscsi_ep->ep_cid);
 
-               pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+               dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                                    nonemb_cmd.va, nonemb_cmd.dma);
                beiscsi_free_ep(beiscsi_ep);
                return -EAGAIN;
@@ -1104,8 +1104,9 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
                            "BS_%d : mgmt_open_connection Failed");
 
                if (ret != -EBUSY)
-                       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
-                                           nonemb_cmd.va, nonemb_cmd.dma);
+                       dma_free_coherent(&phba->ctrl.pdev->dev,
+                                       nonemb_cmd.size, nonemb_cmd.va,
+                                       nonemb_cmd.dma);
 
                beiscsi_free_ep(beiscsi_ep);
                return ret;
@@ -1118,7 +1119,7 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
        beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
                    "BS_%d : mgmt_open_connection Success\n");
 
-       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+       dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                            nonemb_cmd.va, nonemb_cmd.dma);
        return 0;
 }

diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index d544453aa466c4756cad62bec2819af8362e4874..5278fdc2c52d70480f5ae566f5fac1846c0ae856 100644 (file)
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -511,18 +511,9 @@ static int beiscsi_enable_pci(struct pci_dev *pcidev)
        }
 
        pci_set_master(pcidev);
-       ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
+       ret = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(64));
        if (ret) {
-               ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
-               if (ret) {
-                       dev_err(&pcidev->dev, "Could not set PCI DMA Mask\n");
-                       goto pci_region_release;
-               } else {
-                       ret = pci_set_consistent_dma_mask(pcidev,
-                                                         DMA_BIT_MASK(32));
-               }
-       } else {
-               ret = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(64));
+               ret = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32));
                if (ret) {
                        dev_err(&pcidev->dev, "Could not set PCI DMA Mask\n");
                        goto pci_region_release;
@@ -550,9 +541,8 @@ static int be_ctrl_init(struct beiscsi_hba *phba, struct pci_dev *pdev)
        if (status)
                return status;
        mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
-       mbox_mem_alloc->va = pci_alloc_consistent(pdev,
-                                                 mbox_mem_alloc->size,
-                                                 &mbox_mem_alloc->dma);
+       mbox_mem_alloc->va = dma_alloc_coherent(&pdev->dev,
+                       mbox_mem_alloc->size, &mbox_mem_alloc->dma, GFP_KERNEL);
        if (!mbox_mem_alloc->va) {
                beiscsi_unmap_pci_function(phba);
                return -ENOMEM;
@@ -2302,11 +2292,11 @@ static int hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task)
 
                /* Map addr only if there is data_count */
                if (dsp_value) {
-                       io_task->mtask_addr = pci_map_single(phba->pcidev,
+                       io_task->mtask_addr = dma_map_single(&phba->pcidev->dev,
                                                             task->data,
                                                             task->data_count,
-                                                            PCI_DMA_TODEVICE);
-                       if (pci_dma_mapping_error(phba->pcidev,
+                                                            DMA_TO_DEVICE);
+                       if (dma_mapping_error(&phba->pcidev->dev,
                                                  io_task->mtask_addr))
                                return -ENOMEM;
                        io_task->mtask_data_count = task->data_count;
@@ -2517,10 +2507,9 @@ static int beiscsi_alloc_mem(struct beiscsi_hba *phba)
                       BEISCSI_MAX_FRAGS_INIT);
                curr_alloc_size = min(be_max_phys_size * 1024, alloc_size);
                do {
-                       mem_arr->virtual_address = pci_alloc_consistent(
-                                                       phba->pcidev,
-                                                       curr_alloc_size,
-                                                       &bus_add);
+                       mem_arr->virtual_address =
+                               dma_alloc_coherent(&phba->pcidev->dev,
+                                       curr_alloc_size, &bus_add, GFP_KERNEL);
                        if (!mem_arr->virtual_address) {
                                if (curr_alloc_size <= BE_MIN_MEM_SIZE)
                                        goto free_mem;
@@ -2558,7 +2547,7 @@ free_mem:
        mem_descr->num_elements = j;
        while ((i) || (j)) {
                for (j = mem_descr->num_elements; j > 0; j--) {
-                       pci_free_consistent(phba->pcidev,
+                       dma_free_coherent(&phba->pcidev->dev,
                                            mem_descr->mem_array[j - 1].size,
                                            mem_descr->mem_array[j - 1].
                                            virtual_address,
@@ -3029,9 +3018,9 @@ static int beiscsi_create_eqs(struct beiscsi_hba *phba,
                eq = &phwi_context->be_eq[i].q;
                mem = &eq->dma_mem;
                phwi_context->be_eq[i].phba = phba;
-               eq_vaddress = pci_alloc_consistent(phba->pcidev,
+               eq_vaddress = dma_alloc_coherent(&phba->pcidev->dev,
                                                   num_eq_pages * PAGE_SIZE,
-                                                  &paddr);
+                                                  &paddr, GFP_KERNEL);
                if (!eq_vaddress) {
                        ret = -ENOMEM;
                        goto create_eq_error;
@@ -3067,7 +3056,7 @@ create_eq_error:
                eq = &phwi_context->be_eq[i].q;
                mem = &eq->dma_mem;
                if (mem->va)
-                       pci_free_consistent(phba->pcidev, num_eq_pages
+                       dma_free_coherent(&phba->pcidev->dev, num_eq_pages
                                            * PAGE_SIZE,
                                            mem->va, mem->dma);
        }
@@ -3095,9 +3084,9 @@ static int beiscsi_create_cqs(struct beiscsi_hba *phba,
                pbe_eq->cq = cq;
                pbe_eq->phba = phba;
                mem = &cq->dma_mem;
-               cq_vaddress = pci_alloc_consistent(phba->pcidev,
+               cq_vaddress = dma_alloc_coherent(&phba->pcidev->dev,
                                                   num_cq_pages * PAGE_SIZE,
-                                                  &paddr);
+                                                  &paddr, GFP_KERNEL);
                if (!cq_vaddress) {
                        ret = -ENOMEM;
                        goto create_cq_error;
@@ -3132,7 +3121,7 @@ create_cq_error:
                cq = &phwi_context->be_cq[i];
                mem = &cq->dma_mem;
                if (mem->va)
-                       pci_free_consistent(phba->pcidev, num_cq_pages
+                       dma_free_coherent(&phba->pcidev->dev, num_cq_pages
                                            * PAGE_SIZE,
                                            mem->va, mem->dma);
        }
@@ -3324,7 +3313,7 @@ static void be_queue_free(struct beiscsi_hba *phba, struct be_queue_info *q)
 {
        struct be_dma_mem *mem = &q->dma_mem;
        if (mem->va) {
-               pci_free_consistent(phba->pcidev, mem->size,
+               dma_free_coherent(&phba->pcidev->dev, mem->size,
                        mem->va, mem->dma);
                mem->va = NULL;
        }
@@ -3339,7 +3328,8 @@ static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
        q->len = len;
        q->entry_size = entry_size;
        mem->size = len * entry_size;
-       mem->va = pci_zalloc_consistent(phba->pcidev, mem->size, &mem->dma);
+       mem->va = dma_zalloc_coherent(&phba->pcidev->dev, mem->size, &mem->dma,
+                       GFP_KERNEL);
        if (!mem->va)
                return -ENOMEM;
        return 0;
@@ -3477,7 +3467,7 @@ static void be_mcc_queues_destroy(struct beiscsi_hba *phba)
                             &ctrl->ptag_state[tag].tag_state)) {
                        ptag_mem = &ctrl->ptag_state[tag].tag_mem_state;
                        if (ptag_mem->size) {
-                               pci_free_consistent(ctrl->pdev,
+                               dma_free_coherent(&ctrl->pdev->dev,
                                                    ptag_mem->size,
                                                    ptag_mem->va,
                                                    ptag_mem->dma);
@@ -3878,7 +3868,7 @@ static void beiscsi_free_mem(struct beiscsi_hba *phba)
        j = 0;
        for (i = 0; i < SE_MEM_MAX; i++) {
                for (j = mem_descr->num_elements; j > 0; j--) {
-                       pci_free_consistent(phba->pcidev,
+                       dma_free_coherent(&phba->pcidev->dev,
                          mem_descr->mem_array[j - 1].size,
                          mem_descr->mem_array[j - 1].virtual_address,
                          (unsigned long)mem_descr->mem_array[j - 1].
@@ -4253,10 +4243,10 @@ beiscsi_free_mgmt_task_handles(struct beiscsi_conn *beiscsi_conn,
        }
 
        if (io_task->mtask_addr) {
-               pci_unmap_single(phba->pcidev,
+               dma_unmap_single(&phba->pcidev->dev,
                                 io_task->mtask_addr,
                                 io_task->mtask_data_count,
-                                PCI_DMA_TODEVICE);
+                                DMA_TO_DEVICE);
                io_task->mtask_addr = 0;
        }
 }
@@ -4850,9 +4840,9 @@ static int beiscsi_bsg_request(struct bsg_job *job)
 
        switch (bsg_req->msgcode) {
        case ISCSI_BSG_HST_VENDOR:
-               nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+               nonemb_cmd.va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
                                        job->request_payload.payload_len,
-                                       &nonemb_cmd.dma);
+                                       &nonemb_cmd.dma, GFP_KERNEL);
                if (nonemb_cmd.va == NULL) {
                        beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                                    "BM_%d : Failed to allocate memory for "
@@ -4865,7 +4855,7 @@ static int beiscsi_bsg_request(struct bsg_job *job)
                        beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                                    "BM_%d : MBX Tag Allocation Failed\n");
 
-                       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                       dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                                            nonemb_cmd.va, nonemb_cmd.dma);
                        return -EAGAIN;
                }
@@ -4879,7 +4869,7 @@ static int beiscsi_bsg_request(struct bsg_job *job)
                if (!test_bit(BEISCSI_HBA_ONLINE, &phba->state)) {
                        clear_bit(MCC_TAG_STATE_RUNNING,
                                  &phba->ctrl.ptag_state[tag].tag_state);
-                       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                       dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                                            nonemb_cmd.va, nonemb_cmd.dma);
                        return -EIO;
                }
@@ -4896,7 +4886,7 @@ static int beiscsi_bsg_request(struct bsg_job *job)
                bsg_reply->result = status;
                bsg_job_done(job, bsg_reply->result,
                             bsg_reply->reply_payload_rcv_len);
-               pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+               dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                                    nonemb_cmd.va, nonemb_cmd.dma);
                if (status || extd_status) {
                        beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
@@ -5753,7 +5743,7 @@ free_twq:
        beiscsi_cleanup_port(phba);
        beiscsi_free_mem(phba);
 free_port:
-       pci_free_consistent(phba->pcidev,
+       dma_free_coherent(&phba->pcidev->dev,
                            phba->ctrl.mbox_mem_alloced.size,
                            phba->ctrl.mbox_mem_alloced.va,
                            phba->ctrl.mbox_mem_alloced.dma);
@@ -5797,7 +5787,7 @@ static void beiscsi_remove(struct pci_dev *pcidev)
 
        /* ctrl uninit */
        beiscsi_unmap_pci_function(phba);
-       pci_free_consistent(phba->pcidev,
+       dma_free_coherent(&phba->pcidev->dev,
                            phba->ctrl.mbox_mem_alloced.size,
                            phba->ctrl.mbox_mem_alloced.va,
                            phba->ctrl.mbox_mem_alloced.dma);

diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 8fdc07b6c686778b961311a6d69cbeb4763cde62..ca7b7bbc8371f4404d5ed23e1bb36ed85cd2c07a 100644 (file)
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -284,7 +284,7 @@ static int beiscsi_exec_nemb_cmd(struct beiscsi_hba *phba,
                return rc;
 
 free_cmd:
-       pci_free_consistent(ctrl->pdev, nonemb_cmd->size,
+       dma_free_coherent(&ctrl->pdev->dev, nonemb_cmd->size,
                            nonemb_cmd->va, nonemb_cmd->dma);
        return rc;
 }
@@ -293,7 +293,8 @@ static int beiscsi_prep_nemb_cmd(struct beiscsi_hba *phba,
                                 struct be_dma_mem *cmd,
                                 u8 subsystem, u8 opcode, u32 size)
 {
-       cmd->va = pci_zalloc_consistent(phba->ctrl.pdev, size, &cmd->dma);
+       cmd->va = dma_zalloc_coherent(&phba->ctrl.pdev->dev, size, &cmd->dma,
+                       GFP_KERNEL);
        if (!cmd->va) {
                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                            "BG_%d : Failed to allocate memory for if info\n");
@@ -315,7 +316,7 @@ static void __beiscsi_eq_delay_compl(struct beiscsi_hba *phba, unsigned int tag)
        __beiscsi_mcc_compl_status(phba, tag, NULL, NULL);
        tag_mem = &phba->ctrl.ptag_state[tag].tag_mem_state;
        if (tag_mem->size) {
-               pci_free_consistent(phba->pcidev, tag_mem->size,
+               dma_free_coherent(&phba->pcidev->dev, tag_mem->size,
                                    tag_mem->va, tag_mem->dma);
                tag_mem->size = 0;
        }
@@ -761,7 +762,7 @@ int beiscsi_if_get_info(struct beiscsi_hba *phba, int ip_type,
                                    "BG_%d : Memory Allocation Failure\n");
 
                                /* Free the DMA memory for the IOCTL issuing */
-                               pci_free_consistent(phba->ctrl.pdev,
+                               dma_free_coherent(&phba->ctrl.pdev->dev,
                                                    nonemb_cmd.size,
                                                    nonemb_cmd.va,
                                                    nonemb_cmd.dma);
@@ -780,7 +781,7 @@ int beiscsi_if_get_info(struct beiscsi_hba *phba, int ip_type,
                        ioctl_size += sizeof(struct be_cmd_req_hdr);
 
                        /* Free the previous allocated DMA memory */
-                       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                       dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                                            nonemb_cmd.va,
                                            nonemb_cmd.dma);
 
@@ -869,7 +870,7 @@ static void beiscsi_boot_process_compl(struct beiscsi_hba *phba,
                                      status);
                        boot_work = 0;
                }
-               pci_free_consistent(phba->ctrl.pdev, bs->nonemb_cmd.size,
+               dma_free_coherent(&phba->ctrl.pdev->dev, bs->nonemb_cmd.size,
                                    bs->nonemb_cmd.va, bs->nonemb_cmd.dma);
                bs->nonemb_cmd.va = NULL;
                break;
@@ -1012,9 +1013,10 @@ unsigned int beiscsi_boot_get_sinfo(struct beiscsi_hba *phba)
 
        nonemb_cmd = &phba->boot_struct.nonemb_cmd;
        nonemb_cmd->size = sizeof(struct be_cmd_get_session_resp);
-       nonemb_cmd->va = pci_alloc_consistent(phba->ctrl.pdev,
+       nonemb_cmd->va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
                                              nonemb_cmd->size,
-                                             &nonemb_cmd->dma);
+                                             &nonemb_cmd->dma,
+                                             GFP_KERNEL);
        if (!nonemb_cmd->va) {
                mutex_unlock(&ctrl->mbox_lock);
                return 0;
@@ -1508,9 +1510,10 @@ int beiscsi_mgmt_invalidate_icds(struct beiscsi_hba *phba,
                return -EINVAL;
 
        nonemb_cmd.size = sizeof(union be_invldt_cmds_params);
-       nonemb_cmd.va = pci_zalloc_consistent(phba->ctrl.pdev,
+       nonemb_cmd.va = dma_zalloc_coherent(&phba->ctrl.pdev->dev,
                                              nonemb_cmd.size,
-                                             &nonemb_cmd.dma);
+                                             &nonemb_cmd.dma,
+                                             GFP_KERNEL);
        if (!nonemb_cmd.va) {
                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_EH,
                            "BM_%d : invldt_cmds_params alloc failed\n");
@@ -1521,7 +1524,7 @@ int beiscsi_mgmt_invalidate_icds(struct beiscsi_hba *phba,
        wrb = alloc_mcc_wrb(phba, &tag);
        if (!wrb) {
                mutex_unlock(&ctrl->mbox_lock);
-               pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+               dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                                    nonemb_cmd.va, nonemb_cmd.dma);
                return -ENOMEM;
        }
@@ -1548,7 +1551,7 @@ int beiscsi_mgmt_invalidate_icds(struct beiscsi_hba *phba,
 
        rc = beiscsi_mccq_compl_wait(phba, tag, NULL, &nonemb_cmd);
        if (rc != -EBUSY)
-               pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+               dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
                                    nonemb_cmd.va, nonemb_cmd.dma);
        return rc;
 }