staging: comedi: drivers: Remove use of deprecated pci API

Replace pci_[alloc|free]_consistent occurences with
dma_[alloc|free]_coherent.

The Coccinelle semantic patch that was used to make some of these
changes is as follows:
@deprecated@
idexpression id;
position p;
@@

(
  pci_dma_supported@p ( id, ...)
|
  pci_alloc_consistent@p ( id, ...)
)

@bad1@
idexpression id;
position deprecated.p;
@@
...when != &id->dev
   when != pci_get_drvdata ( id )
   when != pci_enable_device ( id )
(
  pci_dma_supported@p ( id, ...)
|
  pci_alloc_consistent@p ( id, ...)
)

@depends on !bad1@
idexpression id;
expression direction;
position deprecated.p;
@@

(
- pci_dma_supported@p ( id,
+ dma_supported ( &id->dev,
...
+ , GFP_KERNEL
  )
|
- pci_alloc_consistent@p ( id,
+ dma_alloc_coherent ( &id->dev,
...
+ , GFP_KERNEL
  )
)

alloc_and_init_dma_members does not affect the interrupt status and is
only called by auto_attach, which also does not affect the interrupt
status. auto_attach() also contains a call to comedi_alloc_devpriv()
which calls kzalloc with GFP_KERNEL flag.  Thus, there seems to be no
danger that dma_alloc_coherent can be called with interrupts turned
off, and GFP_KERNEL can be used.

Signed-off-by: Amitoj Kaur Chawla <amitoj1606@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/comedi/drivers/cb_pcidas64.c b/drivers/staging/comedi/drivers/cb_pcidas64.c
index e918d42..c773b8c 100644 (file)
--- a/drivers/staging/comedi/drivers/cb_pcidas64.c
+++ b/drivers/staging/comedi/drivers/cb_pcidas64.c
@@ -1480,35 +1480,39 @@ static int alloc_and_init_dma_members(struct comedi_device *dev)
        /*  allocate pci dma buffers */
        for (i = 0; i < ai_dma_ring_count(board); i++) {
                devpriv->ai_buffer[i] =
-                       pci_alloc_consistent(pcidev, DMA_BUFFER_SIZE,
-                                            &devpriv->ai_buffer_bus_addr[i]);
+                       dma_alloc_coherent(&pcidev->dev, DMA_BUFFER_SIZE,
+                                          &devpriv->ai_buffer_bus_addr[i],
+                                          GFP_KERNEL);
                if (!devpriv->ai_buffer[i])
                        return -ENOMEM;
        }
        for (i = 0; i < AO_DMA_RING_COUNT; i++) {
                if (ao_cmd_is_supported(board)) {
                        devpriv->ao_buffer[i] =
-                               pci_alloc_consistent(pcidev, DMA_BUFFER_SIZE,
-                                                    &devpriv->
-                                                     ao_buffer_bus_addr[i]);
+                               dma_alloc_coherent(&pcidev->dev,
+                                                  DMA_BUFFER_SIZE,
+                                                  &devpriv->
+                                                  ao_buffer_bus_addr[i],
+                                                  GFP_KERNEL);
                        if (!devpriv->ao_buffer[i])
                                return -ENOMEM;
                }
        }
        /*  allocate dma descriptors */
        devpriv->ai_dma_desc =
-               pci_alloc_consistent(pcidev, sizeof(struct plx_dma_desc) *
-                                    ai_dma_ring_count(board),
-                                    &devpriv->ai_dma_desc_bus_addr);
+               dma_alloc_coherent(&pcidev->dev, sizeof(struct plx_dma_desc) *
+                                  ai_dma_ring_count(board),
+                                  &devpriv->ai_dma_desc_bus_addr, GFP_KERNEL);
        if (!devpriv->ai_dma_desc)
                return -ENOMEM;
 
        if (ao_cmd_is_supported(board)) {
                devpriv->ao_dma_desc =
-                       pci_alloc_consistent(pcidev,
-                                            sizeof(struct plx_dma_desc) *
-                                            AO_DMA_RING_COUNT,
-                                            &devpriv->ao_dma_desc_bus_addr);
+                       dma_alloc_coherent(&pcidev->dev,
+                                          sizeof(struct plx_dma_desc) *
+                                          AO_DMA_RING_COUNT,
+                                          &devpriv->ao_dma_desc_bus_addr,
+                                          GFP_KERNEL);
                if (!devpriv->ao_dma_desc)
                        return -ENOMEM;
        }
@@ -1564,31 +1568,31 @@ static void cb_pcidas64_free_dma(struct comedi_device *dev)
        /* free pci dma buffers */
        for (i = 0; i < ai_dma_ring_count(board); i++) {
                if (devpriv->ai_buffer[i])
-                       pci_free_consistent(pcidev,
-                                           DMA_BUFFER_SIZE,
-                                           devpriv->ai_buffer[i],
-                                           devpriv->ai_buffer_bus_addr[i]);
+                       dma_free_coherent(&pcidev->dev,
+                                         DMA_BUFFER_SIZE,
+                                         devpriv->ai_buffer[i],
+                                         devpriv->ai_buffer_bus_addr[i]);
        }
        for (i = 0; i < AO_DMA_RING_COUNT; i++) {
                if (devpriv->ao_buffer[i])
-                       pci_free_consistent(pcidev,
-                                           DMA_BUFFER_SIZE,
-                                           devpriv->ao_buffer[i],
-                                           devpriv->ao_buffer_bus_addr[i]);
+                       dma_free_coherent(&pcidev->dev,
+                                         DMA_BUFFER_SIZE,
+                                         devpriv->ao_buffer[i],
+                                         devpriv->ao_buffer_bus_addr[i]);
        }
        /* free dma descriptors */
        if (devpriv->ai_dma_desc)
-               pci_free_consistent(pcidev,
-                                   sizeof(struct plx_dma_desc) *
-                                   ai_dma_ring_count(board),
-                                   devpriv->ai_dma_desc,
-                                   devpriv->ai_dma_desc_bus_addr);
+               dma_free_coherent(&pcidev->dev,
+                                 sizeof(struct plx_dma_desc) *
+                                 ai_dma_ring_count(board),
+                                 devpriv->ai_dma_desc,
+                                 devpriv->ai_dma_desc_bus_addr);
        if (devpriv->ao_dma_desc)
-               pci_free_consistent(pcidev,
-                                   sizeof(struct plx_dma_desc) *
-                                   AO_DMA_RING_COUNT,
-                                   devpriv->ao_dma_desc,
-                                   devpriv->ao_dma_desc_bus_addr);
+               dma_free_coherent(&pcidev->dev,
+                                 sizeof(struct plx_dma_desc) *
+                                 AO_DMA_RING_COUNT,
+                                 devpriv->ao_dma_desc,
+                                 devpriv->ao_dma_desc_bus_addr);
 }
 
 static inline void warn_external_queue(struct comedi_device *dev)