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 : 808 : __dma_device_satisfies_mask(struct dma_device *device,
171 : : const dma_cap_mask_t *want)
172 : : {
173 : : dma_cap_mask_t has;
174 : :
175 : 808 : bitmap_and(has.bits, want->bits, device->cap_mask.bits,
176 : : DMA_TX_TYPE_END);
177 : 808 : 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 : 1212 : 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 : 808 : 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 [ - + ]: 808 : if (chan->client_count) {
214 : 0 : __module_get(owner);
215 : 0 : goto out;
216 : : }
217 : :
218 [ + - ]: 808 : if (!try_module_get(owner))
219 : : return -ENODEV;
220 : :
221 : : /* allocate upon first client reference */
222 [ + - ]: 808 : if (chan->device->device_alloc_chan_resources) {
223 : 808 : ret = chan->device->device_alloc_chan_resources(chan);
224 [ + - ]: 808 : if (ret < 0)
225 : : goto err_out;
226 : : }
227 : :
228 [ - + ]: 1616 : if (!dma_has_cap(DMA_PRIVATE, chan->device->cap_mask))
229 : 0 : balance_ref_count(chan);
230 : :
231 : : out:
232 : 808 : chan->client_count++;
233 : 808 : 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 : 404 : static void dma_chan_put(struct dma_chan *chan)
247 : : {
248 : : /* This channel is not in use, bail out */
249 [ + - ]: 404 : if (!chan->client_count)
250 : 404 : return;
251 : :
252 : 404 : chan->client_count--;
253 : 404 : module_put(dma_chan_to_owner(chan));
254 : :
255 : : /* This channel is not in use anymore, free it */
256 [ + - + - ]: 404 : if (!chan->client_count && chan->device->device_free_chan_resources) {
257 : : /* Make sure all operations have completed */
258 : 404 : dmaengine_synchronize(chan);
259 : 404 : chan->device->device_free_chan_resources(chan);
260 : : }
261 : :
262 : : /* If the channel is used via a DMA request router, free the mapping */
263 [ - + # # ]: 404 : 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 : 404 : 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 : 404 : clear_bit(DMA_INTERRUPT, dma_cap_mask_all.bits);
321 : 404 : clear_bit(DMA_PRIVATE, dma_cap_mask_all.bits);
322 : 404 : clear_bit(DMA_SLAVE, dma_cap_mask_all.bits);
323 : :
324 [ + + ]: 4444 : for_each_dma_cap_mask(cap, dma_cap_mask_all) {
325 : 4040 : channel_table[cap] = alloc_percpu(struct dma_chan_tbl_ent);
326 [ + - ]: 4040 : if (!channel_table[cap]) {
327 : : err = -ENOMEM;
328 : : break;
329 : : }
330 : : }
331 : :
332 [ - + ]: 404 : 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 : 404 : 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 : 404 : 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 [ + + ]: 4444 : for_each_dma_cap_mask(cap, dma_cap_mask_all)
441 [ + + ]: 20200 : for_each_possible_cpu(cpu)
442 : 16160 : per_cpu_ptr(channel_table[cap], cpu)->chan = NULL;
443 : :
444 [ + + ]: 808 : list_for_each_entry(device, &dma_device_list, global_node) {
445 [ + - ]: 404 : if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
446 : 404 : 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 [ - + ]: 404 : if (!dmaengine_ref_count)
453 : 404 : 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 : 808 : 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 [ + - + - ]: 808 : 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 [ + - - + ]: 1616 : 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 [ + - ]: 808 : list_for_each_entry(chan, &dev->channels, device_node) {
520 [ - + ]: 808 : if (chan->client_count) {
521 : : dev_dbg(dev->dev, "%s: %s busy\n",
522 : : __func__, dma_chan_name(chan));
523 : 0 : continue;
524 : : }
525 [ - + # # ]: 808 : 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 : 808 : return chan;
531 : : }
532 : :
533 : : return NULL;
534 : : }
535 : :
536 : 808 : 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 : 808 : struct dma_chan *chan = private_candidate(mask, device, fn, fn_param);
541 : : int err;
542 : :
543 [ + - ]: 808 : 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 : 808 : device->privatecnt++;
551 : 808 : err = dma_chan_get(chan);
552 : :
553 [ - + ]: 808 : 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 [ + - ]: 808 : 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 : 808 : 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 : 808 : mutex_lock(&dma_list_mutex);
618 : :
619 : 808 : chan = find_candidate(device, &mask, NULL, NULL);
620 : :
621 : 808 : mutex_unlock(&dma_list_mutex);
622 : :
623 [ + - ]: 808 : 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 : 404 : 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 [ - + ]: 404 : 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 : 1212 : 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 [ + - ]: 1212 : if (dev->of_node)
701 : 1212 : 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 [ + - ]: 1212 : if (chan) {
708 : : /* Valid channel found or requester needs to be deferred */
709 [ + + + - ]: 1616 : 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 : 404 : mutex_lock(&dma_list_mutex);
715 [ + + ]: 808 : list_for_each_entry_safe(d, _d, &dma_device_list, global_node) {
716 : : dma_cap_mask_t mask;
717 : 404 : const struct dma_slave_map *map = dma_filter_match(d, name, dev);
718 : :
719 [ + - ]: 404 : if (!map)
720 : 404 : 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 : 404 : mutex_unlock(&dma_list_mutex);
730 : :
731 [ + - ]: 404 : 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 : 808 : struct dma_chan *dma_request_slave_channel(struct device *dev,
743 : : const char *name)
744 : : {
745 : 808 : struct dma_chan *ch = dma_request_chan(dev, name);
746 [ + - ]: 808 : if (IS_ERR(ch))
747 : : return NULL;
748 : :
749 : 808 : 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 : 404 : void dma_release_channel(struct dma_chan *chan)
781 : : {
782 : 404 : mutex_lock(&dma_list_mutex);
783 [ - + # # ]: 404 : WARN_ONCE(chan->client_count != 1,
784 : : "chan reference count %d != 1\n", chan->client_count);
785 : 404 : dma_chan_put(chan);
786 : : /* drop PRIVATE cap enabled by __dma_request_channel() */
787 [ - + ]: 404 : if (--chan->device->privatecnt == 0)
788 : 0 : dma_cap_clear(DMA_PRIVATE, chan->device->cap_mask);
789 : 404 : mutex_unlock(&dma_list_mutex);
790 : 404 : }
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 : 404 : 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 [ + - ]: 404 : if (!dma_has_cap(DMA_MEMCPY, device->cap_mask))
867 : : return false;
868 : : #endif
869 : :
870 : : #if IS_ENABLED(CONFIG_ASYNC_XOR)
871 [ - + ]: 404 : 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 : 404 : static int get_dma_id(struct dma_device *device)
894 : : {
895 : : int rc = ida_alloc(&dma_ida, GFP_KERNEL);
896 : :
897 [ + - ]: 404 : if (rc < 0)
898 : : return rc;
899 : 404 : device->dev_id = rc;
900 : 404 : return 0;
901 : : }
902 : :
903 : : /**
904 : : * dma_async_device_register - registers DMA devices found
905 : : * @device: &dma_device
906 : : */
907 : 404 : 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 [ + - ]: 404 : if (!device)
914 : : return -ENODEV;
915 : :
916 : : /* validate device routines */
917 [ - + ]: 404 : if (!device->dev) {
918 : 0 : pr_err("DMAdevice must have dev\n");
919 : 0 : return -EIO;
920 : : }
921 : :
922 : 404 : device->owner = device->dev->driver->owner;
923 : :
924 [ + - - + ]: 404 : 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 [ - + # # ]: 404 : 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 [ - + # # ]: 404 : 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 [ - + # # ]: 404 : 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 [ - + # # ]: 404 : 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 [ - + # # ]: 404 : 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 [ - + # # ]: 404 : 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 [ + - - + ]: 404 : 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 [ - + # # ]: 404 : 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 [ - + ]: 404 : 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 [ - + ]: 404 : 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 [ - + ]: 404 : 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 [ + - ]: 404 : if (!idr_ref)
1007 : : return -ENOMEM;
1008 : 404 : rc = get_dma_id(device);
1009 [ - + ]: 404 : 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 [ + + ]: 4444 : list_for_each_entry(chan, &device->channels, device_node) {
1018 : : rc = -ENOMEM;
1019 : 4040 : chan->local = alloc_percpu(typeof(*chan->local));
1020 [ + - ]: 4040 : if (chan->local == NULL)
1021 : : goto err_out;
1022 : 4040 : chan->dev = kzalloc(sizeof(*chan->dev), GFP_KERNEL);
1023 [ - + ]: 4040 : if (chan->dev == NULL) {
1024 : 0 : free_percpu(chan->local);
1025 : 0 : chan->local = NULL;
1026 : 0 : goto err_out;
1027 : : }
1028 : :
1029 : 4040 : chan->chan_id = chancnt++;
1030 : 4040 : chan->dev->device.class = &dma_devclass;
1031 : 4040 : chan->dev->device.parent = device->dev;
1032 : 4040 : chan->dev->chan = chan;
1033 : 4040 : chan->dev->idr_ref = idr_ref;
1034 : 4040 : chan->dev->dev_id = device->dev_id;
1035 : : atomic_inc(idr_ref);
1036 : 4040 : dev_set_name(&chan->dev->device, "dma%dchan%d",
1037 : : device->dev_id, chan->chan_id);
1038 : :
1039 : 4040 : rc = device_register(&chan->dev->device);
1040 [ - + ]: 4040 : 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 : 4040 : chan->client_count = 0;
1048 : : }
1049 : :
1050 [ - + ]: 404 : 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 : 404 : device->chancnt = chancnt;
1057 : :
1058 : 404 : mutex_lock(&dma_list_mutex);
1059 : : /* take references on public channels */
1060 [ - + # # ]: 404 : 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 : 404 : list_add_tail_rcu(&device->global_node, &dma_device_list);
1076 [ + - ]: 404 : if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
1077 : 404 : device->privatecnt++; /* Always private */
1078 : 404 : dma_channel_rebalance();
1079 : 404 : mutex_unlock(&dma_list_mutex);
1080 : :
1081 : 404 : 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 : 404 : static int __init dmaengine_init_unmap_pool(void)
1253 : : {
1254 : : int i;
1255 : :
1256 [ + + ]: 808 : for (i = 0; i < ARRAY_SIZE(unmap_pool); i++) {
1257 : : struct dmaengine_unmap_pool *p = &unmap_pool[i];
1258 : : size_t size;
1259 : :
1260 : 404 : size = sizeof(struct dmaengine_unmap_data) +
1261 : 404 : sizeof(dma_addr_t) * p->size;
1262 : :
1263 : 404 : p->cache = kmem_cache_create(p->name, size, 0,
1264 : : SLAB_HWCACHE_ALIGN, NULL);
1265 [ + - ]: 404 : if (!p->cache)
1266 : : break;
1267 : 404 : p->pool = mempool_create_slab_pool(1, p->cache);
1268 [ + - ]: 404 : if (!p->pool)
1269 : : break;
1270 : : }
1271 : :
1272 [ - + ]: 404 : 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 : 2091394 : void dma_async_tx_descriptor_init(struct dma_async_tx_descriptor *tx,
1298 : : struct dma_chan *chan)
1299 : : {
1300 : 2091394 : tx->chan = chan;
1301 : : #ifdef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
1302 : : spin_lock_init(&tx->lock);
1303 : : #endif
1304 : 2091394 : }
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 : 404 : static int __init dma_bus_init(void)
1370 : : {
1371 : 404 : int err = dmaengine_init_unmap_pool();
1372 : :
1373 [ + - ]: 404 : if (err)
1374 : : return err;
1375 : 404 : return class_register(&dma_devclass);
1376 : : }
1377 : : arch_initcall(dma_bus_init);
1378 : :
1379 : :
|
