Linaro-mm-sig February 2013

linaro-mm-sig@lists.linaro.org

38 participants
27 discussions

[PATCH] mm: dmapool: use provided gfp flags for all dma_alloc_coherent() calls

by Marek Szyprowski

dmapool always calls dma_alloc_coherent() with GFP_ATOMIC flag, regardless the flags provided by the caller. This causes excessive pruning of emergency memory pools without any good reason. This patch changes the code to correctly use gfp flags provided by the dmapool caller. This should solve the dmapool usage on ARM architecture, where GFP_ATOMIC DMA allocations can be served only from the special, very limited memory pool. Reported-by: Soren Moch <smoch(a)web.de> Reported-by: Thomas Petazzoni <thomas.petazzoni(a)free-electrons.com> Signed-off-by: Marek Szyprowski <m.szyprowski(a)samsung.com> --- mm/dmapool.c | 27 +++++++-------------------- 1 file changed, 7 insertions(+), 20 deletions(-) diff --git a/mm/dmapool.c b/mm/dmapool.c index c5ab33b..86de9b2 100644 --- a/mm/dmapool.c +++ b/mm/dmapool.c @@ -62,8 +62,6 @@ struct dma_page { /* cacheable header for 'allocation' bytes */ unsigned int offset; }; -#define POOL_TIMEOUT_JIFFIES ((100 /* msec */ * HZ) / 1000) - static DEFINE_MUTEX(pools_lock); static ssize_t @@ -227,7 +225,6 @@ static struct dma_page *pool_alloc_page(struct dma_pool *pool, gfp_t mem_flags) memset(page->vaddr, POOL_POISON_FREED, pool->allocation); #endif pool_initialise_page(pool, page); - list_add(&page->page_list, &pool->page_list); page->in_use = 0; page->offset = 0; } else { @@ -315,30 +312,21 @@ void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags, might_sleep_if(mem_flags & __GFP_WAIT); spin_lock_irqsave(&pool->lock, flags); - restart: list_for_each_entry(page, &pool->page_list, page_list) { if (page->offset < pool->allocation) goto ready; } - page = pool_alloc_page(pool, GFP_ATOMIC); - if (!page) { - if (mem_flags & __GFP_WAIT) { - DECLARE_WAITQUEUE(wait, current); - __set_current_state(TASK_UNINTERRUPTIBLE); - __add_wait_queue(&pool->waitq, &wait); - spin_unlock_irqrestore(&pool->lock, flags); + /* pool_alloc_page() might sleep, so temporarily drop &pool->lock */ + spin_unlock_irqrestore(&pool->lock, flags); - schedule_timeout(POOL_TIMEOUT_JIFFIES); + page = pool_alloc_page(pool, mem_flags); + if (!page) + return NULL; - spin_lock_irqsave(&pool->lock, flags); - __remove_wait_queue(&pool->waitq, &wait); - goto restart; - } - retval = NULL; - goto done; - } + spin_lock_irqsave(&pool->lock, flags); + list_add(&page->page_list, &pool->page_list); ready: page->in_use++; offset = page->offset; @@ -348,7 +336,6 @@ void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags, #ifdef DMAPOOL_DEBUG memset(retval, POOL_POISON_ALLOCATED, pool->size); #endif - done: spin_unlock_irqrestore(&pool->lock, flags); return retval; } -- 1.7.9.5

11 years, 7 months

[PATCH v2 1/3] arch: make __mutex_fastpath_lock_retval return whether fastpath succeeded or not.

by Maarten Lankhorst

This will allow me to call functions that have multiple arguments if fastpath fails. This is required to support ticket mutexes, because they need to be able to pass an extra argument to the fail function. Originally I duplicated the functions, by adding __mutex_fastpath_lock_retval_arg. This ended up being just a duplication of the existing function, so a way to test if fastpath was called ended up being better. This also cleaned up the reservation mutex patch some by being able to call an atomic_set instead of atomic_xchg, and making it easier to detect if the wrong unlock function was previously used. Signed-off-by: Maarten Lankhorst <maarten.lankhorst(a)canonical.com> --- arch/ia64/include/asm/mutex.h | 10 ++++------ arch/powerpc/include/asm/mutex.h | 10 ++++------ arch/sh/include/asm/mutex-llsc.h | 4 ++-- arch/x86/include/asm/mutex_32.h | 11 ++++------- arch/x86/include/asm/mutex_64.h | 11 ++++------- include/asm-generic/mutex-dec.h | 10 ++++------ include/asm-generic/mutex-null.h | 2 +- include/asm-generic/mutex-xchg.h | 10 ++++------ kernel/mutex.c | 32 ++++++++++++++------------------ 9 files changed, 41 insertions(+), 59 deletions(-) diff --git a/arch/ia64/include/asm/mutex.h b/arch/ia64/include/asm/mutex.h index bed73a6..f41e66d 100644 --- a/arch/ia64/include/asm/mutex.h +++ b/arch/ia64/include/asm/mutex.h @@ -29,17 +29,15 @@ __mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *)) * __mutex_fastpath_lock_retval - try to take the lock by moving the count * from 1 to a 0 value * @count: pointer of type atomic_t - * @fail_fn: function to call if the original value was not 1 * - * Change the count from 1 to a value lower than 1, and call <fail_fn> if - * it wasn't 1 originally. This function returns 0 if the fastpath succeeds, - * or anything the slow path function returns. + * Change the count from 1 to a value lower than 1. This function returns 0 + * if the fastpath succeeds, or -1 otherwise. */ static inline int -__mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *)) +__mutex_fastpath_lock_retval(atomic_t *count) { if (unlikely(ia64_fetchadd4_acq(count, -1) != 1)) - return fail_fn(count); + return -1; return 0; } diff --git a/arch/powerpc/include/asm/mutex.h b/arch/powerpc/include/asm/mutex.h index 5399f7e..127ab23 100644 --- a/arch/powerpc/include/asm/mutex.h +++ b/arch/powerpc/include/asm/mutex.h @@ -82,17 +82,15 @@ __mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *)) * __mutex_fastpath_lock_retval - try to take the lock by moving the count * from 1 to a 0 value * @count: pointer of type atomic_t - * @fail_fn: function to call if the original value was not 1 * - * Change the count from 1 to a value lower than 1, and call <fail_fn> if - * it wasn't 1 originally. This function returns 0 if the fastpath succeeds, - * or anything the slow path function returns. + * Change the count from 1 to a value lower than 1. This function returns 0 + * if the fastpath succeeds, or -1 otherwise. */ static inline int -__mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *)) +__mutex_fastpath_lock_retval(atomic_t *count) { if (unlikely(__mutex_dec_return_lock(count) < 0)) - return fail_fn(count); + return -1; return 0; } diff --git a/arch/sh/include/asm/mutex-llsc.h b/arch/sh/include/asm/mutex-llsc.h index 090358a..dad29b6 100644 --- a/arch/sh/include/asm/mutex-llsc.h +++ b/arch/sh/include/asm/mutex-llsc.h @@ -37,7 +37,7 @@ __mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *)) } static inline int -__mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *)) +__mutex_fastpath_lock_retval(atomic_t *count) { int __done, __res; @@ -51,7 +51,7 @@ __mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *)) : "t"); if (unlikely(!__done || __res != 0)) - __res = fail_fn(count); + __res = -1; return __res; } diff --git a/arch/x86/include/asm/mutex_32.h b/arch/x86/include/asm/mutex_32.h index 03f90c8..b7f6b34 100644 --- a/arch/x86/include/asm/mutex_32.h +++ b/arch/x86/include/asm/mutex_32.h @@ -42,17 +42,14 @@ do { \ * __mutex_fastpath_lock_retval - try to take the lock by moving the count * from 1 to a 0 value * @count: pointer of type atomic_t - * @fail_fn: function to call if the original value was not 1 * - * Change the count from 1 to a value lower than 1, and call <fail_fn> if it - * wasn't 1 originally. This function returns 0 if the fastpath succeeds, - * or anything the slow path function returns + * Change the count from 1 to a value lower than 1. This function returns 0 + * if the fastpath succeeds, or 1 otherwise. */ -static inline int __mutex_fastpath_lock_retval(atomic_t *count, - int (*fail_fn)(atomic_t *)) +static inline int __mutex_fastpath_lock_retval(atomic_t *count) { if (unlikely(atomic_dec_return(count) < 0)) - return fail_fn(count); + return -1; else return 0; } diff --git a/arch/x86/include/asm/mutex_64.h b/arch/x86/include/asm/mutex_64.h index 68a87b0..2c543ff 100644 --- a/arch/x86/include/asm/mutex_64.h +++ b/arch/x86/include/asm/mutex_64.h @@ -37,17 +37,14 @@ do { \ * __mutex_fastpath_lock_retval - try to take the lock by moving the count * from 1 to a 0 value * @count: pointer of type atomic_t - * @fail_fn: function to call if the original value was not 1 * - * Change the count from 1 to a value lower than 1, and call <fail_fn> if - * it wasn't 1 originally. This function returns 0 if the fastpath succeeds, - * or anything the slow path function returns + * Change the count from 1 to a value lower than 1. This function returns 0 + * if the fastpath succeeds, or -1 otherwise. */ -static inline int __mutex_fastpath_lock_retval(atomic_t *count, - int (*fail_fn)(atomic_t *)) +static inline int __mutex_fastpath_lock_retval(atomic_t *count) { if (unlikely(atomic_dec_return(count) < 0)) - return fail_fn(count); + return -1; else return 0; } diff --git a/include/asm-generic/mutex-dec.h b/include/asm-generic/mutex-dec.h index f104af7..d4f9fb4 100644 --- a/include/asm-generic/mutex-dec.h +++ b/include/asm-generic/mutex-dec.h @@ -28,17 +28,15 @@ __mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *)) * __mutex_fastpath_lock_retval - try to take the lock by moving the count * from 1 to a 0 value * @count: pointer of type atomic_t - * @fail_fn: function to call if the original value was not 1 * - * Change the count from 1 to a value lower than 1, and call <fail_fn> if - * it wasn't 1 originally. This function returns 0 if the fastpath succeeds, - * or anything the slow path function returns. + * Change the count from 1 to a value lower than 1. This function returns 0 + * if the fastpath succeeds, or -1 otherwise. */ static inline int -__mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *)) +__mutex_fastpath_lock_retval(atomic_t *count) { if (unlikely(atomic_dec_return(count) < 0)) - return fail_fn(count); + return -1; return 0; } diff --git a/include/asm-generic/mutex-null.h b/include/asm-generic/mutex-null.h index e1bbbc7..efd6206 100644 --- a/include/asm-generic/mutex-null.h +++ b/include/asm-generic/mutex-null.h @@ -11,7 +11,7 @@ #define _ASM_GENERIC_MUTEX_NULL_H #define __mutex_fastpath_lock(count, fail_fn) fail_fn(count) -#define __mutex_fastpath_lock_retval(count, fail_fn) fail_fn(count) +#define __mutex_fastpath_lock_retval(count, fail_fn) (-1) #define __mutex_fastpath_unlock(count, fail_fn) fail_fn(count) #define __mutex_fastpath_trylock(count, fail_fn) fail_fn(count) #define __mutex_slowpath_needs_to_unlock() 1 diff --git a/include/asm-generic/mutex-xchg.h b/include/asm-generic/mutex-xchg.h index c04e0db..f169ec0 100644 --- a/include/asm-generic/mutex-xchg.h +++ b/include/asm-generic/mutex-xchg.h @@ -39,18 +39,16 @@ __mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *)) * __mutex_fastpath_lock_retval - try to take the lock by moving the count * from 1 to a 0 value * @count: pointer of type atomic_t - * @fail_fn: function to call if the original value was not 1 * - * Change the count from 1 to a value lower than 1, and call <fail_fn> if it - * wasn't 1 originally. This function returns 0 if the fastpath succeeds, - * or anything the slow path function returns + * Change the count from 1 to a value lower than 1. This function returns 0 + * if the fastpath succeeds, or -1 otherwise. */ static inline int -__mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *)) +__mutex_fastpath_lock_retval(atomic_t *count) { if (unlikely(atomic_xchg(count, 0) != 1)) if (likely(atomic_xchg(count, -1) != 1)) - return fail_fn(count); + return -1; return 0; } diff --git a/kernel/mutex.c b/kernel/mutex.c index 52f2301..84a5f07 100644 --- a/kernel/mutex.c +++ b/kernel/mutex.c @@ -351,10 +351,10 @@ __mutex_unlock_slowpath(atomic_t *lock_count) * mutex_lock_interruptible() and mutex_trylock(). */ static noinline int __sched -__mutex_lock_killable_slowpath(atomic_t *lock_count); +__mutex_lock_killable_slowpath(struct mutex *lock); static noinline int __sched -__mutex_lock_interruptible_slowpath(atomic_t *lock_count); +__mutex_lock_interruptible_slowpath(struct mutex *lock); /** * mutex_lock_interruptible - acquire the mutex, interruptible @@ -372,12 +372,12 @@ int __sched mutex_lock_interruptible(struct mutex *lock) int ret; might_sleep(); - ret = __mutex_fastpath_lock_retval - (&lock->count, __mutex_lock_interruptible_slowpath); - if (!ret) + ret = __mutex_fastpath_lock_retval(&lock->count); + if (likely(!ret)) { mutex_set_owner(lock); - - return ret; + return 0; + } else + return __mutex_lock_interruptible_slowpath(lock); } EXPORT_SYMBOL(mutex_lock_interruptible); @@ -387,12 +387,12 @@ int __sched mutex_lock_killable(struct mutex *lock) int ret; might_sleep(); - ret = __mutex_fastpath_lock_retval - (&lock->count, __mutex_lock_killable_slowpath); - if (!ret) + ret = __mutex_fastpath_lock_retval(&lock->count); + if (likely(!ret)) { mutex_set_owner(lock); - - return ret; + return 0; + } else + return __mutex_lock_killable_slowpath(lock); } EXPORT_SYMBOL(mutex_lock_killable); @@ -405,18 +405,14 @@ __mutex_lock_slowpath(atomic_t *lock_count) } static noinline int __sched -__mutex_lock_killable_slowpath(atomic_t *lock_count) +__mutex_lock_killable_slowpath(struct mutex *lock) { - struct mutex *lock = container_of(lock_count, struct mutex, count); - return __mutex_lock_common(lock, TASK_KILLABLE, 0, NULL, _RET_IP_); } static noinline int __sched -__mutex_lock_interruptible_slowpath(atomic_t *lock_count) +__mutex_lock_interruptible_slowpath(struct mutex *lock) { - struct mutex *lock = container_of(lock_count, struct mutex, count); - return __mutex_lock_common(lock, TASK_INTERRUPTIBLE, 0, NULL, _RET_IP_); } #endif

11 years, 8 months

[PATCH 0/2] Device Tree support for CMA (Contiguous Memory Allocator)

by Marek Szyprowski

Hello, Here is my initial proposal for device tree integration for Contiguous Memory Allocator. The code is quite straightforward, however I expect that the memory bindings require some discussion. The proposed bindings allows to define contiguous memory regions of specified base address and size. Then, the defined regions can be assigned to the given device(s) by adding a property with a phanle to the defined contiguous memory region. From the device tree perspective that's all. Once the bindings are added, all the memory allocations from dma-mapping subsystem will be served from the defined contiguous memory regions. Contiguous Memory Allocator is a framework, which lets to provide a large contiguous memory buffers for (usually a multimedia) devices. The contiguous memory is reserved during early boot and then shared with kernel, which is allowed to allocate it for movable pages. Then, when device driver requests a contigouous buffer, the framework migrates movable pages out of contiguous region and gives it to the driver. When device driver frees the buffer, it is added to kernel memory pool again. For more information, please refer to commit c64be2bb1c6eb43c838b2c6d57 ("drivers: add Contiguous Memory Allocator") and d484864dd96e1830e76895 (CMA merge commit). Best regards Marek Szyprowski Samsung Poland R&D Center Patch summary: Marek Szyprowski (2): drivers: dma-contiguous: clean source code and prepare for device tree drivers: dma-contiguous: add initialization from device tree Documentation/devicetree/bindings/memory.txt | 101 ++++++++++ arch/arm/boot/dts/skeleton.dtsi | 7 +- drivers/base/dma-contiguous.c | 278 +++++++++++++++++++------- include/asm-generic/dma-contiguous.h | 4 +- include/linux/dma-contiguous.h | 32 ++- 5 files changed, 338 insertions(+), 84 deletions(-) create mode 100644 Documentation/devicetree/bindings/memory.txt -- 1.7.9.5

11 years, 9 months

[RFD] Proposal for merging Android sync driver in staging

by John Stultz

I'd like to get a discussion going about submitting the Android sync driver to staging. I know there is currently some very similar work going on with the dmabuf-fences, and rather then both approaches being worked out individually on their own, I suspect there could be better collaboration around this effort. So my proposal is that we merge the Android sync driver into staging. In my mind, this has the following benefits: 1) It allows other drivers that depend on the sync interface to also be submitted to staging, rather then forcing those drivers to be hidden away in various out of tree git repos, location unknown. 2) It would provide a baseline view to the upstream community of the interface Android is using, providing a real-world, active use case of the functionality. Once the sync driver is in staging, if the dmabuf-fences work is fully sufficient to replace the Android sync driver, we should be able to whittle down the sync driver until its just a interface shim (and at which point efforts can be made to convert Android userland over to dmabuf-fences). However, if the dmabuf-fences work is not fully sufficient to replace the android sync driver, we should be able to at least to whittle down the driver to those specific differences, which would provide a concrete example of where the dmabuf-fences, or other work may need to be expanded, or if maybe the sync driver is the better approach. I've gone through the Android tree and reworked the sync driver to live in staging, while still preserving the full patch history/authorship. You can checkout the reworked patch queue here: http://git.linaro.org/gitweb?p=people/jstultz/android-dev.git;a=shortlog;h=… If folks would take a look and let me know what they think of the changes as well as what they think about pushing it to staging, or other ideas for how to improve collaboration so we can have common interfaces here, I'd appreciate it. Also note: I've done this so far without any feedback from the Android devs (despite my reaching out to Erik a few times recently), so if they object to pushing it to staging, in deference to it being their code I'll back off, even though I do think it would be good to have the code get more visibility upstream in staging. I don't mean to step on anyone's toes. :) thanks -john

11 years, 9 months

[GIT PULL]: dma-buf updates for 3.9

by Sumit Semwal

Hi Linus, Here's the 3.9 pull request for dma-buf framework updates: could you please pull? Thanks and best regards, ~Sumit. The following changes since commit d895cb1af15c04c522a25c79cc429076987c089b: Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs (2013-02-26 20:16:07 -0800) are available in the git repository at: git://git.linaro.org/people/sumitsemwal/linux-dma-buf.git tags/tag-for-linus-3.9 for you to fetch changes up to 495c10cc1c0c359871d5bef32dd173252fc17995: CHROMIUM: dma-buf: restore args on failure of dma_buf_mmap (2013-02-27 15:14:02 +0530) ---------------------------------------------------------------- 3.9: dma-buf updates Refcounting implemented for vmap in core dma-buf ---------------------------------------------------------------- Daniel Vetter (1): dma-buf: implement vmap refcounting in the interface logic John Sheu (1): CHROMIUM: dma-buf: restore args on failure of dma_buf_mmap Documentation/dma-buf-sharing.txt | 6 +++- drivers/base/dma-buf.c | 66 ++++++++++++++++++++++++++++++------- include/linux/dma-buf.h | 4 ++- 3 files changed, 63 insertions(+), 13 deletions(-)

11 years, 9 months

[PATCH v2] lib/scatterlist: add simple page iterator

by Imre Deak

Add an iterator to walk through a scatter list a page at a time starting at a specific page offset. As opposed to the mapping iterator this is meant to be small, performing well even in simple loops like collecting all pages on the scatterlist into an array or setting up an iommu table based on the pages' DMA address. v2: - In each iteration sg_pgoffset pointed incorrectly at the next page not the current one. Signed-off-by: Imre Deak <imre.deak(a)intel.com> --- include/linux/scatterlist.h | 50 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h index 4bd6c06..72578b5 100644 --- a/include/linux/scatterlist.h +++ b/include/linux/scatterlist.h @@ -231,6 +231,56 @@ size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents, */ #define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist)) +struct sg_page_iter { + struct scatterlist *sg; + int sg_pgoffset; + struct page *page; +}; + +static inline int +sg_page_cnt(struct scatterlist *sg) +{ + BUG_ON(sg->offset || sg->length & ~PAGE_MASK); + + return sg->length >> PAGE_SHIFT; +} + +static inline struct page * +sg_page_iter_get_page(struct sg_page_iter *iter) +{ + while (iter->sg && iter->sg_pgoffset >= sg_page_cnt(iter->sg)) { + iter->sg_pgoffset -= sg_page_cnt(iter->sg); + iter->sg = sg_next(iter->sg); + } + + return iter->sg ? nth_page(sg_page(iter->sg), iter->sg_pgoffset) : NULL; +} + +static inline void +sg_page_iter_next(struct sg_page_iter *iter) +{ + iter->sg_pgoffset++; + iter->page = sg_page_iter_get_page(iter); +} + +static inline void +sg_page_iter_start(struct sg_page_iter *iter, struct scatterlist *sglist, + unsigned long pgoffset) +{ + iter->sg = sglist; + iter->sg_pgoffset = pgoffset; + iter->page = sg_page_iter_get_page(iter); +} + +/* + * Simple sg page iterator, starting off at the given page offset. Each entry + * on the sglist must start at offset 0 and can contain only full pages. + * iter->page will point to the current page, iter->sg_pgoffset to the page + * offset within the sg holding that page. + */ +#define for_each_sg_page(sglist, iter, pgoffset) \ + for (sg_page_iter_start((iter), (sglist), (pgoffset)); \ + (iter)->page; sg_page_iter_next(iter)) /* * Mapping sg iterator -- 1.7.9.5

11 years, 9 months

Re: [Linaro-mm-sig] [Mesa-dev] [RFC] New dma_buf -> EGLImage EGL extension - Final spec published!

by Tom Cooksey

Hi All, The final spec has had enum values assigned and been published on Khronos: http://www.khronos.org/registry/egl/extensions/EXT/EGL_EXT_image_dma_buf_im… Thanks to all who've provided input. Cheers, Tom > -----Original Message----- > From: mesa-dev-bounces+tom.cooksey=arm.com(a)lists.freedesktop.org [mailto:mesa-dev- > bounces+tom.cooksey=arm.com(a)lists.freedesktop.org] On Behalf Of Tom Cooksey > Sent: 04 October 2012 13:10 > To: mesa-dev(a)lists.freedesktop.org; linaro-mm-sig(a)lists.linaro.org; dri- > devel(a)lists.freedesktop.org; linux-media(a)vger.kernel.org > Subject: [Mesa-dev] [RFC] New dma_buf -> EGLImage EGL extension - New draft! > > Hi All, > > After receiving a fair bit of feedback (thanks!), I've updated the > EGL_EXT_image_dma_buf_import spec > and expanded it to resolve a number of the issues. Please find the latest draft below and let > me > know any additional feedback you might have, either on the lists or by private e-mail - I > don't mind > which. > > I think the only remaining issue now is if we need a mechanism whereby an application can > query > which drm_fourcc.h formats EGL supports or if just failing with EGL_BAD_MATCH when the > application > has use one EGL doesn't support is sufficient. Any thoughts? > > > Cheers, > > Tom > > > --------------------8<-------------------- > > > Name > > EXT_image_dma_buf_import > > Name Strings > > EGL_EXT_image_dma_buf_import > > Contributors > > Jesse Barker > Rob Clark > Tom Cooksey > > Contacts > > Jesse Barker (jesse 'dot' barker 'at' linaro 'dot' org) > Tom Cooksey (tom 'dot' cooksey 'at' arm 'dot' com) > > Status > > DRAFT > > Version > > Version 4, October 04, 2012 > > Number > > EGL Extension ??? > > Dependencies > > EGL 1.2 is required. > > EGL_KHR_image_base is required. > > The EGL implementation must be running on a Linux kernel supporting the > dma_buf buffer sharing mechanism. > > This extension is written against the wording of the EGL 1.2 Specification. > > Overview > > This extension allows creating an EGLImage from a Linux dma_buf file > descriptor or multiple file descriptors in the case of multi-plane YUV > images. > > New Types > > None > > New Procedures and Functions > > None > > New Tokens > > Accepted by the <target> parameter of eglCreateImageKHR: > > EGL_LINUX_DMA_BUF_EXT > > Accepted as an attribute in the <attrib_list> parameter of > eglCreateImageKHR: > > EGL_LINUX_DRM_FOURCC_EXT > EGL_DMA_BUF_PLANE0_FD_EXT > EGL_DMA_BUF_PLANE0_OFFSET_EXT > EGL_DMA_BUF_PLANE0_PITCH_EXT > EGL_DMA_BUF_PLANE1_FD_EXT > EGL_DMA_BUF_PLANE1_OFFSET_EXT > EGL_DMA_BUF_PLANE1_PITCH_EXT > EGL_DMA_BUF_PLANE2_FD_EXT > EGL_DMA_BUF_PLANE2_OFFSET_EXT > EGL_DMA_BUF_PLANE2_PITCH_EXT > EGL_YUV_COLOR_SPACE_HINT_EXT > EGL_SAMPLE_RANGE_HINT_EXT > EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT > EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT > > Accepted as the value for the EGL_YUV_COLOR_SPACE_HINT_EXT attribute: > > EGL_ITU_REC601_EXT > EGL_ITU_REC709_EXT > EGL_ITU_REC2020_EXT > > Accepted as the value for the EGL_SAMPLE_RANGE_HINT_EXT attribute: > > EGL_YUV_FULL_RANGE_EXT > EGL_YUV_NARROW_RANGE_EXT > > Accepted as the value for the EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT & > EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT attributes: > > EGL_YUV_CHROMA_SITING_0_EXT > EGL_YUV_CHROMA_SITING_0_5_EXT > > > Additions to Chapter 2 of the EGL 1.2 Specification (EGL Operation) > > Add to section 2.5.1 "EGLImage Specification" (as defined by the > EGL_KHR_image_base specification), in the description of > eglCreateImageKHR: > > "Values accepted for <target> are listed in Table aaa, below. > > +-------------------------+--------------------------------------------+ > | <target> | Notes | > +-------------------------+--------------------------------------------+ > | EGL_LINUX_DMA_BUF_EXT | Used for EGLImages imported from Linux | > | | dma_buf file descriptors | > +-------------------------+--------------------------------------------+ > Table aaa. Legal values for eglCreateImageKHR <target> parameter > > ... > > If <target> is EGL_LINUX_DMA_BUF_EXT, <dpy> must be a valid display, <ctx> > must be EGL_NO_CONTEXT, and <buffer> must be NULL, cast into the type > EGLClientBuffer. The details of the image is specified by the attributes > passed into eglCreateImageKHR. Required attributes and their values are as > follows: > > * EGL_WIDTH & EGL_HEIGHT: The logical dimensions of the buffer in pixels > > * EGL_LINUX_DRM_FOURCC_EXT: The pixel format of the buffer, as specified > by drm_fourcc.h and used as the pixel_format parameter of the > drm_mode_fb_cmd2 ioctl. > > * EGL_DMA_BUF_PLANE0_FD_EXT: The dma_buf file descriptor of plane 0 of > the image. > > * EGL_DMA_BUF_PLANE0_OFFSET_EXT: The offset from the start of the > dma_buf of the first sample in plane 0, in bytes. > > * EGL_DMA_BUF_PLANE0_PITCH_EXT: The number of bytes between the start of > subsequent rows of samples in plane 0. May have special meaning for > non-linear formats. > > For images in an RGB color-space or those using a single-plane YUV format, > only the first plane's file descriptor, offset & pitch should be specified. > For semi-planar YUV formats, the chroma samples are stored in plane 1 and > for fully planar formats, U-samples are stored in plane 1 and V-samples are > stored in plane 2. Planes 1 & 2 are specified by the following attributes, > which have the same meanings as defined above for plane 0: > > * EGL_DMA_BUF_PLANE1_FD_EXT > * EGL_DMA_BUF_PLANE1_OFFSET_EXT > * EGL_DMA_BUF_PLANE1_PITCH_EXT > * EGL_DMA_BUF_PLANE2_FD_EXT > * EGL_DMA_BUF_PLANE2_OFFSET_EXT > * EGL_DMA_BUF_PLANE2_PITCH_EXT > > In addition to the above required attributes, the application may also > provide hints as to how the data should be interpreted by the GL. If any of > these hints are not specified, the GL will guess based on the pixel format > passed as the EGL_LINUX_DRM_FOURCC_EXT attribute or may fall-back to some > default value. Not all GLs will be able to support all combinations of > these hints and are free to use whatever settings they choose to achieve > the closest possible match. > > * EGL_YUV_COLOR_SPACE_HINT_EXT: The color-space the data is in. Only > relevant for images in a YUV format, ignored when specified for an > image in an RGB format. Accepted values are: > EGL_ITU_REC601_EXT, EGL_ITU_REC709_EXT & EGL_ITU_REC2020_EXT. > > * EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT & > EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT: Where chroma samples are > sited relative to luma samples when the image is in a sub-sampled > format. When the image is not using chroma sub-sampling, the luma and > chroma samples are assumed to be co-sited. Siting is split into the > vertical and horizontal and is in a fixed range. A siting of zero > means the first luma sample is taken from the same position in that > dimension as the chroma sample. This is best illustrated in the > diagram below: > > (0.5, 0.5) (0.0, 0.5) (0.0, 0.0) > + + + + + + + + * + * + > x x x x > + + + + + + + + + + + + > > + + + + + + + + * + * + > x x x x > + + + + + + + + + + + + > > Luma samples (+), Chroma samples (x) Chrome & Luma samples (*) > > Note this attribute is ignored for RGB images and non sub-sampled > YUV images. Accepted values are: EGL_YUV_CHROMA_SITING_0_EXT (0.0) > & EGL_YUV_CHROMA_SITING_0_5_EXT (0.5) > > * EGL_SAMPLE_RANGE_HINT_EXT: The numerical range of samples. Only > relevant for images in a YUV format, ignored when specified for > images in an RGB format. Accepted values are: EGL_YUV_FULL_RANGE_EXT > (0-256) & EGL_YUV_NARROW_RANGE_EXT (16-235). > > > If eglCreateImageKHR is successful for a EGL_LINUX_DMA_BUF_EXT target, the > EGL takes ownership of the file descriptor and is responsible for closing > it, which it may do at any time while the EGLDisplay is initialized." > > > Add to the list of error conditions for eglCreateImageKHR: > > "* If <target> is EGL_LINUX_DMA_BUF_EXT and <buffer> is not NULL, the > error EGL_BAD_PARAMETER is generated. > > * If <target> is EGL_LINUX_DMA_BUF_EXT, and the list of attributes is > incomplete, EGL_BAD_PARAMETER is generated. > > * If <target> is EGL_LINUX_DMA_BUF_EXT, and the EGL_LINUX_DRM_FOURCC_EXT > attribute is set to a format not supported by the EGL, EGL_BAD_MATCH > is generated. > > * If <target> is EGL_LINUX_DMA_BUF_EXT, and the EGL_LINUX_DRM_FOURCC_EXT > attribute indicates a single-plane format, EGL_BAD_ATTRIBUTE is > generated if any of the EGL_DMA_BUF_PLANE1_* or EGL_DMA_BUF_PLANE2_* > attributes are specified. > > * If <target> is EGL_LINUX_DMA_BUF_EXT and the value specified for > EGL_YUV_COLOR_SPACE_HINT_EXT is not EGL_ITU_REC601_EXT, > EGL_ITU_REC709_EXT or EGL_ITU_REC2020_EXT, EGL_BAD_ATTRIBUTE is > generated. > > * If <target> is EGL_LINUX_DMA_BUF_EXT and the value specified for > EGL_SAMPLE_RANGE_HINT_EXT is not EGL_YUV_FULL_RANGE_EXT or > EGL_YUV_NARROW_RANGE_EXT, EGL_BAD_ATTRIBUTE is generated. > > * If <target> is EGL_LINUX_DMA_BUF_EXT and the value specified for > EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT or > EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT is not > EGL_YUV_CHROMA_SITING_0_EXT or EGL_YUV_CHROMA_SITING_0_5_EXT, > EGL_BAD_ATTRIBUTE is generated. > > * If <target> is EGL_LINUX_DMA_BUF_EXT and one or more of the values > specified for a plane's pitch or offset isn't supported by EGL, > EGL_BAD_ACCESS is generated. > > * If <target> is EGL_LINUX_DMA_BUF_EXT and eglCreateImageKHR fails, > EGL does not retain ownership of the file descriptor and it is the > responsibility of the application to close it." > > > Issues > > 1. Should this be a KHR or EXT extension? > > ANSWER: EXT. Khronos EGL working group not keen on this extension as it is > seen as contradicting the EGLStream direction the specification is going in. > The working group recommends creating additional specs to allow an EGLStream > producer/consumer connected to v4l2/DRM or any other Linux interface. > > 2. Should this be a generic any platform extension, or a Linux-only > extension which explicitly states the handles are dma_buf fds? > > ANSWER: There's currently no intention to port this extension to any OS not > based on the Linux kernel. Consequently, this spec can be explicitly written > against Linux and the dma_buf API. > > 3. Does ownership of the file descriptor pass to the EGL library? > > ANSWER: If eglCreateImageKHR is successful, EGL assumes ownership of the > file descriptors and is responsible for closing them. > > 4. How are the different YUV color spaces handled (BT.709/BT.601)? > > ANSWER: The pixel formats defined in drm_fourcc.h only specify how the data > is laid out in memory. It does not define how that data should be > interpreted. Added a new EGL_YUV_COLOR_SPACE_HINT_EXT attribute to allow the > application to specify which color space the data is in to allow the GL to > choose an appropriate set of co-efficients if it needs to convert that data > to RGB for example. > > 5. What chroma-siting is used for sub-sampled YUV formats? > > ANSWER: The chroma siting is not specified by either the v4l2 or DRM APIs. > This is similar to the color-space issue (4) in that the chroma siting > doesn't affect how the data is stored in memory. However, the GL will need > to know the siting in order to filter the image correctly. While the visual > impact of getting the siting wrong is minor, provision should be made to > allow an application to specify the siting if desired. Added additional > EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT & > EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT attributes to allow the siting to > be specified using a set of pre-defined values (0 or 0.5). > > 6. How can an application query which formats the EGL implementation > supports? > > PROPOSAL: Don't provide a query mechanism but instead add an error condition > that EGL_BAD_MATCH is raised if the EGL implementation doesn't support that > particular format. > > 7. Which image formats should be supported and how is format specified? > > Seem to be two options 1) specify a new enum in this specification and > enumerate all possible formats. 2) Use an existing enum already in Linux, > either v4l2_mbus_pixelcode and/or those formats listed in drm_fourcc.h? > > ANSWER: Go for option 2) and just use values defined in drm_fourcc.h. > > 8. How can AYUV images be handled? > > ANSWER: At least on fourcc.org and in drm_fourcc.h, there only seems to be > a single AYUV format and that is a packed format, so everything, including > the alpha component would be in the first plane. > > 9. How can you import interlaced images? > > ANSWER: Interlaced frames are usually stored with the top & bottom fields > interleaved in a single buffer. As the fields would need to be displayed as > at different times, the application would create two EGLImages from the same > buffer, one for the top field and another for the bottom. Both EGLImages > would set the pitch to 2x the buffer width and the second EGLImage would use > a suitable offset to indicate it started on the second line of the buffer. > This should work regardless of whether the data is packed in a single plane, > semi-planar or multi-planar. > > If each interlaced field is stored in a separate buffer then it should be > trivial to create two EGLImages, one for each field's buffer. > > 10. How are semi-planar/planar formats handled that have a different > width/height for Y' and CbCr such as YUV420? > > ANSWER: The spec says EGL_WIDTH & EGL_HEIGHT specify the *logical* width and > height of the buffer in pixels. For pixel formats with sub-sampled Chroma > values, it should be trivial for the EGL implementation to calculate the > width/height of the Chroma sample buffers using the logical width & height > and by inspecting the pixel format passed as the EGL_LINUX_DRM_FOURCC_EXT > attribute. I.e. If the pixel format says it's YUV420, the Chroma buffer's > width = EGL_WIDTH/2 & height =EGL_HEIGHT/2. > > 11. How are Bayer formats handled? > > ANSWER: As of Linux 2.6.34, drm_fourcc.h does not include any Bayer formats. > However, future kernel versions may add such formats in which case they > would be handled in the same way as any other format. > > 12. Should the spec support buffers which have samples in a "narrow range"? > > Content sampled from older analogue sources typically don't use the full > (0-256) range of the data type storing the sample and instead use a narrow > (16-235) range to allow some headroom & toeroom in the signals to avoid > clipping signals which overshoot slightly during processing. This is > sometimes known as signals using "studio swing". > > ANSWER: Add a new attribute to define if the samples use a narrow 16-235 > range or the full 0-256 range. > > 13. Specifying the color space and range seems cumbersome, why not just > allow the application to specify the full YUV->RGB color conversion matrix? > > ANSWER: Some hardware may not be able to use an arbitrary conversion matrix > and needs to select an appropriate pre-defined matrix based on the color > space and the sample range. > > 14. How do you handle EGL implementations which have restrictions on pitch > and/or offset? > > ANSWER: Buffers being imported using dma_buf pretty much have to be > allocated by a kernel-space driver. As such, it is expected that a system > integrator would make sure all devices which allocate buffers suitable for > exporting make sure they use a pitch supported by all possible importers. > However, it is still possible eglCreateImageKHR can fail due to an > unsupported pitch. Added a new error to the list indicating this. > > 15. Should this specification also describe how to export an existing > EGLImage as a dma_buf file descriptor? > > ANSWER: No. Importing and exporting buffers are two separate operations and > importing an existing dma_buf fd into an EGLImage is useful functionality in > itself. Agree that exporting an EGLImage as a dma_buf fd is useful, E.g. it > could be used by an OpenMAX IL implementation's OMX_UseEGLImage function to > give access to the buffer backing an EGLImage to video hardware. However, > exporting can be split into a separate extension specification. > > > Revision History > > #4 (Tom Cooksey, October 04, 2012) > - Fixed issue numbering! > - Added issues 8 - 15. > - Promoted proposal for Issue 3 to be the answer. > - Added an additional attribute to allow an application to specify the color > space as a hint which should address issue 4. > - Added an additional attribute to allow an application to specify the chroma > siting as a hint which should address issue 5. > - Added an additional attribute to allow an application to specify the sample > range as a hint which should address the new issue 12. > - Added language to end of error section clarifying who owns the fd passed > to eglCreateImageKHR if an error is generated. > > #3 (Tom Cooksey, August 16, 2012) > - Changed name from EGL_EXT_image_external and re-written language to > explicitly state this for use with Linux & dma_buf. > - Added a list of issues, including some still open ones. > > #2 (Jesse Barker, May 30, 2012) > - Revision to split eglCreateImageKHR functionality from export > Functionality. > - Update definition of EGLNativeBufferType to be a struct containing a list > of handles to support multi-buffer/multi-planar formats. > > #1 (Jesse Barker, March 20, 2012) > - Initial draft. > > > > > _______________________________________________ > mesa-dev mailing list > mesa-dev(a)lists.freedesktop.org > http://lists.freedesktop.org/mailman/listinfo/mesa-dev

11 years, 9 months

Reminder: CDF BoF at ELC on Thursday

by Jesse Barker

Hi all, Just a reminder of the BoF on Thursday at 4pm (pacific time) at ELC; in particular, it looks like we'll be in the Mission room of the Parc 55 Wyndham. Remember that you don't need to be registered for the conference to attend the BoF, so Bay Area folks are encouraged to join in. Also, if you know of colleagues that are coming to ELC and might not be on this list, please forward this along so they can attend. Here's a rough agenda: - Aims, goals, and non-goals. - CDFv3 overview. - Considerations for Android. - Future direction. In particular, I think it would be good to call out non-goals, especially for the initial version of the framework so that we have a basis that is genuinely useful to build upon. For reference, the thread on Laurent's report from the FOSDEM BoF http://lists.freedesktop.org/archives/dri-devel/2013-February/034576.html cheers, -- Jesse Barker Principal Software Engineer ARM +1 (408) 576-1423 -- IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you.

11 years, 10 months

dw_mmc build broken in next-20130220 (was Re: [PATCH v3 2/2] lib/scatterlist: use page iterator in the mapping iterator)

by James Hogan

On 13 February 2013 15:10, Imre Deak <imre.deak(a)intel.com> wrote: > For better code reuse use the newly added page iterator to iterate > through the pages. The offset, length within the page is still > calculated by the mapping iterator as well as the actual mapping. > Idea from Tejun Heo <tj(a)kernel.org>. > > Signed-off-by: Imre Deak <imre.deak(a)intel.com> > --- > include/linux/scatterlist.h | 6 +++--- > lib/scatterlist.c | 46 ++++++++++++++++++++----------------------- > 2 files changed, 24 insertions(+), 28 deletions(-) > > diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h > index 788a853..a6cd692 100644 > --- a/include/linux/scatterlist.h > +++ b/include/linux/scatterlist.h > @@ -295,9 +295,9 @@ struct sg_mapping_iter { > size_t consumed; /* number of consumed bytes */ > > /* these are internal states, keep away */ > - struct scatterlist *__sg; /* current entry */ > - unsigned int __nents; /* nr of remaining entries */ > - unsigned int __offset; /* offset within sg */ > + unsigned int __offset; /* offset within page */ > + struct sg_page_iter __piter; /* page iterator */ > + unsigned int __remaining; /* remaining bytes on page */ > unsigned int __flags; > }; Hi, FYI, in next-20130220 this appears to break the build of the dw_mmc driver: drivers/mmc/host/dw_mmc.c In function 'dw_mci_read_data_pio': drivers/mmc/host/dw_mmc.c +1457 : error: 'struct sg_mapping_iter' has no member named '__sg' drivers/mmc/host/dw_mmc.c In function 'dw_mci_write_data_pio': drivers/mmc/host/dw_mmc.c +1512 : error: 'struct sg_mapping_iter' has no member named '__sg' Cheers James

11 years, 10 months

[RFC] ARM: iommu: Adding new dma-mappin API to map sgtable

by Nishanth Peethambaran

Adding APIs in arm dma mapping code to map a scatterlist in iommu domain and get dma address. Allocators outside dma-mapping code like ION could allocate pages and devices would need to map them for iommu and obtain a linear dma address. Intention is to re-use the IOVA managment code and "mapping" across allocators. Can the above requirement be done without adding new APIs? APIs available to map an sglist (arm_dma_map_sg) does not provide a linear dma address. Signed-off-by: Nishanth Peethambaran <nishanth(a)broadcom.com> --- arch/arm/include/asm/dma-mapping.h | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/arch/arm/include/asm/dma-mapping.h b/arch/arm/include/asm/dma-mapping.h index 5b579b9..f9e2f6c 100644 --- a/arch/arm/include/asm/dma-mapping.h +++ b/arch/arm/include/asm/dma-mapping.h @@ -268,6 +268,16 @@ extern void arm_dma_sync_sg_for_device(struct device *, struct scatterlist *, in extern int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr, dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs); +/* + * Map scatterlist pages for the device and return a dma address + */ +extern dma_addr_t arm_dma_map_sgtable(struct device *dev, struct sgtable *sgt, + enum dma_data_direction dir, struct dma_attrs *attrs); +/* + * Unmap the dma address + */ +extern void arm_dma_unmap(struct device *, dma_addr_t iova, int size, + enum dma_data_direction dir, struct dma_attrs *attrs); #endif /* __KERNEL__ */ #endif -- 1.7.9.5

11 years, 10 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

Linaro-mm-sig February 2013