LCOV - code coverage report
Current view: top level - drivers/dma - dmaengine.c (source / functions) Hit Total Coverage
Test: Real Lines: 151 446 33.9 %
Date: 2020-10-17 15:46:16 Functions: 0 43 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : /*
       7                 :            :  * This code implements the DMA subsystem. It provides a HW-neutral interface
       8                 :            :  * for other kernel code to use asynchronous memory copy capabilities,
       9                 :            :  * if present, and allows different HW DMA drivers to register as providing
      10                 :            :  * this capability.
      11                 :            :  *
      12                 :            :  * Due to the fact we are accelerating what is already a relatively fast
      13                 :            :  * operation, the code goes to great lengths to avoid additional overhead,
      14                 :            :  * such as locking.
      15                 :            :  *
      16                 :            :  * LOCKING:
      17                 :            :  *
      18                 :            :  * The subsystem keeps a global list of dma_device structs it is protected by a
      19                 :            :  * mutex, dma_list_mutex.
      20                 :            :  *
      21                 :            :  * A subsystem can get access to a channel by calling dmaengine_get() followed
      22                 :            :  * by dma_find_channel(), or if it has need for an exclusive channel it can call
      23                 :            :  * dma_request_channel().  Once a channel is allocated a reference is taken
      24                 :            :  * against its corresponding driver to disable removal.
      25                 :            :  *
      26                 :            :  * Each device has a channels list, which runs unlocked but is never modified
      27                 :            :  * once the device is registered, it's just setup by the driver.
      28                 :            :  *
      29                 :            :  * See Documentation/driver-api/dmaengine for more details
      30                 :            :  */
      31                 :            : 
      32                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      33                 :            : 
      34                 :            : #include <linux/platform_device.h>
      35                 :            : #include <linux/dma-mapping.h>
      36                 :            : #include <linux/init.h>
      37                 :            : #include <linux/module.h>
      38                 :            : #include <linux/mm.h>
      39                 :            : #include <linux/device.h>
      40                 :            : #include <linux/dmaengine.h>
      41                 :            : #include <linux/hardirq.h>
      42                 :            : #include <linux/spinlock.h>
      43                 :            : #include <linux/percpu.h>
      44                 :            : #include <linux/rcupdate.h>
      45                 :            : #include <linux/mutex.h>
      46                 :            : #include <linux/jiffies.h>
      47                 :            : #include <linux/rculist.h>
      48                 :            : #include <linux/idr.h>
      49                 :            : #include <linux/slab.h>
      50                 :            : #include <linux/acpi.h>
      51                 :            : #include <linux/acpi_dma.h>
      52                 :            : #include <linux/of_dma.h>
      53                 :            : #include <linux/mempool.h>
      54                 :            : #include <linux/numa.h>
      55                 :            : 
      56                 :            : static DEFINE_MUTEX(dma_list_mutex);
      57                 :            : static DEFINE_IDA(dma_ida);
      58                 :            : static LIST_HEAD(dma_device_list);
      59                 :            : static long dmaengine_ref_count;
      60                 :            : 
      61                 :            : /* --- sysfs implementation --- */
      62                 :            : 
      63                 :            : /**
      64                 :            :  * dev_to_dma_chan - convert a device pointer to its sysfs container object
      65                 :            :  * @dev - device node
      66                 :            :  *
      67                 :            :  * Must be called under dma_list_mutex
      68                 :            :  */
      69                 :            : static struct dma_chan *dev_to_dma_chan(struct device *dev)
      70                 :            : {
      71                 :            :         struct dma_chan_dev *chan_dev;
      72                 :            : 
      73                 :            :         chan_dev = container_of(dev, typeof(*chan_dev), device);
      74                 :          0 :         return chan_dev->chan;
      75                 :            : }
      76                 :            : 
      77                 :          0 : static ssize_t memcpy_count_show(struct device *dev,
      78                 :            :                                  struct device_attribute *attr, char *buf)
      79                 :            : {
      80                 :            :         struct dma_chan *chan;
      81                 :            :         unsigned long count = 0;
      82                 :            :         int i;
      83                 :            :         int err;
      84                 :            : 
      85                 :          0 :         mutex_lock(&dma_list_mutex);
      86                 :            :         chan = dev_to_dma_chan(dev);
      87                 :          0 :         if (chan) {
      88                 :          0 :                 for_each_possible_cpu(i)
      89                 :          0 :                         count += per_cpu_ptr(chan->local, i)->memcpy_count;
      90                 :          0 :                 err = sprintf(buf, "%lu\n", count);
      91                 :            :         } else
      92                 :            :                 err = -ENODEV;
      93                 :          0 :         mutex_unlock(&dma_list_mutex);
      94                 :            : 
      95                 :          0 :         return err;
      96                 :            : }
      97                 :            : static DEVICE_ATTR_RO(memcpy_count);
      98                 :            : 
      99                 :          0 : static ssize_t bytes_transferred_show(struct device *dev,
     100                 :            :                                       struct device_attribute *attr, char *buf)
     101                 :            : {
     102                 :            :         struct dma_chan *chan;
     103                 :            :         unsigned long count = 0;
     104                 :            :         int i;
     105                 :            :         int err;
     106                 :            : 
     107                 :          0 :         mutex_lock(&dma_list_mutex);
     108                 :            :         chan = dev_to_dma_chan(dev);
     109                 :          0 :         if (chan) {
     110                 :          0 :                 for_each_possible_cpu(i)
     111                 :          0 :                         count += per_cpu_ptr(chan->local, i)->bytes_transferred;
     112                 :          0 :                 err = sprintf(buf, "%lu\n", count);
     113                 :            :         } else
     114                 :            :                 err = -ENODEV;
     115                 :          0 :         mutex_unlock(&dma_list_mutex);
     116                 :            : 
     117                 :          0 :         return err;
     118                 :            : }
     119                 :            : static DEVICE_ATTR_RO(bytes_transferred);
     120                 :            : 
     121                 :          0 : static ssize_t in_use_show(struct device *dev, struct device_attribute *attr,
     122                 :            :                            char *buf)
     123                 :            : {
     124                 :            :         struct dma_chan *chan;
     125                 :            :         int err;
     126                 :            : 
     127                 :          0 :         mutex_lock(&dma_list_mutex);
     128                 :            :         chan = dev_to_dma_chan(dev);
     129                 :          0 :         if (chan)
     130                 :          0 :                 err = sprintf(buf, "%d\n", chan->client_count);
     131                 :            :         else
     132                 :            :                 err = -ENODEV;
     133                 :          0 :         mutex_unlock(&dma_list_mutex);
     134                 :            : 
     135                 :          0 :         return err;
     136                 :            : }
     137                 :            : static DEVICE_ATTR_RO(in_use);
     138                 :            : 
     139                 :            : static struct attribute *dma_dev_attrs[] = {
     140                 :            :         &dev_attr_memcpy_count.attr,
     141                 :            :         &dev_attr_bytes_transferred.attr,
     142                 :            :         &dev_attr_in_use.attr,
     143                 :            :         NULL,
     144                 :            : };
     145                 :            : ATTRIBUTE_GROUPS(dma_dev);
     146                 :            : 
     147                 :          0 : static void chan_dev_release(struct device *dev)
     148                 :            : {
     149                 :            :         struct dma_chan_dev *chan_dev;
     150                 :            : 
     151                 :          0 :         chan_dev = container_of(dev, typeof(*chan_dev), device);
     152                 :          0 :         if (atomic_dec_and_test(chan_dev->idr_ref)) {
     153                 :          0 :                 ida_free(&dma_ida, chan_dev->dev_id);
     154                 :          0 :                 kfree(chan_dev->idr_ref);
     155                 :            :         }
     156                 :          0 :         kfree(chan_dev);
     157                 :          0 : }
     158                 :            : 
     159                 :            : static struct class dma_devclass = {
     160                 :            :         .name           = "dma",
     161                 :            :         .dev_groups     = dma_dev_groups,
     162                 :            :         .dev_release    = chan_dev_release,
     163                 :            : };
     164                 :            : 
     165                 :            : /* --- client and device registration --- */
     166                 :            : 
     167                 :            : #define dma_device_satisfies_mask(device, mask) \
     168                 :            :         __dma_device_satisfies_mask((device), &(mask))
     169                 :            : static int
     170                 :          3 : __dma_device_satisfies_mask(struct dma_device *device,
     171                 :            :                             const dma_cap_mask_t *want)
     172                 :            : {
     173                 :            :         dma_cap_mask_t has;
     174                 :            : 
     175                 :          3 :         bitmap_and(has.bits, want->bits, device->cap_mask.bits,
     176                 :            :                 DMA_TX_TYPE_END);
     177                 :          3 :         return bitmap_equal(want->bits, has.bits, DMA_TX_TYPE_END);
     178                 :            : }
     179                 :            : 
     180                 :            : static struct module *dma_chan_to_owner(struct dma_chan *chan)
     181                 :            : {
     182                 :          3 :         return chan->device->owner;
     183                 :            : }
     184                 :            : 
     185                 :            : /**
     186                 :            :  * balance_ref_count - catch up the channel reference count
     187                 :            :  * @chan - channel to balance ->client_count versus dmaengine_ref_count
     188                 :            :  *
     189                 :            :  * balance_ref_count must be called under dma_list_mutex
     190                 :            :  */
     191                 :          0 : static void balance_ref_count(struct dma_chan *chan)
     192                 :            : {
     193                 :            :         struct module *owner = dma_chan_to_owner(chan);
     194                 :            : 
     195                 :          0 :         while (chan->client_count < dmaengine_ref_count) {
     196                 :          0 :                 __module_get(owner);
     197                 :          0 :                 chan->client_count++;
     198                 :            :         }
     199                 :          0 : }
     200                 :            : 
     201                 :            : /**
     202                 :            :  * dma_chan_get - try to grab a dma channel's parent driver module
     203                 :            :  * @chan - channel to grab
     204                 :            :  *
     205                 :            :  * Must be called under dma_list_mutex
     206                 :            :  */
     207                 :          3 : static int dma_chan_get(struct dma_chan *chan)
     208                 :            : {
     209                 :            :         struct module *owner = dma_chan_to_owner(chan);
     210                 :            :         int ret;
     211                 :            : 
     212                 :            :         /* The channel is already in use, update client count */
     213                 :          3 :         if (chan->client_count) {
     214                 :          0 :                 __module_get(owner);
     215                 :          0 :                 goto out;
     216                 :            :         }
     217                 :            : 
     218                 :          3 :         if (!try_module_get(owner))
     219                 :            :                 return -ENODEV;
     220                 :            : 
     221                 :            :         /* allocate upon first client reference */
     222                 :          3 :         if (chan->device->device_alloc_chan_resources) {
     223                 :          3 :                 ret = chan->device->device_alloc_chan_resources(chan);
     224                 :          3 :                 if (ret < 0)
     225                 :            :                         goto err_out;
     226                 :            :         }
     227                 :            : 
     228                 :          3 :         if (!dma_has_cap(DMA_PRIVATE, chan->device->cap_mask))
     229                 :          0 :                 balance_ref_count(chan);
     230                 :            : 
     231                 :            : out:
     232                 :          3 :         chan->client_count++;
     233                 :          3 :         return 0;
     234                 :            : 
     235                 :            : err_out:
     236                 :          0 :         module_put(owner);
     237                 :          0 :         return ret;
     238                 :            : }
     239                 :            : 
     240                 :            : /**
     241                 :            :  * dma_chan_put - drop a reference to a dma channel's parent driver module
     242                 :            :  * @chan - channel to release
     243                 :            :  *
     244                 :            :  * Must be called under dma_list_mutex
     245                 :            :  */
     246                 :          3 : static void dma_chan_put(struct dma_chan *chan)
     247                 :            : {
     248                 :            :         /* This channel is not in use, bail out */
     249                 :          3 :         if (!chan->client_count)
     250                 :          3 :                 return;
     251                 :            : 
     252                 :          3 :         chan->client_count--;
     253                 :          3 :         module_put(dma_chan_to_owner(chan));
     254                 :            : 
     255                 :            :         /* This channel is not in use anymore, free it */
     256                 :          3 :         if (!chan->client_count && chan->device->device_free_chan_resources) {
     257                 :            :                 /* Make sure all operations have completed */
     258                 :          3 :                 dmaengine_synchronize(chan);
     259                 :          3 :                 chan->device->device_free_chan_resources(chan);
     260                 :            :         }
     261                 :            : 
     262                 :            :         /* If the channel is used via a DMA request router, free the mapping */
     263                 :          3 :         if (chan->router && chan->router->route_free) {
     264                 :          0 :                 chan->router->route_free(chan->router->dev, chan->route_data);
     265                 :          0 :                 chan->router = NULL;
     266                 :          0 :                 chan->route_data = NULL;
     267                 :            :         }
     268                 :            : }
     269                 :            : 
     270                 :          0 : enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie)
     271                 :            : {
     272                 :            :         enum dma_status status;
     273                 :          0 :         unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000);
     274                 :            : 
     275                 :            :         dma_async_issue_pending(chan);
     276                 :            :         do {
     277                 :            :                 status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);
     278                 :          0 :                 if (time_after_eq(jiffies, dma_sync_wait_timeout)) {
     279                 :          0 :                         dev_err(chan->device->dev, "%s: timeout!\n", __func__);
     280                 :          0 :                         return DMA_ERROR;
     281                 :            :                 }
     282                 :          0 :                 if (status != DMA_IN_PROGRESS)
     283                 :            :                         break;
     284                 :          0 :                 cpu_relax();
     285                 :          0 :         } while (1);
     286                 :            : 
     287                 :          0 :         return status;
     288                 :            : }
     289                 :            : EXPORT_SYMBOL(dma_sync_wait);
     290                 :            : 
     291                 :            : /**
     292                 :            :  * dma_cap_mask_all - enable iteration over all operation types
     293                 :            :  */
     294                 :            : static dma_cap_mask_t dma_cap_mask_all;
     295                 :            : 
     296                 :            : /**
     297                 :            :  * dma_chan_tbl_ent - tracks channel allocations per core/operation
     298                 :            :  * @chan - associated channel for this entry
     299                 :            :  */
     300                 :            : struct dma_chan_tbl_ent {
     301                 :            :         struct dma_chan *chan;
     302                 :            : };
     303                 :            : 
     304                 :            : /**
     305                 :            :  * channel_table - percpu lookup table for memory-to-memory offload providers
     306                 :            :  */
     307                 :            : static struct dma_chan_tbl_ent __percpu *channel_table[DMA_TX_TYPE_END];
     308                 :            : 
     309                 :          3 : static int __init dma_channel_table_init(void)
     310                 :            : {
     311                 :            :         enum dma_transaction_type cap;
     312                 :            :         int err = 0;
     313                 :            : 
     314                 :            :         bitmap_fill(dma_cap_mask_all.bits, DMA_TX_TYPE_END);
     315                 :            : 
     316                 :            :         /* 'interrupt', 'private', and 'slave' are channel capabilities,
     317                 :            :          * but are not associated with an operation so they do not need
     318                 :            :          * an entry in the channel_table
     319                 :            :          */
     320                 :          3 :         clear_bit(DMA_INTERRUPT, dma_cap_mask_all.bits);
     321                 :          3 :         clear_bit(DMA_PRIVATE, dma_cap_mask_all.bits);
     322                 :          3 :         clear_bit(DMA_SLAVE, dma_cap_mask_all.bits);
     323                 :            : 
     324                 :          3 :         for_each_dma_cap_mask(cap, dma_cap_mask_all) {
     325                 :          3 :                 channel_table[cap] = alloc_percpu(struct dma_chan_tbl_ent);
     326                 :          3 :                 if (!channel_table[cap]) {
     327                 :            :                         err = -ENOMEM;
     328                 :            :                         break;
     329                 :            :                 }
     330                 :            :         }
     331                 :            : 
     332                 :          3 :         if (err) {
     333                 :          0 :                 pr_err("initialization failure\n");
     334                 :          0 :                 for_each_dma_cap_mask(cap, dma_cap_mask_all)
     335                 :          0 :                         free_percpu(channel_table[cap]);
     336                 :            :         }
     337                 :            : 
     338                 :          3 :         return err;
     339                 :            : }
     340                 :            : arch_initcall(dma_channel_table_init);
     341                 :            : 
     342                 :            : /**
     343                 :            :  * dma_find_channel - find a channel to carry out the operation
     344                 :            :  * @tx_type: transaction type
     345                 :            :  */
     346                 :          0 : struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type)
     347                 :            : {
     348                 :          0 :         return this_cpu_read(channel_table[tx_type]->chan);
     349                 :            : }
     350                 :            : EXPORT_SYMBOL(dma_find_channel);
     351                 :            : 
     352                 :            : /**
     353                 :            :  * dma_issue_pending_all - flush all pending operations across all channels
     354                 :            :  */
     355                 :          0 : void dma_issue_pending_all(void)
     356                 :            : {
     357                 :            :         struct dma_device *device;
     358                 :            :         struct dma_chan *chan;
     359                 :            : 
     360                 :            :         rcu_read_lock();
     361                 :          0 :         list_for_each_entry_rcu(device, &dma_device_list, global_node) {
     362                 :          0 :                 if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
     363                 :          0 :                         continue;
     364                 :          0 :                 list_for_each_entry(chan, &device->channels, device_node)
     365                 :          0 :                         if (chan->client_count)
     366                 :          0 :                                 device->device_issue_pending(chan);
     367                 :            :         }
     368                 :            :         rcu_read_unlock();
     369                 :          0 : }
     370                 :            : EXPORT_SYMBOL(dma_issue_pending_all);
     371                 :            : 
     372                 :            : /**
     373                 :            :  * dma_chan_is_local - returns true if the channel is in the same numa-node as the cpu
     374                 :            :  */
     375                 :            : static bool dma_chan_is_local(struct dma_chan *chan, int cpu)
     376                 :            : {
     377                 :            :         int node = dev_to_node(chan->device->dev);
     378                 :            :         return node == NUMA_NO_NODE ||
     379                 :            :                 cpumask_test_cpu(cpu, cpumask_of_node(node));
     380                 :            : }
     381                 :            : 
     382                 :            : /**
     383                 :            :  * min_chan - returns the channel with min count and in the same numa-node as the cpu
     384                 :            :  * @cap: capability to match
     385                 :            :  * @cpu: cpu index which the channel should be close to
     386                 :            :  *
     387                 :            :  * If some channels are close to the given cpu, the one with the lowest
     388                 :            :  * reference count is returned. Otherwise, cpu is ignored and only the
     389                 :            :  * reference count is taken into account.
     390                 :            :  * Must be called under dma_list_mutex.
     391                 :            :  */
     392                 :          0 : static struct dma_chan *min_chan(enum dma_transaction_type cap, int cpu)
     393                 :            : {
     394                 :            :         struct dma_device *device;
     395                 :            :         struct dma_chan *chan;
     396                 :            :         struct dma_chan *min = NULL;
     397                 :            :         struct dma_chan *localmin = NULL;
     398                 :            : 
     399                 :          0 :         list_for_each_entry(device, &dma_device_list, global_node) {
     400                 :          0 :                 if (!dma_has_cap(cap, device->cap_mask) ||
     401                 :            :                     dma_has_cap(DMA_PRIVATE, device->cap_mask))
     402                 :          0 :                         continue;
     403                 :          0 :                 list_for_each_entry(chan, &device->channels, device_node) {
     404                 :          0 :                         if (!chan->client_count)
     405                 :          0 :                                 continue;
     406                 :          0 :                         if (!min || chan->table_count < min->table_count)
     407                 :            :                                 min = chan;
     408                 :            : 
     409                 :            :                         if (dma_chan_is_local(chan, cpu))
     410                 :          0 :                                 if (!localmin ||
     411                 :          0 :                                     chan->table_count < localmin->table_count)
     412                 :            :                                         localmin = chan;
     413                 :            :                 }
     414                 :            :         }
     415                 :            : 
     416                 :          0 :         chan = localmin ? localmin : min;
     417                 :            : 
     418                 :          0 :         if (chan)
     419                 :          0 :                 chan->table_count++;
     420                 :            : 
     421                 :          0 :         return chan;
     422                 :            : }
     423                 :            : 
     424                 :            : /**
     425                 :            :  * dma_channel_rebalance - redistribute the available channels
     426                 :            :  *
     427                 :            :  * Optimize for cpu isolation (each cpu gets a dedicated channel for an
     428                 :            :  * operation type) in the SMP case,  and operation isolation (avoid
     429                 :            :  * multi-tasking channels) in the non-SMP case.  Must be called under
     430                 :            :  * dma_list_mutex.
     431                 :            :  */
     432                 :          3 : static void dma_channel_rebalance(void)
     433                 :            : {
     434                 :            :         struct dma_chan *chan;
     435                 :            :         struct dma_device *device;
     436                 :            :         int cpu;
     437                 :            :         int cap;
     438                 :            : 
     439                 :            :         /* undo the last distribution */
     440                 :          3 :         for_each_dma_cap_mask(cap, dma_cap_mask_all)
     441                 :          3 :                 for_each_possible_cpu(cpu)
     442                 :          3 :                         per_cpu_ptr(channel_table[cap], cpu)->chan = NULL;
     443                 :            : 
     444                 :          3 :         list_for_each_entry(device, &dma_device_list, global_node) {
     445                 :          3 :                 if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
     446                 :          3 :                         continue;
     447                 :          0 :                 list_for_each_entry(chan, &device->channels, device_node)
     448                 :          0 :                         chan->table_count = 0;
     449                 :            :         }
     450                 :            : 
     451                 :            :         /* don't populate the channel_table if no clients are available */
     452                 :          3 :         if (!dmaengine_ref_count)
     453                 :          3 :                 return;
     454                 :            : 
     455                 :            :         /* redistribute available channels */
     456                 :          0 :         for_each_dma_cap_mask(cap, dma_cap_mask_all)
     457                 :          0 :                 for_each_online_cpu(cpu) {
     458                 :          0 :                         chan = min_chan(cap, cpu);
     459                 :          0 :                         per_cpu_ptr(channel_table[cap], cpu)->chan = chan;
     460                 :            :                 }
     461                 :            : }
     462                 :            : 
     463                 :          0 : int dma_get_slave_caps(struct dma_chan *chan, struct dma_slave_caps *caps)
     464                 :            : {
     465                 :            :         struct dma_device *device;
     466                 :            : 
     467                 :          0 :         if (!chan || !caps)
     468                 :            :                 return -EINVAL;
     469                 :            : 
     470                 :          0 :         device = chan->device;
     471                 :            : 
     472                 :            :         /* check if the channel supports slave transactions */
     473                 :          0 :         if (!(test_bit(DMA_SLAVE, device->cap_mask.bits) ||
     474                 :            :               test_bit(DMA_CYCLIC, device->cap_mask.bits)))
     475                 :            :                 return -ENXIO;
     476                 :            : 
     477                 :            :         /*
     478                 :            :          * Check whether it reports it uses the generic slave
     479                 :            :          * capabilities, if not, that means it doesn't support any
     480                 :            :          * kind of slave capabilities reporting.
     481                 :            :          */
     482                 :          0 :         if (!device->directions)
     483                 :            :                 return -ENXIO;
     484                 :            : 
     485                 :          0 :         caps->src_addr_widths = device->src_addr_widths;
     486                 :          0 :         caps->dst_addr_widths = device->dst_addr_widths;
     487                 :          0 :         caps->directions = device->directions;
     488                 :          0 :         caps->max_burst = device->max_burst;
     489                 :          0 :         caps->residue_granularity = device->residue_granularity;
     490                 :          0 :         caps->descriptor_reuse = device->descriptor_reuse;
     491                 :          0 :         caps->cmd_pause = !!device->device_pause;
     492                 :          0 :         caps->cmd_resume = !!device->device_resume;
     493                 :          0 :         caps->cmd_terminate = !!device->device_terminate_all;
     494                 :            : 
     495                 :          0 :         return 0;
     496                 :            : }
     497                 :            : EXPORT_SYMBOL_GPL(dma_get_slave_caps);
     498                 :            : 
     499                 :          3 : static struct dma_chan *private_candidate(const dma_cap_mask_t *mask,
     500                 :            :                                           struct dma_device *dev,
     501                 :            :                                           dma_filter_fn fn, void *fn_param)
     502                 :            : {
     503                 :            :         struct dma_chan *chan;
     504                 :            : 
     505                 :          3 :         if (mask && !__dma_device_satisfies_mask(dev, mask)) {
     506                 :            :                 dev_dbg(dev->dev, "%s: wrong capabilities\n", __func__);
     507                 :            :                 return NULL;
     508                 :            :         }
     509                 :            :         /* devices with multiple channels need special handling as we need to
     510                 :            :          * ensure that all channels are either private or public.
     511                 :            :          */
     512                 :          3 :         if (dev->chancnt > 1 && !dma_has_cap(DMA_PRIVATE, dev->cap_mask))
     513                 :          0 :                 list_for_each_entry(chan, &dev->channels, device_node) {
     514                 :            :                         /* some channels are already publicly allocated */
     515                 :          0 :                         if (chan->client_count)
     516                 :            :                                 return NULL;
     517                 :            :                 }
     518                 :            : 
     519                 :          3 :         list_for_each_entry(chan, &dev->channels, device_node) {
     520                 :          3 :                 if (chan->client_count) {
     521                 :            :                         dev_dbg(dev->dev, "%s: %s busy\n",
     522                 :            :                                  __func__, dma_chan_name(chan));
     523                 :          0 :                         continue;
     524                 :            :                 }
     525                 :          3 :                 if (fn && !fn(chan, fn_param)) {
     526                 :            :                         dev_dbg(dev->dev, "%s: %s filter said false\n",
     527                 :            :                                  __func__, dma_chan_name(chan));
     528                 :          0 :                         continue;
     529                 :            :                 }
     530                 :          3 :                 return chan;
     531                 :            :         }
     532                 :            : 
     533                 :            :         return NULL;
     534                 :            : }
     535                 :            : 
     536                 :          3 : static struct dma_chan *find_candidate(struct dma_device *device,
     537                 :            :                                        const dma_cap_mask_t *mask,
     538                 :            :                                        dma_filter_fn fn, void *fn_param)
     539                 :            : {
     540                 :          3 :         struct dma_chan *chan = private_candidate(mask, device, fn, fn_param);
     541                 :            :         int err;
     542                 :            : 
     543                 :          3 :         if (chan) {
     544                 :            :                 /* Found a suitable channel, try to grab, prep, and return it.
     545                 :            :                  * We first set DMA_PRIVATE to disable balance_ref_count as this
     546                 :            :                  * channel will not be published in the general-purpose
     547                 :            :                  * allocator
     548                 :            :                  */
     549                 :            :                 dma_cap_set(DMA_PRIVATE, device->cap_mask);
     550                 :          3 :                 device->privatecnt++;
     551                 :          3 :                 err = dma_chan_get(chan);
     552                 :            : 
     553                 :          3 :                 if (err) {
     554                 :          0 :                         if (err == -ENODEV) {
     555                 :            :                                 dev_dbg(device->dev, "%s: %s module removed\n",
     556                 :            :                                         __func__, dma_chan_name(chan));
     557                 :            :                                 list_del_rcu(&device->global_node);
     558                 :            :                         } else
     559                 :            :                                 dev_dbg(device->dev,
     560                 :            :                                         "%s: failed to get %s: (%d)\n",
     561                 :            :                                          __func__, dma_chan_name(chan), err);
     562                 :            : 
     563                 :          0 :                         if (--device->privatecnt == 0)
     564                 :            :                                 dma_cap_clear(DMA_PRIVATE, device->cap_mask);
     565                 :            : 
     566                 :            :                         chan = ERR_PTR(err);
     567                 :            :                 }
     568                 :            :         }
     569                 :            : 
     570                 :          3 :         return chan ? chan : ERR_PTR(-EPROBE_DEFER);
     571                 :            : }
     572                 :            : 
     573                 :            : /**
     574                 :            :  * dma_get_slave_channel - try to get specific channel exclusively
     575                 :            :  * @chan: target channel
     576                 :            :  */
     577                 :          0 : struct dma_chan *dma_get_slave_channel(struct dma_chan *chan)
     578                 :            : {
     579                 :            :         int err = -EBUSY;
     580                 :            : 
     581                 :            :         /* lock against __dma_request_channel */
     582                 :          0 :         mutex_lock(&dma_list_mutex);
     583                 :            : 
     584                 :          0 :         if (chan->client_count == 0) {
     585                 :          0 :                 struct dma_device *device = chan->device;
     586                 :            : 
     587                 :            :                 dma_cap_set(DMA_PRIVATE, device->cap_mask);
     588                 :          0 :                 device->privatecnt++;
     589                 :          0 :                 err = dma_chan_get(chan);
     590                 :          0 :                 if (err) {
     591                 :            :                         dev_dbg(chan->device->dev,
     592                 :            :                                 "%s: failed to get %s: (%d)\n",
     593                 :            :                                 __func__, dma_chan_name(chan), err);
     594                 :            :                         chan = NULL;
     595                 :          0 :                         if (--device->privatecnt == 0)
     596                 :            :                                 dma_cap_clear(DMA_PRIVATE, device->cap_mask);
     597                 :            :                 }
     598                 :            :         } else
     599                 :            :                 chan = NULL;
     600                 :            : 
     601                 :          0 :         mutex_unlock(&dma_list_mutex);
     602                 :            : 
     603                 :            : 
     604                 :          0 :         return chan;
     605                 :            : }
     606                 :            : EXPORT_SYMBOL_GPL(dma_get_slave_channel);
     607                 :            : 
     608                 :          3 : struct dma_chan *dma_get_any_slave_channel(struct dma_device *device)
     609                 :            : {
     610                 :            :         dma_cap_mask_t mask;
     611                 :            :         struct dma_chan *chan;
     612                 :            : 
     613                 :            :         dma_cap_zero(mask);
     614                 :            :         dma_cap_set(DMA_SLAVE, mask);
     615                 :            : 
     616                 :            :         /* lock against __dma_request_channel */
     617                 :          3 :         mutex_lock(&dma_list_mutex);
     618                 :            : 
     619                 :          3 :         chan = find_candidate(device, &mask, NULL, NULL);
     620                 :            : 
     621                 :          3 :         mutex_unlock(&dma_list_mutex);
     622                 :            : 
     623                 :          3 :         return IS_ERR(chan) ? NULL : chan;
     624                 :            : }
     625                 :            : EXPORT_SYMBOL_GPL(dma_get_any_slave_channel);
     626                 :            : 
     627                 :            : /**
     628                 :            :  * __dma_request_channel - try to allocate an exclusive channel
     629                 :            :  * @mask: capabilities that the channel must satisfy
     630                 :            :  * @fn: optional callback to disposition available channels
     631                 :            :  * @fn_param: opaque parameter to pass to dma_filter_fn
     632                 :            :  * @np: device node to look for DMA channels
     633                 :            :  *
     634                 :            :  * Returns pointer to appropriate DMA channel on success or NULL.
     635                 :            :  */
     636                 :          0 : struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
     637                 :            :                                        dma_filter_fn fn, void *fn_param,
     638                 :            :                                        struct device_node *np)
     639                 :            : {
     640                 :            :         struct dma_device *device, *_d;
     641                 :            :         struct dma_chan *chan = NULL;
     642                 :            : 
     643                 :            :         /* Find a channel */
     644                 :          0 :         mutex_lock(&dma_list_mutex);
     645                 :          0 :         list_for_each_entry_safe(device, _d, &dma_device_list, global_node) {
     646                 :            :                 /* Finds a DMA controller with matching device node */
     647                 :          0 :                 if (np && device->dev->of_node && np != device->dev->of_node)
     648                 :          0 :                         continue;
     649                 :            : 
     650                 :          0 :                 chan = find_candidate(device, mask, fn, fn_param);
     651                 :          0 :                 if (!IS_ERR(chan))
     652                 :            :                         break;
     653                 :            : 
     654                 :            :                 chan = NULL;
     655                 :            :         }
     656                 :          0 :         mutex_unlock(&dma_list_mutex);
     657                 :            : 
     658                 :            :         pr_debug("%s: %s (%s)\n",
     659                 :            :                  __func__,
     660                 :            :                  chan ? "success" : "fail",
     661                 :            :                  chan ? dma_chan_name(chan) : NULL);
     662                 :            : 
     663                 :          0 :         return chan;
     664                 :            : }
     665                 :            : EXPORT_SYMBOL_GPL(__dma_request_channel);
     666                 :            : 
     667                 :          3 : static const struct dma_slave_map *dma_filter_match(struct dma_device *device,
     668                 :            :                                                     const char *name,
     669                 :            :                                                     struct device *dev)
     670                 :            : {
     671                 :            :         int i;
     672                 :            : 
     673                 :          3 :         if (!device->filter.mapcnt)
     674                 :            :                 return NULL;
     675                 :            : 
     676                 :          0 :         for (i = 0; i < device->filter.mapcnt; i++) {
     677                 :          0 :                 const struct dma_slave_map *map = &device->filter.map[i];
     678                 :            : 
     679                 :          0 :                 if (!strcmp(map->devname, dev_name(dev)) &&
     680                 :          0 :                     !strcmp(map->slave, name))
     681                 :          0 :                         return map;
     682                 :            :         }
     683                 :            : 
     684                 :            :         return NULL;
     685                 :            : }
     686                 :            : 
     687                 :            : /**
     688                 :            :  * dma_request_chan - try to allocate an exclusive slave channel
     689                 :            :  * @dev:        pointer to client device structure
     690                 :            :  * @name:       slave channel name
     691                 :            :  *
     692                 :            :  * Returns pointer to appropriate DMA channel on success or an error pointer.
     693                 :            :  */
     694                 :          3 : struct dma_chan *dma_request_chan(struct device *dev, const char *name)
     695                 :            : {
     696                 :            :         struct dma_device *d, *_d;
     697                 :            :         struct dma_chan *chan = NULL;
     698                 :            : 
     699                 :            :         /* If device-tree is present get slave info from here */
     700                 :          3 :         if (dev->of_node)
     701                 :          3 :                 chan = of_dma_request_slave_channel(dev->of_node, name);
     702                 :            : 
     703                 :            :         /* If device was enumerated by ACPI get slave info from here */
     704                 :            :         if (has_acpi_companion(dev) && !chan)
     705                 :            :                 chan = acpi_dma_request_slave_chan_by_name(dev, name);
     706                 :            : 
     707                 :          3 :         if (chan) {
     708                 :            :                 /* Valid channel found or requester needs to be deferred */
     709                 :          3 :                 if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER)
     710                 :            :                         return chan;
     711                 :            :         }
     712                 :            : 
     713                 :            :         /* Try to find the channel via the DMA filter map(s) */
     714                 :          3 :         mutex_lock(&dma_list_mutex);
     715                 :          3 :         list_for_each_entry_safe(d, _d, &dma_device_list, global_node) {
     716                 :            :                 dma_cap_mask_t mask;
     717                 :          3 :                 const struct dma_slave_map *map = dma_filter_match(d, name, dev);
     718                 :            : 
     719                 :          3 :                 if (!map)
     720                 :          3 :                         continue;
     721                 :            : 
     722                 :            :                 dma_cap_zero(mask);
     723                 :            :                 dma_cap_set(DMA_SLAVE, mask);
     724                 :            : 
     725                 :          0 :                 chan = find_candidate(d, &mask, d->filter.fn, map->param);
     726                 :          0 :                 if (!IS_ERR(chan))
     727                 :            :                         break;
     728                 :            :         }
     729                 :          3 :         mutex_unlock(&dma_list_mutex);
     730                 :            : 
     731                 :          3 :         return chan ? chan : ERR_PTR(-EPROBE_DEFER);
     732                 :            : }
     733                 :            : EXPORT_SYMBOL_GPL(dma_request_chan);
     734                 :            : 
     735                 :            : /**
     736                 :            :  * dma_request_slave_channel - try to allocate an exclusive slave channel
     737                 :            :  * @dev:        pointer to client device structure
     738                 :            :  * @name:       slave channel name
     739                 :            :  *
     740                 :            :  * Returns pointer to appropriate DMA channel on success or NULL.
     741                 :            :  */
     742                 :          3 : struct dma_chan *dma_request_slave_channel(struct device *dev,
     743                 :            :                                            const char *name)
     744                 :            : {
     745                 :          3 :         struct dma_chan *ch = dma_request_chan(dev, name);
     746                 :          3 :         if (IS_ERR(ch))
     747                 :            :                 return NULL;
     748                 :            : 
     749                 :          3 :         return ch;
     750                 :            : }
     751                 :            : EXPORT_SYMBOL_GPL(dma_request_slave_channel);
     752                 :            : 
     753                 :            : /**
     754                 :            :  * dma_request_chan_by_mask - allocate a channel satisfying certain capabilities
     755                 :            :  * @mask: capabilities that the channel must satisfy
     756                 :            :  *
     757                 :            :  * Returns pointer to appropriate DMA channel on success or an error pointer.
     758                 :            :  */
     759                 :          0 : struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask)
     760                 :            : {
     761                 :            :         struct dma_chan *chan;
     762                 :            : 
     763                 :          0 :         if (!mask)
     764                 :            :                 return ERR_PTR(-ENODEV);
     765                 :            : 
     766                 :          0 :         chan = __dma_request_channel(mask, NULL, NULL, NULL);
     767                 :          0 :         if (!chan) {
     768                 :          0 :                 mutex_lock(&dma_list_mutex);
     769                 :          0 :                 if (list_empty(&dma_device_list))
     770                 :            :                         chan = ERR_PTR(-EPROBE_DEFER);
     771                 :            :                 else
     772                 :            :                         chan = ERR_PTR(-ENODEV);
     773                 :          0 :                 mutex_unlock(&dma_list_mutex);
     774                 :            :         }
     775                 :            : 
     776                 :          0 :         return chan;
     777                 :            : }
     778                 :            : EXPORT_SYMBOL_GPL(dma_request_chan_by_mask);
     779                 :            : 
     780                 :          3 : void dma_release_channel(struct dma_chan *chan)
     781                 :            : {
     782                 :          3 :         mutex_lock(&dma_list_mutex);
     783                 :          3 :         WARN_ONCE(chan->client_count != 1,
     784                 :            :                   "chan reference count %d != 1\n", chan->client_count);
     785                 :          3 :         dma_chan_put(chan);
     786                 :            :         /* drop PRIVATE cap enabled by __dma_request_channel() */
     787                 :          3 :         if (--chan->device->privatecnt == 0)
     788                 :          0 :                 dma_cap_clear(DMA_PRIVATE, chan->device->cap_mask);
     789                 :          3 :         mutex_unlock(&dma_list_mutex);
     790                 :          3 : }
     791                 :            : EXPORT_SYMBOL_GPL(dma_release_channel);
     792                 :            : 
     793                 :            : /**
     794                 :            :  * dmaengine_get - register interest in dma_channels
     795                 :            :  */
     796                 :          0 : void dmaengine_get(void)
     797                 :            : {
     798                 :            :         struct dma_device *device, *_d;
     799                 :            :         struct dma_chan *chan;
     800                 :            :         int err;
     801                 :            : 
     802                 :          0 :         mutex_lock(&dma_list_mutex);
     803                 :          0 :         dmaengine_ref_count++;
     804                 :            : 
     805                 :            :         /* try to grab channels */
     806                 :          0 :         list_for_each_entry_safe(device, _d, &dma_device_list, global_node) {
     807                 :          0 :                 if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
     808                 :          0 :                         continue;
     809                 :          0 :                 list_for_each_entry(chan, &device->channels, device_node) {
     810                 :          0 :                         err = dma_chan_get(chan);
     811                 :          0 :                         if (err == -ENODEV) {
     812                 :            :                                 /* module removed before we could use it */
     813                 :            :                                 list_del_rcu(&device->global_node);
     814                 :            :                                 break;
     815                 :            :                         } else if (err)
     816                 :            :                                 dev_dbg(chan->device->dev,
     817                 :            :                                         "%s: failed to get %s: (%d)\n",
     818                 :            :                                         __func__, dma_chan_name(chan), err);
     819                 :            :                 }
     820                 :            :         }
     821                 :            : 
     822                 :            :         /* if this is the first reference and there were channels
     823                 :            :          * waiting we need to rebalance to get those channels
     824                 :            :          * incorporated into the channel table
     825                 :            :          */
     826                 :          0 :         if (dmaengine_ref_count == 1)
     827                 :          0 :                 dma_channel_rebalance();
     828                 :          0 :         mutex_unlock(&dma_list_mutex);
     829                 :          0 : }
     830                 :            : EXPORT_SYMBOL(dmaengine_get);
     831                 :            : 
     832                 :            : /**
     833                 :            :  * dmaengine_put - let dma drivers be removed when ref_count == 0
     834                 :            :  */
     835                 :          0 : void dmaengine_put(void)
     836                 :            : {
     837                 :            :         struct dma_device *device;
     838                 :            :         struct dma_chan *chan;
     839                 :            : 
     840                 :          0 :         mutex_lock(&dma_list_mutex);
     841                 :          0 :         dmaengine_ref_count--;
     842                 :          0 :         BUG_ON(dmaengine_ref_count < 0);
     843                 :            :         /* drop channel references */
     844                 :          0 :         list_for_each_entry(device, &dma_device_list, global_node) {
     845                 :          0 :                 if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
     846                 :          0 :                         continue;
     847                 :          0 :                 list_for_each_entry(chan, &device->channels, device_node)
     848                 :          0 :                         dma_chan_put(chan);
     849                 :            :         }
     850                 :          0 :         mutex_unlock(&dma_list_mutex);
     851                 :          0 : }
     852                 :            : EXPORT_SYMBOL(dmaengine_put);
     853                 :            : 
     854                 :          3 : static bool device_has_all_tx_types(struct dma_device *device)
     855                 :            : {
     856                 :            :         /* A device that satisfies this test has channels that will never cause
     857                 :            :          * an async_tx channel switch event as all possible operation types can
     858                 :            :          * be handled.
     859                 :            :          */
     860                 :            :         #ifdef CONFIG_ASYNC_TX_DMA
     861                 :            :         if (!dma_has_cap(DMA_INTERRUPT, device->cap_mask))
     862                 :            :                 return false;
     863                 :            :         #endif
     864                 :            : 
     865                 :            :         #if IS_ENABLED(CONFIG_ASYNC_MEMCPY)
     866                 :          3 :         if (!dma_has_cap(DMA_MEMCPY, device->cap_mask))
     867                 :            :                 return false;
     868                 :            :         #endif
     869                 :            : 
     870                 :            :         #if IS_ENABLED(CONFIG_ASYNC_XOR)
     871                 :          3 :         if (!dma_has_cap(DMA_XOR, device->cap_mask))
     872                 :            :                 return false;
     873                 :            : 
     874                 :            :         #ifndef CONFIG_ASYNC_TX_DISABLE_XOR_VAL_DMA
     875                 :          0 :         if (!dma_has_cap(DMA_XOR_VAL, device->cap_mask))
     876                 :            :                 return false;
     877                 :            :         #endif
     878                 :            :         #endif
     879                 :            : 
     880                 :            :         #if IS_ENABLED(CONFIG_ASYNC_PQ)
     881                 :          0 :         if (!dma_has_cap(DMA_PQ, device->cap_mask))
     882                 :            :                 return false;
     883                 :            : 
     884                 :            :         #ifndef CONFIG_ASYNC_TX_DISABLE_PQ_VAL_DMA
     885                 :          0 :         if (!dma_has_cap(DMA_PQ_VAL, device->cap_mask))
     886                 :            :                 return false;
     887                 :            :         #endif
     888                 :            :         #endif
     889                 :            : 
     890                 :          0 :         return true;
     891                 :            : }
     892                 :            : 
     893                 :          3 : static int get_dma_id(struct dma_device *device)
     894                 :            : {
     895                 :            :         int rc = ida_alloc(&dma_ida, GFP_KERNEL);
     896                 :            : 
     897                 :          3 :         if (rc < 0)
     898                 :            :                 return rc;
     899                 :          3 :         device->dev_id = rc;
     900                 :          3 :         return 0;
     901                 :            : }
     902                 :            : 
     903                 :            : /**
     904                 :            :  * dma_async_device_register - registers DMA devices found
     905                 :            :  * @device: &dma_device
     906                 :            :  */
     907                 :          3 : int dma_async_device_register(struct dma_device *device)
     908                 :            : {
     909                 :            :         int chancnt = 0, rc;
     910                 :            :         struct dma_chan* chan;
     911                 :            :         atomic_t *idr_ref;
     912                 :            : 
     913                 :          3 :         if (!device)
     914                 :            :                 return -ENODEV;
     915                 :            : 
     916                 :            :         /* validate device routines */
     917                 :          3 :         if (!device->dev) {
     918                 :          0 :                 pr_err("DMAdevice must have dev\n");
     919                 :          0 :                 return -EIO;
     920                 :            :         }
     921                 :            : 
     922                 :          3 :         device->owner = device->dev->driver->owner;
     923                 :            : 
     924                 :          3 :         if (dma_has_cap(DMA_MEMCPY, device->cap_mask) && !device->device_prep_dma_memcpy) {
     925                 :          0 :                 dev_err(device->dev,
     926                 :            :                         "Device claims capability %s, but op is not defined\n",
     927                 :            :                         "DMA_MEMCPY");
     928                 :          0 :                 return -EIO;
     929                 :            :         }
     930                 :            : 
     931                 :          3 :         if (dma_has_cap(DMA_XOR, device->cap_mask) && !device->device_prep_dma_xor) {
     932                 :          0 :                 dev_err(device->dev,
     933                 :            :                         "Device claims capability %s, but op is not defined\n",
     934                 :            :                         "DMA_XOR");
     935                 :          0 :                 return -EIO;
     936                 :            :         }
     937                 :            : 
     938                 :          3 :         if (dma_has_cap(DMA_XOR_VAL, device->cap_mask) && !device->device_prep_dma_xor_val) {
     939                 :          0 :                 dev_err(device->dev,
     940                 :            :                         "Device claims capability %s, but op is not defined\n",
     941                 :            :                         "DMA_XOR_VAL");
     942                 :          0 :                 return -EIO;
     943                 :            :         }
     944                 :            : 
     945                 :          3 :         if (dma_has_cap(DMA_PQ, device->cap_mask) && !device->device_prep_dma_pq) {
     946                 :          0 :                 dev_err(device->dev,
     947                 :            :                         "Device claims capability %s, but op is not defined\n",
     948                 :            :                         "DMA_PQ");
     949                 :          0 :                 return -EIO;
     950                 :            :         }
     951                 :            : 
     952                 :          3 :         if (dma_has_cap(DMA_PQ_VAL, device->cap_mask) && !device->device_prep_dma_pq_val) {
     953                 :          0 :                 dev_err(device->dev,
     954                 :            :                         "Device claims capability %s, but op is not defined\n",
     955                 :            :                         "DMA_PQ_VAL");
     956                 :          0 :                 return -EIO;
     957                 :            :         }
     958                 :            : 
     959                 :          3 :         if (dma_has_cap(DMA_MEMSET, device->cap_mask) && !device->device_prep_dma_memset) {
     960                 :          0 :                 dev_err(device->dev,
     961                 :            :                         "Device claims capability %s, but op is not defined\n",
     962                 :            :                         "DMA_MEMSET");
     963                 :          0 :                 return -EIO;
     964                 :            :         }
     965                 :            : 
     966                 :          3 :         if (dma_has_cap(DMA_INTERRUPT, device->cap_mask) && !device->device_prep_dma_interrupt) {
     967                 :          0 :                 dev_err(device->dev,
     968                 :            :                         "Device claims capability %s, but op is not defined\n",
     969                 :            :                         "DMA_INTERRUPT");
     970                 :          0 :                 return -EIO;
     971                 :            :         }
     972                 :            : 
     973                 :          3 :         if (dma_has_cap(DMA_CYCLIC, device->cap_mask) && !device->device_prep_dma_cyclic) {
     974                 :          0 :                 dev_err(device->dev,
     975                 :            :                         "Device claims capability %s, but op is not defined\n",
     976                 :            :                         "DMA_CYCLIC");
     977                 :          0 :                 return -EIO;
     978                 :            :         }
     979                 :            : 
     980                 :          3 :         if (dma_has_cap(DMA_INTERLEAVE, device->cap_mask) && !device->device_prep_interleaved_dma) {
     981                 :          0 :                 dev_err(device->dev,
     982                 :            :                         "Device claims capability %s, but op is not defined\n",
     983                 :            :                         "DMA_INTERLEAVE");
     984                 :          0 :                 return -EIO;
     985                 :            :         }
     986                 :            : 
     987                 :            : 
     988                 :          3 :         if (!device->device_tx_status) {
     989                 :          0 :                 dev_err(device->dev, "Device tx_status is not defined\n");
     990                 :          0 :                 return -EIO;
     991                 :            :         }
     992                 :            : 
     993                 :            : 
     994                 :          3 :         if (!device->device_issue_pending) {
     995                 :          0 :                 dev_err(device->dev, "Device issue_pending is not defined\n");
     996                 :          0 :                 return -EIO;
     997                 :            :         }
     998                 :            : 
     999                 :            :         /* note: this only matters in the
    1000                 :            :          * CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH=n case
    1001                 :            :          */
    1002                 :          3 :         if (device_has_all_tx_types(device))
    1003                 :            :                 dma_cap_set(DMA_ASYNC_TX, device->cap_mask);
    1004                 :            : 
    1005                 :            :         idr_ref = kmalloc(sizeof(*idr_ref), GFP_KERNEL);
    1006                 :          3 :         if (!idr_ref)
    1007                 :            :                 return -ENOMEM;
    1008                 :          3 :         rc = get_dma_id(device);
    1009                 :          3 :         if (rc != 0) {
    1010                 :          0 :                 kfree(idr_ref);
    1011                 :          0 :                 return rc;
    1012                 :            :         }
    1013                 :            : 
    1014                 :            :         atomic_set(idr_ref, 0);
    1015                 :            : 
    1016                 :            :         /* represent channels in sysfs. Probably want devs too */
    1017                 :          3 :         list_for_each_entry(chan, &device->channels, device_node) {
    1018                 :            :                 rc = -ENOMEM;
    1019                 :          3 :                 chan->local = alloc_percpu(typeof(*chan->local));
    1020                 :          3 :                 if (chan->local == NULL)
    1021                 :            :                         goto err_out;
    1022                 :          3 :                 chan->dev = kzalloc(sizeof(*chan->dev), GFP_KERNEL);
    1023                 :          3 :                 if (chan->dev == NULL) {
    1024                 :          0 :                         free_percpu(chan->local);
    1025                 :          0 :                         chan->local = NULL;
    1026                 :          0 :                         goto err_out;
    1027                 :            :                 }
    1028                 :            : 
    1029                 :          3 :                 chan->chan_id = chancnt++;
    1030                 :          3 :                 chan->dev->device.class = &dma_devclass;
    1031                 :          3 :                 chan->dev->device.parent = device->dev;
    1032                 :          3 :                 chan->dev->chan = chan;
    1033                 :          3 :                 chan->dev->idr_ref = idr_ref;
    1034                 :          3 :                 chan->dev->dev_id = device->dev_id;
    1035                 :            :                 atomic_inc(idr_ref);
    1036                 :          3 :                 dev_set_name(&chan->dev->device, "dma%dchan%d",
    1037                 :            :                              device->dev_id, chan->chan_id);
    1038                 :            : 
    1039                 :          3 :                 rc = device_register(&chan->dev->device);
    1040                 :          3 :                 if (rc) {
    1041                 :          0 :                         free_percpu(chan->local);
    1042                 :          0 :                         chan->local = NULL;
    1043                 :          0 :                         kfree(chan->dev);
    1044                 :            :                         atomic_dec(idr_ref);
    1045                 :            :                         goto err_out;
    1046                 :            :                 }
    1047                 :          3 :                 chan->client_count = 0;
    1048                 :            :         }
    1049                 :            : 
    1050                 :          3 :         if (!chancnt) {
    1051                 :          0 :                 dev_err(device->dev, "%s: device has no channels!\n", __func__);
    1052                 :            :                 rc = -ENODEV;
    1053                 :          0 :                 goto err_out;
    1054                 :            :         }
    1055                 :            : 
    1056                 :          3 :         device->chancnt = chancnt;
    1057                 :            : 
    1058                 :          3 :         mutex_lock(&dma_list_mutex);
    1059                 :            :         /* take references on public channels */
    1060                 :          3 :         if (dmaengine_ref_count && !dma_has_cap(DMA_PRIVATE, device->cap_mask))
    1061                 :          0 :                 list_for_each_entry(chan, &device->channels, device_node) {
    1062                 :            :                         /* if clients are already waiting for channels we need
    1063                 :            :                          * to take references on their behalf
    1064                 :            :                          */
    1065                 :          0 :                         if (dma_chan_get(chan) == -ENODEV) {
    1066                 :            :                                 /* note we can only get here for the first
    1067                 :            :                                  * channel as the remaining channels are
    1068                 :            :                                  * guaranteed to get a reference
    1069                 :            :                                  */
    1070                 :            :                                 rc = -ENODEV;
    1071                 :          0 :                                 mutex_unlock(&dma_list_mutex);
    1072                 :          0 :                                 goto err_out;
    1073                 :            :                         }
    1074                 :            :                 }
    1075                 :          3 :         list_add_tail_rcu(&device->global_node, &dma_device_list);
    1076                 :          3 :         if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
    1077                 :          3 :                 device->privatecnt++;        /* Always private */
    1078                 :          3 :         dma_channel_rebalance();
    1079                 :          3 :         mutex_unlock(&dma_list_mutex);
    1080                 :            : 
    1081                 :          3 :         return 0;
    1082                 :            : 
    1083                 :            : err_out:
    1084                 :            :         /* if we never registered a channel just release the idr */
    1085                 :          0 :         if (atomic_read(idr_ref) == 0) {
    1086                 :          0 :                 ida_free(&dma_ida, device->dev_id);
    1087                 :          0 :                 kfree(idr_ref);
    1088                 :          0 :                 return rc;
    1089                 :            :         }
    1090                 :            : 
    1091                 :          0 :         list_for_each_entry(chan, &device->channels, device_node) {
    1092                 :          0 :                 if (chan->local == NULL)
    1093                 :          0 :                         continue;
    1094                 :          0 :                 mutex_lock(&dma_list_mutex);
    1095                 :          0 :                 chan->dev->chan = NULL;
    1096                 :          0 :                 mutex_unlock(&dma_list_mutex);
    1097                 :          0 :                 device_unregister(&chan->dev->device);
    1098                 :          0 :                 free_percpu(chan->local);
    1099                 :            :         }
    1100                 :            :         return rc;
    1101                 :            : }
    1102                 :            : EXPORT_SYMBOL(dma_async_device_register);
    1103                 :            : 
    1104                 :            : /**
    1105                 :            :  * dma_async_device_unregister - unregister a DMA device
    1106                 :            :  * @device: &dma_device
    1107                 :            :  *
    1108                 :            :  * This routine is called by dma driver exit routines, dmaengine holds module
    1109                 :            :  * references to prevent it being called while channels are in use.
    1110                 :            :  */
    1111                 :          0 : void dma_async_device_unregister(struct dma_device *device)
    1112                 :            : {
    1113                 :            :         struct dma_chan *chan;
    1114                 :            : 
    1115                 :          0 :         mutex_lock(&dma_list_mutex);
    1116                 :            :         list_del_rcu(&device->global_node);
    1117                 :          0 :         dma_channel_rebalance();
    1118                 :          0 :         mutex_unlock(&dma_list_mutex);
    1119                 :            : 
    1120                 :          0 :         list_for_each_entry(chan, &device->channels, device_node) {
    1121                 :          0 :                 WARN_ONCE(chan->client_count,
    1122                 :            :                           "%s called while %d clients hold a reference\n",
    1123                 :            :                           __func__, chan->client_count);
    1124                 :          0 :                 mutex_lock(&dma_list_mutex);
    1125                 :          0 :                 chan->dev->chan = NULL;
    1126                 :          0 :                 mutex_unlock(&dma_list_mutex);
    1127                 :          0 :                 device_unregister(&chan->dev->device);
    1128                 :          0 :                 free_percpu(chan->local);
    1129                 :            :         }
    1130                 :          0 : }
    1131                 :            : EXPORT_SYMBOL(dma_async_device_unregister);
    1132                 :            : 
    1133                 :          0 : static void dmam_device_release(struct device *dev, void *res)
    1134                 :            : {
    1135                 :            :         struct dma_device *device;
    1136                 :            : 
    1137                 :          0 :         device = *(struct dma_device **)res;
    1138                 :          0 :         dma_async_device_unregister(device);
    1139                 :          0 : }
    1140                 :            : 
    1141                 :            : /**
    1142                 :            :  * dmaenginem_async_device_register - registers DMA devices found
    1143                 :            :  * @device: &dma_device
    1144                 :            :  *
    1145                 :            :  * The operation is managed and will be undone on driver detach.
    1146                 :            :  */
    1147                 :          0 : int dmaenginem_async_device_register(struct dma_device *device)
    1148                 :            : {
    1149                 :            :         void *p;
    1150                 :            :         int ret;
    1151                 :            : 
    1152                 :            :         p = devres_alloc(dmam_device_release, sizeof(void *), GFP_KERNEL);
    1153                 :          0 :         if (!p)
    1154                 :            :                 return -ENOMEM;
    1155                 :            : 
    1156                 :          0 :         ret = dma_async_device_register(device);
    1157                 :          0 :         if (!ret) {
    1158                 :          0 :                 *(struct dma_device **)p = device;
    1159                 :          0 :                 devres_add(device->dev, p);
    1160                 :            :         } else {
    1161                 :          0 :                 devres_free(p);
    1162                 :            :         }
    1163                 :            : 
    1164                 :          0 :         return ret;
    1165                 :            : }
    1166                 :            : EXPORT_SYMBOL(dmaenginem_async_device_register);
    1167                 :            : 
    1168                 :            : struct dmaengine_unmap_pool {
    1169                 :            :         struct kmem_cache *cache;
    1170                 :            :         const char *name;
    1171                 :            :         mempool_t *pool;
    1172                 :            :         size_t size;
    1173                 :            : };
    1174                 :            : 
    1175                 :            : #define __UNMAP_POOL(x) { .size = x, .name = "dmaengine-unmap-" __stringify(x) }
    1176                 :            : static struct dmaengine_unmap_pool unmap_pool[] = {
    1177                 :            :         __UNMAP_POOL(2),
    1178                 :            :         #if IS_ENABLED(CONFIG_DMA_ENGINE_RAID)
    1179                 :            :         __UNMAP_POOL(16),
    1180                 :            :         __UNMAP_POOL(128),
    1181                 :            :         __UNMAP_POOL(256),
    1182                 :            :         #endif
    1183                 :            : };
    1184                 :            : 
    1185                 :          0 : static struct dmaengine_unmap_pool *__get_unmap_pool(int nr)
    1186                 :            : {
    1187                 :          0 :         int order = get_count_order(nr);
    1188                 :            : 
    1189                 :          0 :         switch (order) {
    1190                 :            :         case 0 ... 1:
    1191                 :            :                 return &unmap_pool[0];
    1192                 :            : #if IS_ENABLED(CONFIG_DMA_ENGINE_RAID)
    1193                 :            :         case 2 ... 4:
    1194                 :            :                 return &unmap_pool[1];
    1195                 :            :         case 5 ... 7:
    1196                 :            :                 return &unmap_pool[2];
    1197                 :            :         case 8:
    1198                 :            :                 return &unmap_pool[3];
    1199                 :            : #endif
    1200                 :            :         default:
    1201                 :          0 :                 BUG();
    1202                 :            :                 return NULL;
    1203                 :            :         }
    1204                 :            : }
    1205                 :            : 
    1206                 :          0 : static void dmaengine_unmap(struct kref *kref)
    1207                 :            : {
    1208                 :          0 :         struct dmaengine_unmap_data *unmap = container_of(kref, typeof(*unmap), kref);
    1209                 :          0 :         struct device *dev = unmap->dev;
    1210                 :            :         int cnt, i;
    1211                 :            : 
    1212                 :          0 :         cnt = unmap->to_cnt;
    1213                 :          0 :         for (i = 0; i < cnt; i++)
    1214                 :          0 :                 dma_unmap_page(dev, unmap->addr[i], unmap->len,
    1215                 :            :                                DMA_TO_DEVICE);
    1216                 :          0 :         cnt += unmap->from_cnt;
    1217                 :          0 :         for (; i < cnt; i++)
    1218                 :          0 :                 dma_unmap_page(dev, unmap->addr[i], unmap->len,
    1219                 :            :                                DMA_FROM_DEVICE);
    1220                 :          0 :         cnt += unmap->bidi_cnt;
    1221                 :          0 :         for (; i < cnt; i++) {
    1222                 :          0 :                 if (unmap->addr[i] == 0)
    1223                 :          0 :                         continue;
    1224                 :          0 :                 dma_unmap_page(dev, unmap->addr[i], unmap->len,
    1225                 :            :                                DMA_BIDIRECTIONAL);
    1226                 :            :         }
    1227                 :          0 :         cnt = unmap->map_cnt;
    1228                 :          0 :         mempool_free(unmap, __get_unmap_pool(cnt)->pool);
    1229                 :          0 : }
    1230                 :            : 
    1231                 :          0 : void dmaengine_unmap_put(struct dmaengine_unmap_data *unmap)
    1232                 :            : {
    1233                 :          0 :         if (unmap)
    1234                 :          0 :                 kref_put(&unmap->kref, dmaengine_unmap);
    1235                 :          0 : }
    1236                 :            : EXPORT_SYMBOL_GPL(dmaengine_unmap_put);
    1237                 :            : 
    1238                 :          0 : static void dmaengine_destroy_unmap_pool(void)
    1239                 :            : {
    1240                 :            :         int i;
    1241                 :            : 
    1242                 :          0 :         for (i = 0; i < ARRAY_SIZE(unmap_pool); i++) {
    1243                 :            :                 struct dmaengine_unmap_pool *p = &unmap_pool[i];
    1244                 :            : 
    1245                 :          0 :                 mempool_destroy(p->pool);
    1246                 :          0 :                 p->pool = NULL;
    1247                 :          0 :                 kmem_cache_destroy(p->cache);
    1248                 :          0 :                 p->cache = NULL;
    1249                 :            :         }
    1250                 :          0 : }
    1251                 :            : 
    1252                 :          3 : static int __init dmaengine_init_unmap_pool(void)
    1253                 :            : {
    1254                 :            :         int i;
    1255                 :            : 
    1256                 :          3 :         for (i = 0; i < ARRAY_SIZE(unmap_pool); i++) {
    1257                 :            :                 struct dmaengine_unmap_pool *p = &unmap_pool[i];
    1258                 :            :                 size_t size;
    1259                 :            : 
    1260                 :          3 :                 size = sizeof(struct dmaengine_unmap_data) +
    1261                 :          3 :                        sizeof(dma_addr_t) * p->size;
    1262                 :            : 
    1263                 :          3 :                 p->cache = kmem_cache_create(p->name, size, 0,
    1264                 :            :                                              SLAB_HWCACHE_ALIGN, NULL);
    1265                 :          3 :                 if (!p->cache)
    1266                 :            :                         break;
    1267                 :          3 :                 p->pool = mempool_create_slab_pool(1, p->cache);
    1268                 :          3 :                 if (!p->pool)
    1269                 :            :                         break;
    1270                 :            :         }
    1271                 :            : 
    1272                 :          3 :         if (i == ARRAY_SIZE(unmap_pool))
    1273                 :            :                 return 0;
    1274                 :            : 
    1275                 :          0 :         dmaengine_destroy_unmap_pool();
    1276                 :          0 :         return -ENOMEM;
    1277                 :            : }
    1278                 :            : 
    1279                 :            : struct dmaengine_unmap_data *
    1280                 :          0 : dmaengine_get_unmap_data(struct device *dev, int nr, gfp_t flags)
    1281                 :            : {
    1282                 :            :         struct dmaengine_unmap_data *unmap;
    1283                 :            : 
    1284                 :          0 :         unmap = mempool_alloc(__get_unmap_pool(nr)->pool, flags);
    1285                 :          0 :         if (!unmap)
    1286                 :            :                 return NULL;
    1287                 :            : 
    1288                 :          0 :         memset(unmap, 0, sizeof(*unmap));
    1289                 :            :         kref_init(&unmap->kref);
    1290                 :          0 :         unmap->dev = dev;
    1291                 :          0 :         unmap->map_cnt = nr;
    1292                 :            : 
    1293                 :          0 :         return unmap;
    1294                 :            : }
    1295                 :            : EXPORT_SYMBOL(dmaengine_get_unmap_data);
    1296                 :            : 
    1297                 :          3 : void dma_async_tx_descriptor_init(struct dma_async_tx_descriptor *tx,
    1298                 :            :         struct dma_chan *chan)
    1299                 :            : {
    1300                 :          3 :         tx->chan = chan;
    1301                 :            :         #ifdef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
    1302                 :            :         spin_lock_init(&tx->lock);
    1303                 :            :         #endif
    1304                 :          3 : }
    1305                 :            : EXPORT_SYMBOL(dma_async_tx_descriptor_init);
    1306                 :            : 
    1307                 :            : /* dma_wait_for_async_tx - spin wait for a transaction to complete
    1308                 :            :  * @tx: in-flight transaction to wait on
    1309                 :            :  */
    1310                 :            : enum dma_status
    1311                 :          0 : dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
    1312                 :            : {
    1313                 :          0 :         unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000);
    1314                 :            : 
    1315                 :          0 :         if (!tx)
    1316                 :            :                 return DMA_COMPLETE;
    1317                 :            : 
    1318                 :          0 :         while (tx->cookie == -EBUSY) {
    1319                 :          0 :                 if (time_after_eq(jiffies, dma_sync_wait_timeout)) {
    1320                 :          0 :                         dev_err(tx->chan->device->dev,
    1321                 :            :                                 "%s timeout waiting for descriptor submission\n",
    1322                 :            :                                 __func__);
    1323                 :          0 :                         return DMA_ERROR;
    1324                 :            :                 }
    1325                 :          0 :                 cpu_relax();
    1326                 :            :         }
    1327                 :          0 :         return dma_sync_wait(tx->chan, tx->cookie);
    1328                 :            : }
    1329                 :            : EXPORT_SYMBOL_GPL(dma_wait_for_async_tx);
    1330                 :            : 
    1331                 :            : /* dma_run_dependencies - helper routine for dma drivers to process
    1332                 :            :  *      (start) dependent operations on their target channel
    1333                 :            :  * @tx: transaction with dependencies
    1334                 :            :  */
    1335                 :          0 : void dma_run_dependencies(struct dma_async_tx_descriptor *tx)
    1336                 :            : {
    1337                 :            :         struct dma_async_tx_descriptor *dep = txd_next(tx);
    1338                 :            :         struct dma_async_tx_descriptor *dep_next;
    1339                 :            :         struct dma_chan *chan;
    1340                 :            : 
    1341                 :            :         if (!dep)
    1342                 :          0 :                 return;
    1343                 :            : 
    1344                 :            :         /* we'll submit tx->next now, so clear the link */
    1345                 :            :         txd_clear_next(tx);
    1346                 :            :         chan = dep->chan;
    1347                 :            : 
    1348                 :            :         /* keep submitting up until a channel switch is detected
    1349                 :            :          * in that case we will be called again as a result of
    1350                 :            :          * processing the interrupt from async_tx_channel_switch
    1351                 :            :          */
    1352                 :            :         for (; dep; dep = dep_next) {
    1353                 :            :                 txd_lock(dep);
    1354                 :            :                 txd_clear_parent(dep);
    1355                 :            :                 dep_next = txd_next(dep);
    1356                 :            :                 if (dep_next && dep_next->chan == chan)
    1357                 :            :                         txd_clear_next(dep); /* ->next will be submitted */
    1358                 :            :                 else
    1359                 :            :                         dep_next = NULL; /* submit current dep and terminate */
    1360                 :            :                 txd_unlock(dep);
    1361                 :            : 
    1362                 :            :                 dep->tx_submit(dep);
    1363                 :            :         }
    1364                 :            : 
    1365                 :            :         chan->device->device_issue_pending(chan);
    1366                 :            : }
    1367                 :            : EXPORT_SYMBOL_GPL(dma_run_dependencies);
    1368                 :            : 
    1369                 :          3 : static int __init dma_bus_init(void)
    1370                 :            : {
    1371                 :          3 :         int err = dmaengine_init_unmap_pool();
    1372                 :            : 
    1373                 :          3 :         if (err)
    1374                 :            :                 return err;
    1375                 :          3 :         return class_register(&dma_devclass);
    1376                 :            : }
    1377                 :            : arch_initcall(dma_bus_init);
    1378                 :            : 
    1379                 :            : 
    

Generated by: LCOV version 1.14