scsi: megaraid: Remove pci-dma-compat wrapper API

The legacy API wrappers in include/linux/pci-dma-compat.h should go away as
they create unnecessary midlayering for include/linux/dma-mapping.h API.
Instead use dma-mapping.h API directly.

The patch has been generated with the coccinelle script below.  And has
been hand modified to replace each GFP_ with a correct flag depending upon
the context.  Compile tested.

@@@@
- PCI_DMA_BIDIRECTIONAL
+ DMA_BIDIRECTIONAL

@@@@
- PCI_DMA_TODEVICE
+ DMA_TO_DEVICE

@@@@
- PCI_DMA_FROMDEVICE
+ DMA_FROM_DEVICE

@@@@
- PCI_DMA_NONE
+ DMA_NONE

@@ expression E1, E2, E3; @@
- pci_alloc_consistent(E1, E2, E3)
+ dma_alloc_coherent(&E1->dev, E2, E3, GFP_)

@@ expression E1, E2, E3; @@
- pci_zalloc_consistent(E1, E2, E3)
+ dma_alloc_coherent(&E1->dev, E2, E3, GFP_)

@@ expression E1, E2, E3, E4; @@
- pci_free_consistent(E1, E2, E3, E4)
+ dma_free_coherent(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_map_single(E1, E2, E3, E4)
+ dma_map_single(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_unmap_single(E1, E2, E3, E4)
+ dma_unmap_single(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4, E5; @@
- pci_map_page(E1, E2, E3, E4, E5)
+ dma_map_page(&E1->dev, E2, E3, E4, E5)

@@ expression E1, E2, E3, E4; @@
- pci_unmap_page(E1, E2, E3, E4)
+ dma_unmap_page(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_map_sg(E1, E2, E3, E4)
+ dma_map_sg(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_unmap_sg(E1, E2, E3, E4)
+ dma_unmap_sg(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_dma_sync_single_for_cpu(E1, E2, E3, E4)
+ dma_sync_single_for_cpu(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_dma_sync_single_for_device(E1, E2, E3, E4)
+ dma_sync_single_for_device(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_dma_sync_sg_for_cpu(E1, E2, E3, E4)
+ dma_sync_sg_for_cpu(&E1->dev, E2, E3, E4)

@@ expression E1, E2, E3, E4; @@
- pci_dma_sync_sg_for_device(E1, E2, E3, E4)
+ dma_sync_sg_for_device(&E1->dev, E2, E3, E4)

@@ expression E1, E2; @@
- pci_dma_mapping_error(E1, E2)
+ dma_mapping_error(&E1->dev, E2)

@@ expression E1, E2; @@
- pci_set_consistent_dma_mask(E1, E2)
+ dma_set_coherent_mask(&E1->dev, E2)

@@ expression E1, E2; @@
- pci_set_dma_mask(E1, E2)
+ dma_set_mask(&E1->dev, E2)

Link: https://lore.kernel.org/r/635cfc08b83a041708ee6afbc430087416f2605c.1596045683.git.usuraj35@gmail.com
Signed-off-by: Suraj Upadhyay <usuraj35@gmail.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 0484ee52ae8023e2be9bc06f6f47fb55999fd612..9276fed527faa780d99e3f974fae797a744e3679 100644 (file)
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -133,8 +133,10 @@ mega_setup_mailbox(adapter_t *adapter)
 {
        unsigned long   align;
 
-       adapter->una_mbox64 = pci_alloc_consistent(adapter->dev,
-                       sizeof(mbox64_t), &adapter->una_mbox64_dma);
+       adapter->una_mbox64 = dma_alloc_coherent(&adapter->dev->dev,
+                                                sizeof(mbox64_t),
+                                                &adapter->una_mbox64_dma,
+                                                GFP_KERNEL);
 
        if( !adapter->una_mbox64 ) return -1;
                
@@ -222,8 +224,9 @@ mega_query_adapter(adapter_t *adapter)
                mraid_inquiry           *inq;
                dma_addr_t              dma_handle;
 
-               ext_inq = pci_alloc_consistent(adapter->dev,
-                               sizeof(mraid_ext_inquiry), &dma_handle);
+               ext_inq = dma_alloc_coherent(&adapter->dev->dev,
+                                            sizeof(mraid_ext_inquiry),
+                                            &dma_handle, GFP_KERNEL);
 
                if( ext_inq == NULL ) return -1;
 
@@ -243,8 +246,9 @@ mega_query_adapter(adapter_t *adapter)
                mega_8_to_40ld(inq, inquiry3,
                                (mega_product_info *)&adapter->product_info);
 
-               pci_free_consistent(adapter->dev, sizeof(mraid_ext_inquiry),
-                               ext_inq, dma_handle);
+               dma_free_coherent(&adapter->dev->dev,
+                                 sizeof(mraid_ext_inquiry), ext_inq,
+                                 dma_handle);
 
        } else {                /*adapter supports 40ld */
                adapter->flag |= BOARD_40LD;
@@ -253,9 +257,10 @@ mega_query_adapter(adapter_t *adapter)
                 * get product_info, which is static information and will be
                 * unchanged
                 */
-               prod_info_dma_handle = pci_map_single(adapter->dev, (void *)
-                               &adapter->product_info,
-                               sizeof(mega_product_info), PCI_DMA_FROMDEVICE);
+               prod_info_dma_handle = dma_map_single(&adapter->dev->dev,
+                                                     (void *)&adapter->product_info,
+                                                     sizeof(mega_product_info),
+                                                     DMA_FROM_DEVICE);
 
                mbox->m_out.xferaddr = prod_info_dma_handle;
 
@@ -267,8 +272,8 @@ mega_query_adapter(adapter_t *adapter)
                                "Product_info cmd failed with error: %d\n",
                                retval);
 
-               pci_unmap_single(adapter->dev, prod_info_dma_handle,
-                               sizeof(mega_product_info), PCI_DMA_FROMDEVICE);
+               dma_unmap_single(&adapter->dev->dev, prod_info_dma_handle,
+                                sizeof(mega_product_info), DMA_FROM_DEVICE);
        }
 
 
@@ -645,7 +650,7 @@ mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
                        scb->raw_mbox[2] = MEGA_RESERVATION_STATUS;
                        scb->raw_mbox[3] = ldrv_num;
 
-                       scb->dma_direction = PCI_DMA_NONE;
+                       scb->dma_direction = DMA_NONE;
 
                        return scb;
 #else
@@ -709,7 +714,7 @@ mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
                                mbox->m_out.cmd = MEGA_MBOXCMD_PASSTHRU;
                        }
 
-                       scb->dma_direction = PCI_DMA_FROMDEVICE;
+                       scb->dma_direction = DMA_FROM_DEVICE;
 
                        pthru->numsgelements = mega_build_sglist(adapter, scb,
                                &pthru->dataxferaddr, &pthru->dataxferlen);
@@ -839,10 +844,10 @@ mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
                         * If it is a read command
                         */
                        if( (*cmd->cmnd & 0x0F) == 0x08 ) {
-                               scb->dma_direction = PCI_DMA_FROMDEVICE;
+                               scb->dma_direction = DMA_FROM_DEVICE;
                        }
                        else {
-                               scb->dma_direction = PCI_DMA_TODEVICE;
+                               scb->dma_direction = DMA_TO_DEVICE;
                        }
 
                        /* Calculate Scatter-Gather info */
@@ -877,7 +882,7 @@ mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
 
                        scb->raw_mbox[3] = ldrv_num;
 
-                       scb->dma_direction = PCI_DMA_NONE;
+                       scb->dma_direction = DMA_NONE;
 
                        return scb;
 #endif
@@ -971,7 +976,7 @@ mega_prepare_passthru(adapter_t *adapter, scb_t *scb, struct scsi_cmnd *cmd,
        memcpy(pthru->cdb, cmd->cmnd, cmd->cmd_len);
 
        /* Not sure about the direction */
-       scb->dma_direction = PCI_DMA_BIDIRECTIONAL;
+       scb->dma_direction = DMA_BIDIRECTIONAL;
 
        /* Special Code for Handling READ_CAPA/ INQ using bounce buffers */
        switch (cmd->cmnd[0]) {
@@ -1035,7 +1040,7 @@ mega_prepare_extpassthru(adapter_t *adapter, scb_t *scb,
        memcpy(epthru->cdb, cmd->cmnd, cmd->cmd_len);
 
        /* Not sure about the direction */
-       scb->dma_direction = PCI_DMA_BIDIRECTIONAL;
+       scb->dma_direction = DMA_BIDIRECTIONAL;
 
        switch(cmd->cmnd[0]) {
        case INQUIRY:
@@ -1813,25 +1818,25 @@ mega_free_sgl(adapter_t *adapter)
                scb = &adapter->scb_list[i];
 
                if( scb->sgl64 ) {
-                       pci_free_consistent(adapter->dev,
-                               sizeof(mega_sgl64) * adapter->sglen,
-                               scb->sgl64,
-                               scb->sgl_dma_addr);
+                       dma_free_coherent(&adapter->dev->dev,
+                                         sizeof(mega_sgl64) * adapter->sglen,
+                                         scb->sgl64, scb->sgl_dma_addr);
 
                        scb->sgl64 = NULL;
                }
 
                if( scb->pthru ) {
-                       pci_free_consistent(adapter->dev, sizeof(mega_passthru),
-                               scb->pthru, scb->pthru_dma_addr);
+                       dma_free_coherent(&adapter->dev->dev,
+                                         sizeof(mega_passthru), scb->pthru,
+                                         scb->pthru_dma_addr);
 
                        scb->pthru = NULL;
                }
 
                if( scb->epthru ) {
-                       pci_free_consistent(adapter->dev,
-                               sizeof(mega_ext_passthru),
-                               scb->epthru, scb->epthru_dma_addr);
+                       dma_free_coherent(&adapter->dev->dev,
+                                         sizeof(mega_ext_passthru),
+                                         scb->epthru, scb->epthru_dma_addr);
 
                        scb->epthru = NULL;
                }
@@ -2004,7 +2009,7 @@ make_local_pdev(adapter_t *adapter, struct pci_dev **pdev)
 
        memcpy(*pdev, adapter->dev, sizeof(struct pci_dev));
 
-       if( pci_set_dma_mask(*pdev, DMA_BIT_MASK(32)) != 0 ) {
+       if (dma_set_mask(&(*pdev)->dev, DMA_BIT_MASK(32)) != 0) {
                kfree(*pdev);
                return -1;
        }
@@ -2028,14 +2033,16 @@ free_local_pdev(struct pci_dev *pdev)
 static inline void *
 mega_allocate_inquiry(dma_addr_t *dma_handle, struct pci_dev *pdev)
 {
-       return pci_alloc_consistent(pdev, sizeof(mega_inquiry3), dma_handle);
+       return dma_alloc_coherent(&pdev->dev, sizeof(mega_inquiry3),
+                                 dma_handle, GFP_KERNEL);
 }
 
 
 static inline void
 mega_free_inquiry(void *inquiry, dma_addr_t dma_handle, struct pci_dev *pdev)
 {
-       pci_free_consistent(pdev, sizeof(mega_inquiry3), inquiry, dma_handle);
+       dma_free_coherent(&pdev->dev, sizeof(mega_inquiry3), inquiry,
+                         dma_handle);
 }
 
 
@@ -2349,7 +2356,8 @@ proc_show_pdrv(struct seq_file *m, adapter_t *adapter, int channel)
        }
 
 
-       scsi_inq = pci_alloc_consistent(pdev, 256, &scsi_inq_dma_handle);
+       scsi_inq = dma_alloc_coherent(&pdev->dev, 256, &scsi_inq_dma_handle,
+                                     GFP_KERNEL);
        if( scsi_inq == NULL ) {
                seq_puts(m, "memory not available for scsi inq.\n");
                goto free_inquiry;
@@ -2422,7 +2430,7 @@ proc_show_pdrv(struct seq_file *m, adapter_t *adapter, int channel)
        }
 
 free_pci:
-       pci_free_consistent(pdev, 256, scsi_inq, scsi_inq_dma_handle);
+       dma_free_coherent(&pdev->dev, 256, scsi_inq, scsi_inq_dma_handle);
 free_inquiry:
        mega_free_inquiry(inquiry, dma_handle, pdev);
 free_pdev:
@@ -2542,8 +2550,8 @@ proc_show_rdrv(struct seq_file *m, adapter_t *adapter, int start, int end )
                        raid_inq.logdrv_info.num_ldrv;
        }
 
-       disk_array = pci_alloc_consistent(pdev, array_sz,
-                       &disk_array_dma_handle);
+       disk_array = dma_alloc_coherent(&pdev->dev, array_sz,
+                                       &disk_array_dma_handle, GFP_KERNEL);
 
        if( disk_array == NULL ) {
                seq_puts(m, "memory not available.\n");
@@ -2662,8 +2670,8 @@ proc_show_rdrv(struct seq_file *m, adapter_t *adapter, int start, int end )
        }
 
 free_pci:
-       pci_free_consistent(pdev, array_sz, disk_array,
-                       disk_array_dma_handle);
+       dma_free_coherent(&pdev->dev, array_sz, disk_array,
+                         disk_array_dma_handle);
 free_inquiry:
        mega_free_inquiry(inquiry, dma_handle, pdev);
 free_pdev:
@@ -2881,9 +2889,9 @@ mega_init_scb(adapter_t *adapter)
 
                scb->idx = i;
 
-               scb->sgl64 = pci_alloc_consistent(adapter->dev,
-                               sizeof(mega_sgl64) * adapter->sglen,
-                               &scb->sgl_dma_addr);
+               scb->sgl64 = dma_alloc_coherent(&adapter->dev->dev,
+                                               sizeof(mega_sgl64) * adapter->sglen,
+                                               &scb->sgl_dma_addr, GFP_KERNEL);
 
                scb->sgl = (mega_sglist *)scb->sgl64;
 
@@ -2893,9 +2901,9 @@ mega_init_scb(adapter_t *adapter)
                        return -1;
                }
 
-               scb->pthru = pci_alloc_consistent(adapter->dev,
-                               sizeof(mega_passthru),
-                               &scb->pthru_dma_addr);
+               scb->pthru = dma_alloc_coherent(&adapter->dev->dev,
+                                               sizeof(mega_passthru),
+                                               &scb->pthru_dma_addr, GFP_KERNEL);
 
                if( !scb->pthru ) {
                        dev_warn(&adapter->dev->dev, "RAID: Can't allocate passthru\n");
@@ -2903,9 +2911,9 @@ mega_init_scb(adapter_t *adapter)
                        return -1;
                }
 
-               scb->epthru = pci_alloc_consistent(adapter->dev,
-                               sizeof(mega_ext_passthru),
-                               &scb->epthru_dma_addr);
+               scb->epthru = dma_alloc_coherent(&adapter->dev->dev,
+                                                sizeof(mega_ext_passthru),
+                                                &scb->epthru_dma_addr, GFP_KERNEL);
 
                if( !scb->epthru ) {
                        dev_warn(&adapter->dev->dev,
@@ -3145,9 +3153,9 @@ megadev_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
                if( uioc.uioc_rmbox[0] == MEGA_MBOXCMD_PASSTHRU ) {
                        /* Passthru commands */
 
-                       pthru = pci_alloc_consistent(pdev,
-                                       sizeof(mega_passthru),
-                                       &pthru_dma_hndl);
+                       pthru = dma_alloc_coherent(&pdev->dev,
+                                                  sizeof(mega_passthru),
+                                                  &pthru_dma_hndl, GFP_KERNEL);
 
                        if( pthru == NULL ) {
                                free_local_pdev(pdev);
@@ -3165,9 +3173,9 @@ megadev_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
                        if( copy_from_user(pthru, upthru,
                                                sizeof(mega_passthru)) ) {
 
-                               pci_free_consistent(pdev,
-                                               sizeof(mega_passthru), pthru,
-                                               pthru_dma_hndl);
+                               dma_free_coherent(&pdev->dev,
+                                                 sizeof(mega_passthru),
+                                                 pthru, pthru_dma_hndl);
 
                                free_local_pdev(pdev);
 
@@ -3178,15 +3186,16 @@ megadev_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
                         * Is there a data transfer
                         */
                        if( pthru->dataxferlen ) {
-                               data = pci_alloc_consistent(pdev,
-                                               pthru->dataxferlen,
-                                               &data_dma_hndl);
+                               data = dma_alloc_coherent(&pdev->dev,
+                                                         pthru->dataxferlen,
+                                                         &data_dma_hndl,
+                                                         GFP_KERNEL);
 
                                if( data == NULL ) {
-                                       pci_free_consistent(pdev,
-                                                       sizeof(mega_passthru),
-                                                       pthru,
-                                                       pthru_dma_hndl);
+                                       dma_free_coherent(&pdev->dev,
+                                                         sizeof(mega_passthru),
+                                                         pthru,
+                                                         pthru_dma_hndl);
 
                                        free_local_pdev(pdev);
 
@@ -3251,13 +3260,13 @@ megadev_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
 
 freemem_and_return:
                        if( pthru->dataxferlen ) {
-                               pci_free_consistent(pdev,
-                                               pthru->dataxferlen, data,
-                                               data_dma_hndl);
+                               dma_free_coherent(&pdev->dev,
+                                                 pthru->dataxferlen, data,
+                                                 data_dma_hndl);
                        }
 
-                       pci_free_consistent(pdev, sizeof(mega_passthru),
-                                       pthru, pthru_dma_hndl);
+                       dma_free_coherent(&pdev->dev, sizeof(mega_passthru),
+                                         pthru, pthru_dma_hndl);
 
                        free_local_pdev(pdev);
 
@@ -3270,8 +3279,10 @@ freemem_and_return:
                         * Is there a data transfer
                         */
                        if( uioc.xferlen ) {
-                               data = pci_alloc_consistent(pdev,
-                                               uioc.xferlen, &data_dma_hndl);
+                               data = dma_alloc_coherent(&pdev->dev,
+                                                         uioc.xferlen,
+                                                         &data_dma_hndl,
+                                                         GFP_KERNEL);
 
                                if( data == NULL ) {
                                        free_local_pdev(pdev);
@@ -3291,9 +3302,9 @@ freemem_and_return:
                                if( copy_from_user(data, (char __user *)(unsigned long) uxferaddr,
                                                        uioc.xferlen) ) {
 
-                                       pci_free_consistent(pdev,
-                                                       uioc.xferlen,
-                                                       data, data_dma_hndl);
+                                       dma_free_coherent(&pdev->dev,
+                                                         uioc.xferlen, data,
+                                                         data_dma_hndl);
 
                                        free_local_pdev(pdev);
 
@@ -3314,9 +3325,9 @@ freemem_and_return:
 
                        if( rval ) {
                                if( uioc.xferlen ) {
-                                       pci_free_consistent(pdev,
-                                                       uioc.xferlen, data,
-                                                       data_dma_hndl);
+                                       dma_free_coherent(&pdev->dev,
+                                                         uioc.xferlen, data,
+                                                         data_dma_hndl);
                                }
 
                                free_local_pdev(pdev);
@@ -3336,9 +3347,8 @@ freemem_and_return:
                        }
 
                        if( uioc.xferlen ) {
-                               pci_free_consistent(pdev,
-                                               uioc.xferlen, data,
-                                               data_dma_hndl);
+                               dma_free_coherent(&pdev->dev, uioc.xferlen,
+                                                 data, data_dma_hndl);
                        }
 
                        free_local_pdev(pdev);
@@ -4004,8 +4014,8 @@ mega_internal_dev_inquiry(adapter_t *adapter, u8 ch, u8 tgt,
         */
        if( make_local_pdev(adapter, &pdev) != 0 ) return -1;
 
-       pthru = pci_alloc_consistent(pdev, sizeof(mega_passthru),
-                       &pthru_dma_handle);
+       pthru = dma_alloc_coherent(&pdev->dev, sizeof(mega_passthru),
+                                  &pthru_dma_handle, GFP_KERNEL);
 
        if( pthru == NULL ) {
                free_local_pdev(pdev);
@@ -4041,8 +4051,8 @@ mega_internal_dev_inquiry(adapter_t *adapter, u8 ch, u8 tgt,
 
        rval = mega_internal_command(adapter, &mc, pthru);
 
-       pci_free_consistent(pdev, sizeof(mega_passthru), pthru,
-                       pthru_dma_handle);
+       dma_free_coherent(&pdev->dev, sizeof(mega_passthru), pthru,
+                         pthru_dma_handle);
 
        free_local_pdev(pdev);
 
@@ -4267,8 +4277,10 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
        /*
         * Allocate buffer to issue internal commands.
         */
-       adapter->mega_buffer = pci_alloc_consistent(adapter->dev,
-               MEGA_BUFFER_SIZE, &adapter->buf_dma_handle);
+       adapter->mega_buffer = dma_alloc_coherent(&adapter->dev->dev,
+                                                 MEGA_BUFFER_SIZE,
+                                                 &adapter->buf_dma_handle,
+                                                 GFP_KERNEL);
        if (!adapter->mega_buffer) {
                dev_warn(&pdev->dev, "out of RAM\n");
                goto out_host_put;
@@ -4427,10 +4439,10 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
        /* Set the Mode of addressing to 64 bit if we can */
        if ((adapter->flag & BOARD_64BIT) && (sizeof(dma_addr_t) == 8)) {
-               pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+               dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
                adapter->has_64bit_addr = 1;
        } else  {
-               pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                adapter->has_64bit_addr = 0;
        }
                
@@ -4469,15 +4481,15 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
        return 0;
 
  out_free_mbox:
-       pci_free_consistent(adapter->dev, sizeof(mbox64_t),
-                       adapter->una_mbox64, adapter->una_mbox64_dma);
+       dma_free_coherent(&adapter->dev->dev, sizeof(mbox64_t),
+                         adapter->una_mbox64, adapter->una_mbox64_dma);
  out_free_irq:
        free_irq(adapter->host->irq, adapter);
  out_free_scb_list:
        kfree(adapter->scb_list);
  out_free_cmd_buffer:
-       pci_free_consistent(adapter->dev, MEGA_BUFFER_SIZE,
-                       adapter->mega_buffer, adapter->buf_dma_handle);
+       dma_free_coherent(&adapter->dev->dev, MEGA_BUFFER_SIZE,
+                         adapter->mega_buffer, adapter->buf_dma_handle);
  out_host_put:
        scsi_host_put(host);
  out_iounmap:
@@ -4551,11 +4563,11 @@ megaraid_remove_one(struct pci_dev *pdev)
        sprintf(buf, "hba%d", adapter->host->host_no);
        remove_proc_subtree(buf, mega_proc_dir_entry);
 
-       pci_free_consistent(adapter->dev, MEGA_BUFFER_SIZE,
-                       adapter->mega_buffer, adapter->buf_dma_handle);
+       dma_free_coherent(&adapter->dev->dev, MEGA_BUFFER_SIZE,
+                         adapter->mega_buffer, adapter->buf_dma_handle);
        kfree(adapter->scb_list);
-       pci_free_consistent(adapter->dev, sizeof(mbox64_t),
-                       adapter->una_mbox64, adapter->una_mbox64_dma);
+       dma_free_coherent(&adapter->dev->dev, sizeof(mbox64_t),
+                         adapter->una_mbox64, adapter->una_mbox64_dma);
 
        scsi_host_put(host);
        pci_disable_device(pdev);