rpmsg: rpc: introduce a new rpmsg_rpc driver
[rpmsg/rpmsg.git] / drivers / rpmsg / rpmsg_rpc_dmabuf.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Remote Processor Procedure Call Driver
4  *
5  * Copyright (C) 2012-2019 Texas Instruments Incorporated - http://www.ti.com/
6  *      Erik Rainey <erik.rainey@ti.com>
7  *      Suman Anna <s-anna@ti.com>
8  */
10 #include <linux/dma-buf.h>
11 #include <linux/rpmsg_rpc.h>
13 #include "rpmsg_rpc_internal.h"
15 #if defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_SOC_OMAP5) || \
16         defined(CONFIG_SOC_DRA7XX)
17 /*
18  * TODO: Remove tiler_stride_from_region & rppc_recalc_off from here, and
19  *       rely on OMAPDRM/TILER code for OMAP dependencies
20  */
22 /**
23  * tiler_stride_from_region() - calculate stride value for OMAP TILER
24  * @localphys:  The local physical address.
25  *
26  * Returns the stride value as seen by remote processors based on the local
27  * address given to the function. This stride value is calculated based on the
28  * actual bus address, and is assumed that the TILER regions are mapped in a
29  * in a linear fashion.
30  *
31  * The physical address range decoding of local addresses is as follows:
32  *
33  * 0x60000000 - 0x67FFFFFF : 8-bit region (Stride is 16K bytes)
34  * 0x68000000 - 0x6FFFFFFF : 16-bit region (Stride is 32K bytes)
35  * 0x70000000 - 0x77FFFFFF : 32-bit region (Stride is 32K bytes)
36  * 0x78000000 - 0x7FFFFFFF : Page mode region (Stride is 0 bytes)
37  *
38  * Return: stride value
39  */
40 static long tiler_stride_from_region(phys_addr_t localphys)
41 {
42         switch (localphys & 0xf8000000) {
43         case 0x60000000:
44                 return 0x4000;
45         case 0x68000000:
46         case 0x70000000:
47                 return 0x8000;
48         default:
49                 return 0;
50         }
51 }
53 /**
54  * rppc_recalc_off() - Recalculate the unsigned offset in a buffer due to
55  *                     it's location in the TILER.
56  * @lpa:        local physical address
57  * @uoff:       unsigned offset
58  *
59  * Return: adjusted offset accounting for TILER region
60  */
61 static long rppc_recalc_off(phys_addr_t lpa, long uoff)
62 {
63         long stride = tiler_stride_from_region(lpa);
65         return (stride != 0) ? (stride * (uoff / PAGE_SIZE)) +
66                                 (uoff & (PAGE_SIZE - 1)) : uoff;
67 }
68 #else
69 static inline long rppc_recalc_off(phys_addr_t lpa, long uoff)
70 {
71         return uoff;
72 }
73 #endif
75 /**
76  * rppc_alloc_dmabuf - import a buffer and store in a rppc buffer descriptor
77  * @rpc - rppc instance handle
78  * @fd - dma_buf file descriptor
79  * @autoreg: flag indicating the mode of creation
80  *
81  * This function primarily imports a buffer into the driver and holds
82  * a reference to the buffer on behalf of the remote processor. The
83  * buffer to be imported is represented by a dma-buf file descriptor,
84  * and as such is agnostic of the buffer allocator and/or exporter.
85  * The buffer is imported using the dma-buf api, and a driver specific
86  * buffer descriptor is used to store the imported buffer properties.
87  * The imported buffers are all stored in a rppc instance specific
88  * idr, to be used for looking up and cleaning up the driver buffer
89  * descriptors.
90  *
91  * The @autoreg field is used to dictate the manner in which the buffer
92  * is imported. The user-side can pre-register the buffers with the driver
93  * (which will import the buffers) if the application is going to use
94  * these repeatedly in consecutive function invocations. The buffers
95  * are auto-imported if the user-side has not registered them previously
96  * and are un-imported once the remote function call returns.
97  *
98  * This function is to be called only after checking that buffer has
99  * not been imported already (see rppc_find_dmabuf).
100  *
101  * Return: allocated rppc_dma_buf or error
102  */
103 struct rppc_dma_buf *rppc_alloc_dmabuf(struct rppc_instance *rpc, int fd,
104                                        bool autoreg)
106         struct rppc_device *rppcdev = rpc->rppcdev;
107         struct rppc_dma_buf *dma;
108         void *ret;
109         int id;
111         dma = kzalloc(sizeof(*dma), GFP_KERNEL);
112         if (!dma)
113                 return ERR_PTR(-ENOMEM);
115         dma->fd = fd;
116         dma->autoreg = !!autoreg;
117         dma->buf = dma_buf_get(dma->fd);
118         if (IS_ERR(dma->buf)) {
119                 ret = dma->buf;
120                 goto free_dma;
121         }
123         dma->attach = dma_buf_attach(dma->buf, rppcdev->dev);
124         if (IS_ERR(dma->attach)) {
125                 ret = dma->attach;
126                 goto put_buf;
127         }
129         dma->sgt = dma_buf_map_attachment(dma->attach, DMA_BIDIRECTIONAL);
130         if (IS_ERR(dma->sgt)) {
131                 ret = dma->sgt;
132                 goto detach_buf;
133         }
135         dma->pa = sg_dma_address(dma->sgt->sgl);
136         mutex_lock(&rpc->lock);
137         id = idr_alloc(&rpc->dma_idr, dma, 0, 0, GFP_KERNEL);
138         dma->id = id;
139         mutex_unlock(&rpc->lock);
140         if (id < 0) {
141                 ret = ERR_PTR(id);
142                 goto unmap_buf;
143         }
145         return dma;
147 unmap_buf:
148         dma_buf_unmap_attachment(dma->attach, dma->sgt, DMA_BIDIRECTIONAL);
149 detach_buf:
150         dma_buf_detach(dma->buf, dma->attach);
151 put_buf:
152         dma_buf_put(dma->buf);
153 free_dma:
154         kfree(dma);
156         return ret;
159 /**
160  * rppc_free_dmabuf - release the imported buffer
161  * @id: idr index of the imported buffer descriptor
162  * @p: imported buffer descriptor allocated during rppc_alloc_dmabuf
163  * @data: rpc instance handle
164  *
165  * This function is used to release a buffer that has been previously
166  * imported through a rppc_alloc_dmabuf call. The function can be used
167  * either individually for releasing a specific buffer or in a loop iterator
168  * for releasing all the buffers associated with a remote function call, or
169  * during cleanup of the rpc instance.
170  *
171  * Return: 0 on success, and -ENOENT if invalid pointers passed in
172  */
173 int rppc_free_dmabuf(int id, void *p, void *data)
175         struct rppc_dma_buf *dma = p;
176         struct rppc_instance *rpc = data;
178         if (!dma || !rpc)
179                 return -ENOENT;
181         dma_buf_unmap_attachment(dma->attach, dma->sgt, DMA_BIDIRECTIONAL);
182         dma_buf_detach(dma->buf, dma->attach);
183         dma_buf_put(dma->buf);
184         WARN_ON(id != dma->id);
185         idr_remove(&rpc->dma_idr, id);
186         kfree(dma);
188         return 0;
191 /**
192  * rppc_free_auto_dmabuf - release an auto-registered imported buffer
193  * @id: idr index of the imported buffer descriptor
194  * @p: imported buffer descriptor allocated during the rppc_alloc_dmabuf
195  * @data: rpc instance handle
196  *
197  * This function is used to release a buffer that has been previously
198  * imported automatically in the remote function invocation path (for
199  * rppc_alloc_dmabuf invocations with autoreg set as true). The function
200  * is used as a loop iterator for releasing all such buffers associated
201  * with a remote function call, and is called after processing the
202  * translations while handling the return message of an executed function
203  * call.
204  *
205  * Return: 0 on success or if the buffer is not auto-imported, and -ENOENT
206  *         if invalid pointers passed in
207  */
208 static int rppc_free_auto_dmabuf(int id, void *p, void *data)
210         struct rppc_dma_buf *dma = p;
211         struct rppc_instance *rpc = data;
213         if (WARN_ON(!dma || !rpc))
214                 return -ENOENT;
216         if (!dma->autoreg)
217                 return 0;
219         rppc_free_dmabuf(id, p, data);
220         return 0;
223 /**
224  * find_dma_by_fd - find the allocated buffer descriptor
225  * @id: idr loop index
226  * @p: imported buffer descriptor associated with each idr index @id
227  * @data: dma-buf file descriptor of the buffer
228  *
229  * This is a idr iterator helper function, used for checking if a buffer
230  * has been imported before and present within the rpc instance's idr.
231  *
232  * Return: rpc buffer descriptor if file descriptor matches, and 0 otherwise
233  */
234 static int find_dma_by_fd(int id, void *p, void *data)
236         struct rppc_dma_buf *dma = p;
237         int fd = (int)data;
239         if (dma->fd == fd)
240                 return (int)p;
242         return 0;
245 /**
246  * rppc_find_dmabuf - find and return the rppc buffer descriptor of an imported
247  *                    buffer
248  * @rpc: rpc instance
249  * @fd: dma-buf file descriptor of the buffer
250  *
251  * This function is used to find and return the rppc buffer descriptor of an
252  * imported buffer. The function is used to check if ia buffer has already
253  * been imported (during manual registration to return an error), and to return
254  * the rppc buffer descriptor to be used for freeing (during manual
255  * deregistration). It is also used during auto-registration to see if the
256  * buffer needs to be imported through a rppc_alloc_dmabuf if not found.
257  *
258  * Return: rppc buffer descriptor of the buffer if it has already been imported,
259  *         or NULL otherwise.
260  */
261 struct rppc_dma_buf *rppc_find_dmabuf(struct rppc_instance *rpc, int fd)
263         struct rppc_dma_buf *node = NULL;
264         void *data = (void *)fd;
266         dev_dbg(rpc->rppcdev->dev, "looking for fd %u\n", fd);
268         mutex_lock(&rpc->lock);
269         node = (struct rppc_dma_buf *)
270                         idr_for_each(&rpc->dma_idr, find_dma_by_fd, data);
271         mutex_unlock(&rpc->lock);
273         dev_dbg(rpc->rppcdev->dev, "returning node %p for fd %u\n",
274                 node, fd);
276         return node;
279 /**
280  * rppc_map_page - import and map a kernel page in a dma_buf
281  * @rpc - rppc instance handle
282  * @fd: file descriptor of the dma_buf to import
283  * @offset: offset of the translate location within the buffer
284  * @base_ptr: pointer for returning mapped kernel address
285  * @dmabuf: pointer for returning the imported dma_buf
286  *
287  * A helper function to import the dma_buf buffer and map into kernel
288  * the page containing the offset within the buffer. The function is
289  * called by rppc_xlate_buffers and returns the pointers to the kernel
290  * mapped address and the imported dma_buf handle in arguments. The
291  * mapping is used for performing in-place translation of the user
292  * provided pointer at location @offset within the buffer.
293  *
294  * The mapping is achieved through the appropriate dma_buf ops, and
295  * the page will be unmapped after performing the translation. See
296  * also rppc_unmap_page.
297  *
298  * Return: 0 on success, or an appropriate failure code otherwise
299  */
300 static int rppc_map_page(struct rppc_instance *rpc, int fd, u32 offset,
301                          u8 **base_ptr, struct dma_buf **dmabuf)
303         int ret = 0;
304         u8 *ptr = NULL;
305         struct dma_buf *dbuf = NULL;
306         u32 pg_offset;
307         unsigned long pg_num;
308         size_t begin, end = PAGE_SIZE;
309         struct device *dev = rpc->rppcdev->dev;
311         if (!base_ptr || !dmabuf)
312                 return -EINVAL;
314         pg_offset = (offset & (PAGE_SIZE - 1));
315         begin = offset & PAGE_MASK;
316         pg_num = offset >> PAGE_SHIFT;
318         dbuf = dma_buf_get(fd);
319         if (IS_ERR(dbuf)) {
320                 ret = PTR_ERR(dbuf);
321                 dev_err(dev, "invalid dma_buf file descriptor passed! fd = %d ret = %d\n",
322                         fd, ret);
323                 goto out;
324         }
326         ret = dma_buf_begin_cpu_access(dbuf, DMA_BIDIRECTIONAL);
327         if (ret < 0) {
328                 dev_err(dev, "failed to acquire cpu access to the dma buf fd = %d offset = 0x%x, ret = %d\n",
329                         fd, offset, ret);
330                 goto put_dmabuf;
331         }
333         ptr = dma_buf_kmap(dbuf, pg_num);
334         if (!ptr) {
335                 ret = -ENOBUFS;
336                 dev_err(dev, "failed to map the page containing the translation into kernel fd = %d offset = 0x%x\n",
337                         fd, offset);
338                 goto end_cpuaccess;
339         }
341         *base_ptr = ptr;
342         *dmabuf = dbuf;
343         dev_dbg(dev, "kmap'd base_ptr = %p buf = %p into kernel from %zu for %zu bytes, pg_offset = 0x%x\n",
344                 ptr, dbuf, begin, end, pg_offset);
345         return 0;
347 end_cpuaccess:
348         dma_buf_end_cpu_access(dbuf, DMA_BIDIRECTIONAL);
349 put_dmabuf:
350         dma_buf_put(dbuf);
351 out:
352         return ret;
355 /**
356  * rppc_unmap_page - unmap and release a previously mapped page
357  * @rpc - rppc instance handle
358  * @offset: offset of the translate location within the buffer
359  * @base_ptr: kernel mapped address for the page to be unmapped
360  * @dmabuf: imported dma_buf to be released
361  *
362  * This function is called by rppc_xlate_buffers to unmap the
363  * page and release the imported buffer. It essentially undoes
364  * the functionality of rppc_map_page.
365  */
366 static void rppc_unmap_page(struct rppc_instance *rpc, u32 offset,
367                             u8 *base_ptr, struct dma_buf *dmabuf)
369         u32 pg_offset;
370         unsigned long pg_num;
371         size_t begin, end = PAGE_SIZE;
372         struct device *dev = rpc->rppcdev->dev;
374         if (!base_ptr || !dmabuf)
375                 return;
377         pg_offset = (offset & (PAGE_SIZE - 1));
378         begin = offset & PAGE_MASK;
379         pg_num = offset >> PAGE_SHIFT;
381         dev_dbg(dev, "Unkmaping base_ptr = %p of buf = %p from %zu to %zu bytes\n",
382                 base_ptr, dmabuf, begin, end);
383         dma_buf_kunmap(dmabuf, pg_num, base_ptr);
384         dma_buf_end_cpu_access(dmabuf, DMA_BIDIRECTIONAL);
385         dma_buf_put(dmabuf);
388 /**
389  * rppc_buffer_lookup - convert a buffer pointer to a remote processor pointer
390  * @rpc: rpc instance
391  * @uva: buffer pointer that needs to be translated
392  * @buva: base pointer of the allocated buffer
393  * @fd: dma-buf file descriptor of the allocated buffer
394  *
395  * This function is used for converting a pointer value in the function
396  * arguments to its appropriate remote processor device address value.
397  * The @uva and @buva are used for identifying the offset of the function
398  * argument pointer in an original allocation. This supports the cases where
399  * an offset pointer (eg: alignment, packed buffers etc) needs to be passed
400  * as the argument rather than the actual allocated pointer.
401  *
402  * The remote processor device address is done by retrieving the base physical
403  * address of the buffer by importing the buffer and converting it to the
404  * remote processor device address using a remoteproc api, with adjustments
405  * to the offset.
406  *
407  * The offset is specifically adjusted for OMAP TILER to account for the stride
408  * and mapping onto the remote processor.
409  *
410  * Return: remote processor device address, 0 on failure (implies invalid
411  *         arguments)
412  */
413 dev_addr_t rppc_buffer_lookup(struct rppc_instance *rpc, virt_addr_t uva,
414                               virt_addr_t buva, int fd)
416         phys_addr_t lpa = 0;
417         dev_addr_t rda = 0;
418         long uoff = uva - buva;
419         struct device *dev = rpc->rppcdev->dev;
420         struct rppc_dma_buf *buf;
422         dev_dbg(dev, "buva = %p uva = %p offset = %ld [0x%016lx] fd = %d\n",
423                 (void *)buva, (void *)uva, uoff, (ulong)uoff, fd);
425         if (uoff < 0) {
426                 dev_err(dev, "invalid pointer values for uva = %p from buva = %p\n",
427                         (void *)uva, (void *)buva);
428                 return rda;
429         }
431         buf = rppc_find_dmabuf(rpc, fd);
432         if (IS_ERR_OR_NULL(buf)) {
433                 buf = rppc_alloc_dmabuf(rpc, fd, true);
434                 if (IS_ERR(buf))
435                         goto out;
436         }
438         lpa = buf->pa;
439         WARN_ON(lpa != sg_dma_address(buf->sgt->sgl));
440         uoff = rppc_recalc_off(lpa, uoff);
441         lpa += uoff;
442         rda = rppc_local_to_remote_da(rpc, lpa);
444 out:
445         dev_dbg(dev, "host uva %p == host pa %pa => remote da %p (fd %d)\n",
446                 (void *)uva, &lpa, (void *)rda, fd);
447         return rda;
450 /**
451  * rppc_xlate_buffers - translate argument pointers in the marshalled packet
452  * @rpc: rppc instance
453  * @func: rppc function packet being acted upon
454  * @direction: direction of translation
455  *
456  * This function translates all the pointers within the function call packet
457  * structure, based on the translation descriptor structures. The translation
458  * replaces the pointers to the appropriate pointers based on the direction.
459  * The function is invoked in preparing the packet to be sent to the remote
460  * processor-side and replaces the pointers to the remote processor device
461  * address pointers; and in processing the packet back after executing the
462  * function and replacing back the remote processor device addresses with
463  * the original pointers.
464  *
465  * Return: 0 on success, or an appropriate failure code otherwise
466  */
467 int rppc_xlate_buffers(struct rppc_instance *rpc, struct rppc_function *func,
468                        int direction)
470         u8 *base_ptr = NULL;
471         struct dma_buf *dbuf = NULL;
472         struct device *dev = rpc->rppcdev->dev;
473         u32 ptr_idx, pri_offset, sec_offset, offset, pg_offset, size;
474         int i, limit, inc = 1;
475         virt_addr_t kva, uva, buva;
476         dev_addr_t rda;
477         int ret = 0, final_ret = 0;
478         int xlate_fd;
480         limit = func->num_translations;
481         if (WARN_ON(!limit))
482                 return 0;
484         dev_dbg(dev, "operating on %d pointers\n", func->num_translations);
486         /* sanity check the translation elements */
487         for (i = 0; i < limit; i++) {
488                 ptr_idx = func->translations[i].index;
490                 if (ptr_idx >= RPPC_MAX_PARAMETERS) {
491                         dev_err(dev, "xlate[%d] - invalid parameter pointer index %u\n",
492                                 i, ptr_idx);
493                         return -EINVAL;
494                 }
495                 if (func->params[ptr_idx].type != RPPC_PARAM_TYPE_PTR) {
496                         dev_err(dev, "xlate[%d] - parameter index %u is not a pointer (type %u)\n",
497                                 i, ptr_idx, func->params[ptr_idx].type);
498                         return -EINVAL;
499                 }
500                 if (func->params[ptr_idx].data == 0) {
501                         dev_err(dev, "xlate[%d] - supplied user pointer is NULL!\n",
502                                 i);
503                         return -EINVAL;
504                 }
506                 pri_offset = func->params[ptr_idx].data -
507                                         func->params[ptr_idx].base;
508                 sec_offset = func->translations[i].offset;
509                 size = func->params[ptr_idx].size;
511                 if (sec_offset > (size - sizeof(virt_addr_t))) {
512                         dev_err(dev, "xlate[%d] offset is larger than data area! (sec_offset = %u size = %u)\n",
513                                 i, sec_offset, size);
514                         return -ENOSPC;
515                 }
516         }
518         /*
519          * we may have a failure during translation, in which case use the same
520          * loop to unwind the whole operation
521          */
522         for (i = 0; i != limit; i += inc) {
523                 dev_dbg(dev, "starting translation %d of %d by %d\n",
524                         i, limit, inc);
526                 ptr_idx = func->translations[i].index;
527                 pri_offset = func->params[ptr_idx].data -
528                                                 func->params[ptr_idx].base;
529                 sec_offset = func->translations[i].offset;
530                 offset = pri_offset + sec_offset;
531                 pg_offset = (offset & (PAGE_SIZE - 1));
533                 /*
534                  * map into kernel the page containing the offset, where the
535                  * pointer needs to be translated.
536                  */
537                 ret = rppc_map_page(rpc, func->params[ptr_idx].fd, offset,
538                                     &base_ptr, &dbuf);
539                 if (ret) {
540                         dev_err(dev, "rppc_map_page failed, translation = %d param_index = %d fd = %d ret = %d\n",
541                                 i, ptr_idx, func->params[ptr_idx].fd, ret);
542                         goto unwind;
543                 }
545                 /*
546                  * perform the actual translation as per the direction.
547                  */
548                 if (direction == RPPC_UVA_TO_RPA) {
549                         kva = (virt_addr_t)&base_ptr[pg_offset];
550                         if (kva & 0x3) {
551                                 dev_err(dev, "kernel virtual address %p is not aligned for translation = %d\n",
552                                         (void *)kva, i);
553                                 ret = -EADDRNOTAVAIL;
554                                 goto unmap;
555                         }
557                         uva = *(virt_addr_t *)kva;
558                         if (!uva) {
559                                 dev_err(dev, "user pointer in the translated offset location is NULL for translation = %d\n",
560                                         i);
561                                 print_hex_dump(KERN_DEBUG, "KMAP: ",
562                                                DUMP_PREFIX_NONE, 16, 1,
563                                                base_ptr, PAGE_SIZE, true);
564                                 ret = -EADDRNOTAVAIL;
565                                 goto unmap;
566                         }
568                         buva = (virt_addr_t)func->translations[i].base;
569                         xlate_fd = func->translations[i].fd;
571                         dev_dbg(dev, "replacing UVA %p at KVA %p prt_idx = %u pg_offset = 0x%x fd = %d\n",
572                                 (void *)uva, (void *)kva, ptr_idx,
573                                 pg_offset, xlate_fd);
575                         /* compute the corresponding remote device address */
576                         rda = rppc_buffer_lookup(rpc, uva, buva, xlate_fd);
577                         if (!rda) {
578                                 ret = -ENODATA;
579                                 goto unmap;
580                         }
582                         /*
583                          * replace the pointer, save the old value for replacing
584                          * it back on the function return path
585                          */
586                         func->translations[i].fd = (int32_t)uva;
587                         *(virt_addr_t *)kva = rda;
588                         dev_dbg(dev, "replaced UVA %p with RDA %p at KVA %p\n",
589                                 (void *)uva, (void *)rda, (void *)kva);
590                 } else if (direction == RPPC_RPA_TO_UVA) {
591                         kva = (virt_addr_t)&base_ptr[pg_offset];
592                         if (kva & 0x3) {
593                                 ret = -EADDRNOTAVAIL;
594                                 goto unmap;
595                         }
597                         rda = *(virt_addr_t *)kva;
598                         uva = (virt_addr_t)func->translations[i].fd;
599                         WARN_ON(!uva);
600                         *(virt_addr_t *)kva = uva;
602                         dev_dbg(dev, "replaced RDA %p with UVA %p at KVA %p\n",
603                                 (void *)rda, (void *)uva, (void *)kva);
604                 }
606 unmap:
607                 /*
608                  * unmap the page containing the translation from kernel, the
609                  * next translation acting on the same fd might be in a
610                  * different page altogether from the current one
611                  */
612                 rppc_unmap_page(rpc, offset, base_ptr, dbuf);
613                 dbuf = NULL;
614                 base_ptr = NULL;
616                 if (!ret)
617                         continue;
619 unwind:
620                 /*
621                  * unwind all the previous translations if the failure occurs
622                  * while sending a message to the remote-side. There's nothing
623                  * to do but to continue if the failure occurs during the
624                  * processing of a function response.
625                  */
626                 if (direction == RPPC_UVA_TO_RPA) {
627                         dev_err(dev, "unwinding UVA to RDA translations! translation = %d\n",
628                                 i);
629                         direction = RPPC_RPA_TO_UVA;
630                         inc = -1;
631                         limit = -1;
632                 } else if (direction == RPPC_RPA_TO_UVA) {
633                         dev_err(dev, "error during UVA to RDA translations!! current translation = %d\n",
634                                 i);
635                 }
636                 /*
637                  * store away the return value to return back to caller
638                  * in case of an error, record only the first error
639                  */
640                 if (!final_ret)
641                         final_ret = ret;
642         }
644         /*
645          * all the in-place pointer replacements are done, release all the
646          * imported buffers during the remote function return path
647          */
648         if (direction == RPPC_RPA_TO_UVA) {
649                 mutex_lock(&rpc->lock);
650                 idr_for_each(&rpc->dma_idr, rppc_free_auto_dmabuf, rpc);
651                 mutex_unlock(&rpc->lock);
652         }
654         return final_ret;