The legacy API wrappers in include/linux/pci-dma-compat.h
should go away as it creates unnecessary midlayering
for include/linux/dma-mapping.h APIs, instead use dma-mapping.h
APIs directly.

The patch has been generated with the coccinelle script below
and has been hand modified to replace GFP_ with correct flags based on
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)

Signed-off-by: Suraj Upadhyay <usura...@gmail.com>
---
 drivers/scsi/megaraid.c | 125 +++++++++++++++++++++-------------------
 1 file changed, 65 insertions(+), 60 deletions(-)

diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 16bcdffeab37..ed06aafeeedc 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -2355,7 +2355,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;
@@ -2428,7 +2429,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:
@@ -2548,8 +2549,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");
@@ -2668,8 +2669,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:
@@ -2887,9 +2888,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;
 
@@ -2899,9 +2900,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");
@@ -2909,9 +2910,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,
@@ -3151,9 +3152,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);
@@ -3171,9 +3172,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);
 
@@ -3184,15 +3185,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);
 
@@ -3257,13 +3259,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);
 
@@ -3276,8 +3278,10 @@ megadev_ioctl(struct file *filep, unsigned int cmd, 
unsigned long arg)
                         * 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);
@@ -3297,9 +3301,9 @@ megadev_ioctl(struct file *filep, unsigned int cmd, 
unsigned long arg)
                                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);
 
@@ -3320,9 +3324,9 @@ megadev_ioctl(struct file *filep, unsigned int cmd, 
unsigned long arg)
 
                        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);
@@ -3342,9 +3346,8 @@ megadev_ioctl(struct file *filep, unsigned int cmd, 
unsigned long arg)
                        }
 
                        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);
@@ -4010,8 +4013,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);
@@ -4047,8 +4050,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);
 
@@ -4273,8 +4276,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;
@@ -4433,10 +4438,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;
        }
                
@@ -4475,15 +4480,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:
@@ -4557,11 +4562,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);
-- 
2.17.1

Attachment: signature.asc
Description: PGP signature

Reply via email to