Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

[firefly-linux-kernel-4.4.55.git] / drivers / dma / dmaengine.c

diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index e057935e3023194a108d4ab69c53796a5bc4605b..f15712f2fec6c06949c23f845eeb8bbb776b8907 100644 (file)
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -222,31 +222,35 @@ static void balance_ref_count(struct dma_chan *chan)
  */
 static int dma_chan_get(struct dma_chan *chan)
 {
-       int err = -ENODEV;
        struct module *owner = dma_chan_to_owner(chan);
+       int ret;
 
+       /* The channel is already in use, update client count */
        if (chan->client_count) {
                __module_get(owner);
-               err = 0;
-       } else if (try_module_get(owner))
-               err = 0;
+               goto out;
+       }
 
-       if (err == 0)
-               chan->client_count++;
+       if (!try_module_get(owner))
+               return -ENODEV;
 
        /* allocate upon first client reference */
-       if (chan->client_count == 1 && err == 0) {
-               int desc_cnt = chan->device->device_alloc_chan_resources(chan);
-
-               if (desc_cnt < 0) {
-                       err = desc_cnt;
-                       chan->client_count = 0;
-                       module_put(owner);
-               } else if (!dma_has_cap(DMA_PRIVATE, chan->device->cap_mask))
-                       balance_ref_count(chan);
+       if (chan->device->device_alloc_chan_resources) {
+               ret = chan->device->device_alloc_chan_resources(chan);
+               if (ret < 0)
+                       goto err_out;
        }
 
-       return err;
+       if (!dma_has_cap(DMA_PRIVATE, chan->device->cap_mask))
+               balance_ref_count(chan);
+
+out:
+       chan->client_count++;
+       return 0;
+
+err_out:
+       module_put(owner);
+       return ret;
 }
 
 /**
@@ -257,11 +261,15 @@ static int dma_chan_get(struct dma_chan *chan)
  */
 static void dma_chan_put(struct dma_chan *chan)
 {
+       /* This channel is not in use, bail out */
        if (!chan->client_count)
-               return; /* this channel failed alloc_chan_resources */
+               return;
+
        chan->client_count--;
        module_put(dma_chan_to_owner(chan));
-       if (chan->client_count == 0)
+
+       /* This channel is not in use anymore, free it */
+       if (!chan->client_count && chan->device->device_free_chan_resources)
                chan->device->device_free_chan_resources(chan);
 }
 
@@ -471,6 +479,39 @@ static void dma_channel_rebalance(void)
                }
 }
 
+int dma_get_slave_caps(struct dma_chan *chan, struct dma_slave_caps *caps)
+{
+       struct dma_device *device;
+
+       if (!chan || !caps)
+               return -EINVAL;
+
+       device = chan->device;
+
+       /* check if the channel supports slave transactions */
+       if (!test_bit(DMA_SLAVE, device->cap_mask.bits))
+               return -ENXIO;
+
+       /*
+        * Check whether it reports it uses the generic slave
+        * capabilities, if not, that means it doesn't support any
+        * kind of slave capabilities reporting.
+        */
+       if (!device->directions)
+               return -ENXIO;
+
+       caps->src_addr_widths = device->src_addr_widths;
+       caps->dst_addr_widths = device->dst_addr_widths;
+       caps->directions = device->directions;
+       caps->residue_granularity = device->residue_granularity;
+
+       caps->cmd_pause = !!device->device_pause;
+       caps->cmd_terminate = !!device->device_terminate_all;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(dma_get_slave_caps);
+
 static struct dma_chan *private_candidate(const dma_cap_mask_t *mask,
                                          struct dma_device *dev,
                                          dma_filter_fn fn, void *fn_param)
@@ -811,17 +852,16 @@ int dma_async_device_register(struct dma_device *device)
                !device->device_prep_dma_sg);
        BUG_ON(dma_has_cap(DMA_CYCLIC, device->cap_mask) &&
                !device->device_prep_dma_cyclic);
-       BUG_ON(dma_has_cap(DMA_SLAVE, device->cap_mask) &&
-               !device->device_control);
        BUG_ON(dma_has_cap(DMA_INTERLEAVE, device->cap_mask) &&
                !device->device_prep_interleaved_dma);
 
-       BUG_ON(!device->device_alloc_chan_resources);
-       BUG_ON(!device->device_free_chan_resources);
        BUG_ON(!device->device_tx_status);
        BUG_ON(!device->device_issue_pending);
        BUG_ON(!device->dev);
 
+       WARN(dma_has_cap(DMA_SLAVE, device->cap_mask) && !device->directions,
+            "this driver doesn't support generic slave capabilities reporting\n");
+
        /* note: this only matters in the
         * CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH=n case
         */