Hi Tomasz,

On Mon, Jan 23, 2012 at 05:51, Tomasz Stanislawski t.stanislaws@samsung.com wrote:

From: Marek Szyprowski m.szyprowski@samsung.com

Signed-off-by: Marek Szyprowski m.szyprowski@samsung.com

drivers/media/video/videobuf2-core.c |   11 +++++++++++  include/media/videobuf2-core.h       |    2 ++  2 files changed, 13 insertions(+), 0 deletions(-)

diff --git a/drivers/media/video/videobuf2-core.c b/drivers/media/video/videobuf2-core.c index 4c3a82e..cb85874 100644 --- a/drivers/media/video/videobuf2-core.c +++ b/drivers/media/video/videobuf2-core.c @@ -836,6 +836,7 @@ void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state)  {        struct vb2_queue *q = vb->vb2_queue;        unsigned long flags;

• int plane;

if (vb->state != VB2_BUF_STATE_ACTIVE)                return; @@ -846,6 +847,10 @@ void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state)        dprintk(4, "Done processing on buffer %d, state: %d\n",                        vb->v4l2_buf.index, vb->state);

• /* sync buffers */
• for (plane = 0; plane < vb->num_planes; ++plane)
• call_memop(q, finish, vb->planes[plane].mem_priv);

/* Add the buffer to the done buffers list */        spin_lock_irqsave(&q->done_lock, flags);        vb->state = state; @@ -1136,9 +1141,15 @@ err:  static void __enqueue_in_driver(struct vb2_buffer *vb)  {        struct vb2_queue *q = vb->vb2_queue;

• int plane;

vb->state = VB2_BUF_STATE_ACTIVE;        atomic_inc(&q->queued_count);

• /* sync buffers */
• for (plane = 0; plane < vb->num_planes; ++plane)
• call_memop(q, prepare, vb->planes[plane].mem_priv);

q->ops->buf_queue(vb);  }

diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h index 35607f7..d8b8171 100644 --- a/include/media/videobuf2-core.h +++ b/include/media/videobuf2-core.h @@ -76,6 +76,8 @@ struct vb2_fileio_data;  */  struct vb2_mem_ops {        void            *(*alloc)(void *alloc_ctx, unsigned long size);

• void            (*prepare)(void *buf_priv);
• void            (*finish)(void *buf_priv);

void            (*put)(void *buf_priv);

void            *(*get_userptr)(void *alloc_ctx, unsigned long vaddr,

1.7.5.4

Those callbacks need to be documented in struct vb2_mem_ops documentation in code. Apart from that the patch looks good.

Em 23-01-2012 11:51, Tomasz Stanislawski escreveu:

Signed-off-by: Tomasz Stanislawski t.stanislaws@samsung.com Signed-off-by: Kyungmin Park kyungmin.park@samsung.com

Please better describe this patch. What is it supposing to fix?

---

drivers/media/video/videobuf2-core.c | 21 +++++++++------------ include/media/videobuf2-core.h | 6 +++--- 2 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/drivers/media/video/videobuf2-core.c b/drivers/media/video/videobuf2-core.c index cb85874..59bb1bc 100644 --- a/drivers/media/video/videobuf2-core.c +++ b/drivers/media/video/videobuf2-core.c @@ -119,7 +119,7 @@ static void __vb2_buf_dmabuf_put(struct vb2_buffer *vb) void *mem_priv = vb->planes[plane].mem_priv; if (mem_priv) {

• 	call_memop(q, plane, detach_dmabuf, mem_priv);
  

• 	call_memop(q, detach_dmabuf, mem_priv);
  

Huh? You're not removing the "plane" parameter on this patch, but, instead, on a previous patch.

No patch is allowed to break compilation, as it breaks git bisect.

	dma_buf_put(vb->planes[plane].dbuf);
	vb->planes[plane].dbuf = NULL;
	vb->planes[plane].mem_priv = NULL;

@@ -907,6 +907,8 @@ static int __fill_vb2_buffer(struct vb2_buffer *vb, const struct v4l2_buffer *b, if (b->memory == V4L2_MEMORY_DMABUF) { for (plane = 0; plane < vb->num_planes; ++plane) { v4l2_planes[plane].m.fd = b->m.planes[plane].m.fd;

• 		v4l2_planes[plane].length =
  

• 			b->m.planes[plane].length;
  }
  

  } } else {

@@ -1055,15 +1057,10 @@ static int __qbuf_dmabuf(struct vb2_buffer *vb, const struct v4l2_buffer *b) if (IS_ERR_OR_NULL(dbuf)) { dprintk(1, "qbuf: invalid dmabuf fd for " "plane %d\n", plane);

• 	ret = PTR_ERR(dbuf);
  

• 	ret = -EINVAL;
  goto err;
  

  }

• /* this doesn't get filled in until __fill_vb2_buffer(),
  

•  * since it isn't known until after dma_buf_get()..
  

•  */
  

• planes[plane].length = dbuf->size;
  

• /* Skip the plane if already verified */ if (dbuf == vb->planes[plane].dbuf) { dma_buf_put(dbuf);

@@ -1075,7 +1072,7 @@ static int __qbuf_dmabuf(struct vb2_buffer *vb, const struct v4l2_buffer *b) /* Release previously acquired memory if present */ if (vb->planes[plane].mem_priv) {

• 	call_memop(q, plane, detach_dmabuf,
  

• 	call_memop(q, detach_dmabuf,
  	vb->planes[plane].mem_priv);
  dma_buf_put(vb->planes[plane].dbuf);
  

  }

@@ -1083,8 +1080,8 @@ static int __qbuf_dmabuf(struct vb2_buffer *vb, const struct v4l2_buffer *b) vb->planes[plane].mem_priv = NULL; /* Acquire each plane's memory */

• mem_priv = q->mem_ops->attach_dmabuf(
  

• 		q->alloc_ctx[plane], dbuf);
  

• mem_priv = q->mem_ops->attach_dmabuf(q->alloc_ctx[plane],
  

• 	dbuf, planes[plane].length, write);
  

  if (IS_ERR(mem_priv)) { dprintk(1, "qbuf: failed acquiring dmabuf " "memory for plane %d\n", plane);

@@ -1102,7 +1099,7 @@ static int __qbuf_dmabuf(struct vb2_buffer *vb, const struct v4l2_buffer *b) */ for (plane = 0; plane < vb->num_planes; ++plane) { ret = q->mem_ops->map_dmabuf(

• 		vb->planes[plane].mem_priv, write);
  

• 	vb->planes[plane].mem_priv);
  

  if (ret) { dprintk(1, "qbuf: failed mapping dmabuf " "memory for plane %d\n", plane);

@@ -1497,7 +1494,7 @@ int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking) */ if (q->memory == V4L2_MEMORY_DMABUF) for (plane = 0; plane < vb->num_planes; ++plane)

• 	call_memop(q, plane, unmap_dmabuf,
  

• 	call_memop(q, unmap_dmabuf,
  	vb->planes[plane].mem_priv);
  

switch (vb->state) { diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h index d8b8171..412c6a4 100644 --- a/include/media/videobuf2-core.h +++ b/include/media/videobuf2-core.h @@ -88,10 +88,10 @@ struct vb2_mem_ops { * in the vb2 core, and vb2_mem_ops really just need to get/put the * sglist (and make sure that the sglist fits it's needs..) */

• void *(*attach_dmabuf)(void *alloc_ctx,

• 			  struct dma_buf *dbuf);
  

• void *(*attach_dmabuf)(void *alloc_ctx, struct dma_buf *dbuf,

• 		unsigned long size, int write);
  

  void (*detach_dmabuf)(void *buf_priv);

• int (*map_dmabuf)(void *buf_priv, int write);

• int (*map_dmabuf)(void *buf_priv); void (*unmap_dmabuf)(void *buf_priv);

void *(*vaddr)(void *buf_priv);

Em 23-01-2012 11:51, Tomasz Stanislawski escreveu:

This patch adds extension to V4L2 api. It allow to export a mmap buffer as file descriptor. New ioctl VIDIOC_EXPBUF is added. It takes a buffer offset used by mmap and return a file descriptor on success.

This requires more discussions.

The usecase for this new API seems to replace the features previously provided by the overlay mode. There, not only the buffer were exposed to userspace, but some control were provided, in order to control the overlay window.

Please start a separate thread about that, explaining how are you imagining that a V4L2 application would use such ioctl.

Regards, Mauro

Signed-off-by: Tomasz Stanislawski t.stanislaws@samsung.com Signed-off-by: Kyungmin Park kyungmin.park@samsung.com

---

drivers/media/video/v4l2-compat-ioctl32.c | 1 + drivers/media/video/v4l2-ioctl.c | 11 +++++++++++ include/linux/videodev2.h | 1 + include/media/v4l2-ioctl.h | 1 + 4 files changed, 14 insertions(+), 0 deletions(-)

diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c index c68531b..0f18b5e 100644 --- a/drivers/media/video/v4l2-compat-ioctl32.c +++ b/drivers/media/video/v4l2-compat-ioctl32.c @@ -954,6 +954,7 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg) case VIDIOC_S_FBUF32: case VIDIOC_OVERLAY32: case VIDIOC_QBUF32:

• case VIDIOC_EXPBUF: case VIDIOC_DQBUF32: case VIDIOC_STREAMON32: case VIDIOC_STREAMOFF32:

diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c index e1da8fc..cb29e00 100644 --- a/drivers/media/video/v4l2-ioctl.c +++ b/drivers/media/video/v4l2-ioctl.c @@ -207,6 +207,7 @@ static const char *v4l2_ioctls[] = { [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF", [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY", [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",

• [_IOC_NR(VIDIOC_EXPBUF)] = "VIDIOC_EXPBUF", [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF", [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON", [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",

@@ -932,6 +933,16 @@ static long __video_do_ioctl(struct file *file, dbgbuf(cmd, vfd, p); break; }

• case VIDIOC_EXPBUF:
• {

• unsigned int *p = arg;
  

• if (!ops->vidioc_expbuf)
  

• 	break;
  

• ret = ops->vidioc_expbuf(file, fh, *p);
  

• break;
  

• } case VIDIOC_DQBUF: { struct v4l2_buffer *p = arg;

diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h index 3c0ade1..448fbed 100644 --- a/include/linux/videodev2.h +++ b/include/linux/videodev2.h @@ -2183,6 +2183,7 @@ struct v4l2_create_buffers { #define VIDIOC_S_FBUF _IOW('V', 11, struct v4l2_framebuffer) #define VIDIOC_OVERLAY _IOW('V', 14, int) #define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer) +#define VIDIOC_EXPBUF _IOWR('V', 16, __u32) #define VIDIOC_DQBUF _IOWR('V', 17, struct v4l2_buffer) #define VIDIOC_STREAMON _IOW('V', 18, int) #define VIDIOC_STREAMOFF _IOW('V', 19, int) diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h index 4d1c74a..8201546 100644 --- a/include/media/v4l2-ioctl.h +++ b/include/media/v4l2-ioctl.h @@ -120,6 +120,7 @@ struct v4l2_ioctl_ops { int (*vidioc_reqbufs) (struct file *file, void *fh, struct v4l2_requestbuffers *b); int (*vidioc_querybuf)(struct file *file, void *fh, struct v4l2_buffer *b); int (*vidioc_qbuf) (struct file *file, void *fh, struct v4l2_buffer *b);

• int (*vidioc_expbuf) (struct file *file, void *fh, __u32 offset); int (*vidioc_dqbuf) (struct file *file, void *fh, struct v4l2_buffer *b);

int (*vidioc_create_bufs)(struct file *file, void *fh, struct v4l2_create_buffers *b);

Hi Mauro. On 01/23/2012 03:32 PM, Mauro Carvalho Chehab wrote:

Em 23-01-2012 11:51, Tomasz Stanislawski escreveu:

...

This patch adds extension to V4L2 api. It allow to export a mmap buffer as file descriptor. New ioctl VIDIOC_EXPBUF is added. It takes a buffer offset used by mmap and return a file descriptor on success.

This requires more discussions.

The usecase for this new API seems to replace the features previously provided by the overlay mode. There, not only the buffer were exposed to userspace, but some control were provided, in order to control the overlay window.

This ioctl was introduced to support exporting of V4L2 buffers via dma-buf interface. This framework was little common with overlay mode. Could you describe what overlay mode feature is replaced by VIDIOC_EXPBUF?

Please start a separate thread about that, explaining how are you imagining that a V4L2 application would use such ioctl.

This patch is essential for full implementation of support for DMABUF framework in V4L2. Therefore the patch cannot be moved to separate thread.

Regrads, Tomasz Stanislawski

Regards, Mauro

...

Signed-off-by: Tomasz Stanislawskit.stanislaws@samsung.com Signed-off-by: Kyungmin Parkkyungmin.park@samsung.com

---

drivers/media/video/v4l2-compat-ioctl32.c | 1 + drivers/media/video/v4l2-ioctl.c | 11 +++++++++++ include/linux/videodev2.h | 1 + include/media/v4l2-ioctl.h | 1 + 4 files changed, 14 insertions(+), 0 deletions(-)

diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c index c68531b..0f18b5e 100644 --- a/drivers/media/video/v4l2-compat-ioctl32.c +++ b/drivers/media/video/v4l2-compat-ioctl32.c @@ -954,6 +954,7 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg) case VIDIOC_S_FBUF32: case VIDIOC_OVERLAY32: case VIDIOC_QBUF32:

• case VIDIOC_EXPBUF: case VIDIOC_DQBUF32: case VIDIOC_STREAMON32: case VIDIOC_STREAMOFF32:

diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c index e1da8fc..cb29e00 100644 --- a/drivers/media/video/v4l2-ioctl.c +++ b/drivers/media/video/v4l2-ioctl.c @@ -207,6 +207,7 @@ static const char *v4l2_ioctls[] = { [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF", [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY", [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",

• [_IOC_NR(VIDIOC_EXPBUF)] = "VIDIOC_EXPBUF", [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF", [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON", [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",

@@ -932,6 +933,16 @@ static long __video_do_ioctl(struct file *file, dbgbuf(cmd, vfd, p); break; }

• case VIDIOC_EXPBUF:
• {

• unsigned int *p = arg;
  

• if (!ops->vidioc_expbuf)
  

• 	break;
  

• ret = ops->vidioc_expbuf(file, fh, *p);
  

• break;
  

• } case VIDIOC_DQBUF: { struct v4l2_buffer *p = arg;

diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h index 3c0ade1..448fbed 100644 --- a/include/linux/videodev2.h +++ b/include/linux/videodev2.h @@ -2183,6 +2183,7 @@ struct v4l2_create_buffers { #define VIDIOC_S_FBUF _IOW('V', 11, struct v4l2_framebuffer) #define VIDIOC_OVERLAY _IOW('V', 14, int) #define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer) +#define VIDIOC_EXPBUF _IOWR('V', 16, __u32) #define VIDIOC_DQBUF _IOWR('V', 17, struct v4l2_buffer) #define VIDIOC_STREAMON _IOW('V', 18, int) #define VIDIOC_STREAMOFF _IOW('V', 19, int) diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h index 4d1c74a..8201546 100644 --- a/include/media/v4l2-ioctl.h +++ b/include/media/v4l2-ioctl.h @@ -120,6 +120,7 @@ struct v4l2_ioctl_ops { int (*vidioc_reqbufs) (struct file *file, void *fh, struct v4l2_requestbuffers *b); int (*vidioc_querybuf)(struct file *file, void *fh, struct v4l2_buffer *b); int (*vidioc_qbuf) (struct file *file, void *fh, struct v4l2_buffer *b);

• int (*vidioc_expbuf) (struct file *file, void *fh, __u32 offset); int (*vidioc_dqbuf) (struct file *file, void *fh, struct v4l2_buffer *b);

  int (*vidioc_create_bufs)(struct file *file, void *fh, struct v4l2_create_buffers *b);

Hi,

On 01/24/2012 12:07 PM, Subash Patel wrote:

Hello Thomasz,

Instead of adding another IOCTL to query the file-descriptor in user-space, why dont we extend the existing ones in v4l2/vb2?

When the memory type set is V4L2_MEMORY_DMABUF, call to VIDIOC_REQBUFS /VIDIOC_QUERYBUF from driver can take/return the fd. We will need to add another attribute to struct v4l2_requestbuffers for this.

struct v4l2_requestbuffers { ... __u32 buf_fd; };

The application requesting buffer would set it to -1, and will receive the fd's when it calls the vb2_querybuf. In the same way, application which is trying to attach to already allocated buffer will set this to valid fd when it calls vidioc_reqbuf, and in vb2_reqbuf depending on the memory type, this can be checked and used to attach with the dma_buf for the respective buffer.

Ofcourse, this requires changes in vb2_reqbufs and vb2_querybuf similar to what you did in vb2_expbufs.

Will there be any issues in such an approach?

I like your idea but IMO there are some issues which this approach.

The VIDIOC_REQBUF is used to create a collection of buffers (i.e. 5 frames). Every frame is a separate buffer therefore it should have separate dmabuf file descriptor. This way you should add buffer index to v4l2_request_buffers. Of course but one could reuse count field but there is still problem with multiplane buffers (see below).

Please note that dmabuf file could be create only for buffers with MMAP memory type. The DMABUF memory type for VIDIOC_REQBUFS indicate that a buffer is imported from DMABUF file descriptor. Similar way like content of USERPTR buffers is taken from user pointer.

Therefore only MMAP buffers can be exported as DMABUF file descriptor.

If VIDIOC_REQUBUF is used for buffer exporting, how to request a bunch of buffers that are dedicated to obtain memory from DMABUF file descriptors?

The second problem is VIDIOC_QUERYBUF. According to V4L2 spec, the memory type field is read only. The driver returns the same memory type as it was used in VIDIOC_REQBUFS. Therefore VIDIOC_QUERYBUF can only be used for MMAP buffers to obtain memoffset. For DMABUF it may return fd=-1 or most recently used file descriptor. As I remember, it was not defined yet.

The third reason are multiplane buffers. This API was introduced if V4L2 buffer (IMO it should be called a frame) consist of multiple memory buffers. Every plane can be mmapped separately. Therefore it should be possible to export every plane as separate DMABUF descriptor.

After some research it was found that memoffset is good identifier of a plane in a buffers. This id is also available in the userspace without any API extensions.

VIDIOC_EXPBUF was used to export a buffer by id, similar way as mmap uses this identifier to map a buffer to userspace. It seams to be the simplest solution.

Fourth reason, VIDIOC_REQBUF means that the application request a buffer. DMABUF framework is used to export existing buffers. Note that memory may not be pinned to a buffer for some APIs like DRM. I think that is should stated explicitly that application wants to export not request a buffer. Using VIDIOC_REQBUF seams to be an API abuse.

What is your opinion?

Regards, Tomasz Stanislawski

Regards, Subash

On 01/23/2012 07:21 PM, Tomasz Stanislawski wrote:

...

This patch adds extension to V4L2 api. It allow to export a mmap buffer as file descriptor. New ioctl VIDIOC_EXPBUF is added. It takes a buffer offset used by mmap and return a file descriptor on success.

Signed-off-by: Tomasz Stanislawskit.stanislaws@samsung.com Signed-off-by: Kyungmin Parkkyungmin.park@samsung.com

---

drivers/media/video/v4l2-compat-ioctl32.c | 1 + drivers/media/video/v4l2-ioctl.c | 11 +++++++++++ include/linux/videodev2.h | 1 + include/media/v4l2-ioctl.h | 1 + 4 files changed, 14 insertions(+), 0 deletions(-)

diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c index c68531b..0f18b5e 100644 --- a/drivers/media/video/v4l2-compat-ioctl32.c +++ b/drivers/media/video/v4l2-compat-ioctl32.c @@ -954,6 +954,7 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg) case VIDIOC_S_FBUF32: case VIDIOC_OVERLAY32: case VIDIOC_QBUF32:

• case VIDIOC_EXPBUF:

case VIDIOC_DQBUF32: case VIDIOC_STREAMON32: case VIDIOC_STREAMOFF32: diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c index e1da8fc..cb29e00 100644 --- a/drivers/media/video/v4l2-ioctl.c +++ b/drivers/media/video/v4l2-ioctl.c @@ -207,6 +207,7 @@ static const char *v4l2_ioctls[] = { [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF", [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY", [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",

• [_IOC_NR(VIDIOC_EXPBUF)] = "VIDIOC_EXPBUF",

[_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF", [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON", [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF", @@ -932,6 +933,16 @@ static long __video_do_ioctl(struct file *file, dbgbuf(cmd, vfd, p); break; }

• case VIDIOC_EXPBUF:
• {
• unsigned int *p = arg;
• if (!ops->vidioc_expbuf)
• break;
• ret = ops->vidioc_expbuf(file, fh, *p);
• break;
• }

case VIDIOC_DQBUF: { struct v4l2_buffer *p = arg; diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h index 3c0ade1..448fbed 100644 --- a/include/linux/videodev2.h +++ b/include/linux/videodev2.h @@ -2183,6 +2183,7 @@ struct v4l2_create_buffers { #define VIDIOC_S_FBUF _IOW('V', 11, struct v4l2_framebuffer) #define VIDIOC_OVERLAY _IOW('V', 14, int) #define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer) +#define VIDIOC_EXPBUF _IOWR('V', 16, __u32) #define VIDIOC_DQBUF _IOWR('V', 17, struct v4l2_buffer) #define VIDIOC_STREAMON _IOW('V', 18, int) #define VIDIOC_STREAMOFF _IOW('V', 19, int) diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h index 4d1c74a..8201546 100644 --- a/include/media/v4l2-ioctl.h +++ b/include/media/v4l2-ioctl.h @@ -120,6 +120,7 @@ struct v4l2_ioctl_ops { int (*vidioc_reqbufs) (struct file *file, void *fh, struct v4l2_requestbuffers *b); int (*vidioc_querybuf)(struct file *file, void *fh, struct v4l2_buffer *b); int (*vidioc_qbuf) (struct file *file, void *fh, struct v4l2_buffer *b);

• int (*vidioc_expbuf) (struct file *file, void *fh, __u32 offset);

int (*vidioc_dqbuf) (struct file *file, void *fh, struct v4l2_buffer *b);

int (*vidioc_create_bufs)(struct file *file, void *fh, struct v4l2_create_buffers *b);

Em 23-01-2012 11:51, Tomasz Stanislawski escreveu:

This is temporary patch. The dma-contig changes were significant and the difference patch would be very difficult to read.

NACK.

This breaks git bisect.

Signed-off-by: Tomasz Stanislawski t.stanislaws@samsung.com Signed-off-by: Kyungmin Park kyungmin.park@samsung.com

---

drivers/media/video/videobuf2-dma-contig.c | 308 ---------------------------- 1 files changed, 0 insertions(+), 308 deletions(-) delete mode 100644 drivers/media/video/videobuf2-dma-contig.c

diff --git a/drivers/media/video/videobuf2-dma-contig.c b/drivers/media/video/videobuf2-dma-contig.c deleted file mode 100644 index ea2699f..0000000 --- a/drivers/media/video/videobuf2-dma-contig.c +++ /dev/null @@ -1,308 +0,0 @@ -/*

• • videobuf2-dma-contig.c - DMA contig memory allocator for videobuf2
• • Copyright (C) 2010 Samsung Electronics
• • Author: Pawel Osciak pawel@osciak.com
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License as published by
• • the Free Software Foundation.
• */

-#include <linux/module.h> -#include <linux/slab.h> -#include <linux/dma-mapping.h> -#include <linux/scatterlist.h> -#include <linux/dma-buf.h>

-#include <media/videobuf2-core.h> -#include <media/videobuf2-memops.h>

-struct vb2_dc_conf {

• struct device *dev;

-};

-struct vb2_dc_buf {

• struct vb2_dc_conf *conf;
• void *vaddr;
• dma_addr_t dma_addr;
• unsigned long size;
• struct vm_area_struct *vma;
• struct dma_buf_attachment *db_attach;
• atomic_t refcount;
• struct vb2_vmarea_handler handler;

-};

-static void vb2_dma_contig_put(void *buf_priv);

-static void *vb2_dma_contig_alloc(void *alloc_ctx, unsigned long size) -{

• struct vb2_dc_conf *conf = alloc_ctx;
• struct vb2_dc_buf *buf;
• /* TODO: add db_attach processing while adding DMABUF as exporter */
• buf = kzalloc(sizeof *buf, GFP_KERNEL);
• if (!buf)

• return ERR_PTR(-ENOMEM);
  

• buf->vaddr = dma_alloc_coherent(conf->dev, size, &buf->dma_addr,

• 			GFP_KERNEL);
  

• if (!buf->vaddr) {

• dev_err(conf->dev, "dma_alloc_coherent of size %ld failed\n",
  

• 	size);
  

• kfree(buf);
  

• return ERR_PTR(-ENOMEM);
  

• }
• buf->conf = conf;
• buf->size = size;
• buf->handler.refcount = &buf->refcount;
• buf->handler.put = vb2_dma_contig_put;
• buf->handler.arg = buf;
• atomic_inc(&buf->refcount);
• return buf;

-}

-static void vb2_dma_contig_put(void *buf_priv) -{

• struct vb2_dc_buf *buf = buf_priv;
• if (atomic_dec_and_test(&buf->refcount)) {

• dma_free_coherent(buf->conf->dev, buf->size, buf->vaddr,
  

• 		  buf->dma_addr);
  

• kfree(buf);
  

• }

-}

-static void *vb2_dma_contig_cookie(void *buf_priv) -{

• struct vb2_dc_buf *buf = buf_priv;
• return &buf->dma_addr;

-}

-static void *vb2_dma_contig_vaddr(void *buf_priv) -{

• struct vb2_dc_buf *buf = buf_priv;
• if (!buf)

• return 0;
  

• return buf->vaddr;

-}

-static unsigned int vb2_dma_contig_num_users(void *buf_priv) -{

• struct vb2_dc_buf *buf = buf_priv;
• return atomic_read(&buf->refcount);

-}

-static int vb2_dma_contig_mmap(void *buf_priv, struct vm_area_struct *vma) -{

• struct vb2_dc_buf *buf = buf_priv;
• if (!buf) {

• printk(KERN_ERR "No buffer to map\n");
  

• return -EINVAL;
  

• }
• return vb2_mmap_pfn_range(vma, buf->dma_addr, buf->size,

• 		  &vb2_common_vm_ops, &buf->handler);
  

-}

-static void *vb2_dma_contig_get_userptr(void *alloc_ctx, unsigned long vaddr,

• 			unsigned long size, int write)
  

-{

• struct vb2_dc_buf *buf;
• struct vm_area_struct *vma;
• dma_addr_t dma_addr = 0;
• int ret;
• buf = kzalloc(sizeof *buf, GFP_KERNEL);
• if (!buf)

• return ERR_PTR(-ENOMEM);
  

• ret = vb2_get_contig_userptr(vaddr, size, &vma, &dma_addr);
• if (ret) {

• printk(KERN_ERR "Failed acquiring VMA for vaddr 0x%08lx\n",
  

• 		vaddr);
  

• kfree(buf);
  

• return ERR_PTR(ret);
  

• }
• buf->size = size;
• buf->dma_addr = dma_addr;
• buf->vma = vma;
• return buf;

-}

-static void vb2_dma_contig_put_userptr(void *mem_priv) -{

• struct vb2_dc_buf *buf = mem_priv;
• if (!buf)

• return;
  

• vb2_put_vma(buf->vma);
• kfree(buf);

-}

-static int vb2_dma_contig_map_dmabuf(void *mem_priv,

• 			enum dma_data_direction direction)
  

-{

• struct vb2_dc_buf *buf = mem_priv;
• struct dma_buf *dmabuf;
• struct sg_table *sg;
• if (!buf || !buf->db_attach) {

• printk(KERN_ERR "No dma buffer to pin\n");
  

• return -EINVAL;
  

• }
• WARN_ON(buf->dma_addr);
• if (direction == DMA_NONE) {

• printk(KERN_ERR "Incorrect DMA direction\n");
  

• return -EINVAL;
  

• }
• dmabuf = buf->db_attach->dmabuf;
• /* get the associated scatterlist for this buffer */
• sg = dma_buf_map_attachment(buf->db_attach, direction);
• if (!sg) {

• printk(KERN_ERR "Error getting dmabuf scatterlist\n");
  

• return -EINVAL;
  

• }
• /*

• *  convert sglist to paddr:
  

• *  Assumption: for dma-contig, dmabuf would map to single entry
  

• *  Will return an error if it has more than one.
  

• */
  

• if (sg->nents > 1) {

• printk(KERN_ERR
  

• 	"dmabuf scatterlist has more than 1 entry\n");
  

• return -EINVAL;
  

• }
• buf->dma_addr = sg_dma_address(sg->sgl);
• /* TODO: check the buffer size as per S_FMT */
• buf->size = sg_dma_len(sg->sgl);
• /* save this scatterlist in dmabuf for put_scatterlist */
• dmabuf->priv = sg;
• return 0;

-}

-static void vb2_dma_contig_unmap_dmabuf(void *mem_priv) -{

• struct vb2_dc_buf *buf = mem_priv;
• struct dma_buf *dmabuf;
• struct sg_table *sg;
• if (!buf || !buf->db_attach)

• return;
  

• WARN_ON(!buf->dma_addr);
• dmabuf = buf->db_attach->dmabuf;
• sg = dmabuf->priv;
• /* Put the sg for this buffer */
• dma_buf_unmap_attachment(buf->db_attach, sg);
• buf->dma_addr = 0;
• buf->size = 0;

-}

-static void *vb2_dma_contig_attach_dmabuf(void *alloc_ctx, struct dma_buf *dbuf) -{

• struct vb2_dc_conf *conf = alloc_ctx;
• struct vb2_dc_buf *buf;
• struct dma_buf_attachment *dba;
• buf = kzalloc(sizeof *buf, GFP_KERNEL);
• if (!buf)

• return ERR_PTR(-ENOMEM);
  

• /* create attachment for the dmabuf with the user device */
• dba = dma_buf_attach(dbuf, conf->dev);
• if (IS_ERR(dba)) {

• printk(KERN_ERR "failed to attach dmabuf\n");
  

• kfree(buf);
  

• return dba;
  

• }
• buf->conf = conf;
• buf->size = dba->dmabuf->size;
• buf->db_attach = dba;
• buf->dma_addr = 0; /* dma_addr is available only after map */
• return buf;

-}

-static void vb2_dma_contig_detach_dmabuf(void *mem_priv) -{

• struct vb2_dc_buf *buf = mem_priv;
• if (!buf)

• return;
  

• if (buf->dma_addr) {

• vb2_dma_contig_unmap_dmabuf(buf);
  

• }
• /* detach this attachment */
• dma_buf_detach(buf->db_attach->dmabuf, buf->db_attach);
• buf->db_attach = NULL;
• kfree(buf);

-}

-const struct vb2_mem_ops vb2_dma_contig_memops = {

• .alloc = vb2_dma_contig_alloc,
• .put = vb2_dma_contig_put,
• .cookie = vb2_dma_contig_cookie,
• .vaddr = vb2_dma_contig_vaddr,
• .mmap = vb2_dma_contig_mmap,
• .get_userptr = vb2_dma_contig_get_userptr,
• .put_userptr = vb2_dma_contig_put_userptr,
• .map_dmabuf = vb2_dma_contig_map_dmabuf,
• .unmap_dmabuf = vb2_dma_contig_unmap_dmabuf,
• .attach_dmabuf = vb2_dma_contig_attach_dmabuf,
• .detach_dmabuf = vb2_dma_contig_detach_dmabuf,
• .num_users = vb2_dma_contig_num_users,

-}; -EXPORT_SYMBOL_GPL(vb2_dma_contig_memops);

-void *vb2_dma_contig_init_ctx(struct device *dev) -{

• struct vb2_dc_conf *conf;
• conf = kzalloc(sizeof *conf, GFP_KERNEL);
• if (!conf)

• return ERR_PTR(-ENOMEM);
  

• conf->dev = dev;
• return conf;

-} -EXPORT_SYMBOL_GPL(vb2_dma_contig_init_ctx);

-void vb2_dma_contig_cleanup_ctx(void *alloc_ctx) -{

• kfree(alloc_ctx);

-} -EXPORT_SYMBOL_GPL(vb2_dma_contig_cleanup_ctx);

-MODULE_DESCRIPTION("DMA-contig memory handling routines for videobuf2"); -MODULE_AUTHOR("Pawel Osciak pawel@osciak.com"); -MODULE_LICENSE("GPL");

Em 23-01-2012 11:51, Tomasz Stanislawski escreveu:

Signed-off-by: Pawel Osciak pawel@osciak.com [author of the original file] Signed-off-by: Marek Szyprowski m.szyprowski@samsung.com [implemetation of mmap, finish/prepare] Signed-off-by: Andrzej Pietrasiewicz andrzej.p@samsung.com [implementation of userprt handling] Signed-off-by: Sumit Semwal sumit.semwal@ti.com Signed-off-by: Sumit Semwal sumit.semwal@linaro.org [PoC for importing dmabuf buffer] Signed-off-by: Tomasz Stanislawski t.stanislaws@samsung.com [buffer exporting using dmabuf, code refactoring] Signed-off-by: Kyungmin Park kyungmin.park@samsung.com

Please provide a diff against the existing driver, in order to allow reviewing what has changed.

---

drivers/media/video/videobuf2-dma-contig.c | 762 ++++++++++++++++++++++++++++ 1 files changed, 762 insertions(+), 0 deletions(-) create mode 100644 drivers/media/video/videobuf2-dma-contig.c

diff --git a/drivers/media/video/videobuf2-dma-contig.c b/drivers/media/video/videobuf2-dma-contig.c new file mode 100644 index 0000000..d95b23a --- /dev/null +++ b/drivers/media/video/videobuf2-dma-contig.c @@ -0,0 +1,762 @@ +/*

• • videobuf2-dma-contig.c - DMA contig memory allocator for videobuf2
• • Copyright (C) 2010 Samsung Electronics
• • Author: Pawel Osciak pawel@osciak.com
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License as published by
• • the Free Software Foundation.
• */

+#include <linux/dma-buf.h> +#include <linux/dma-mapping.h> +#include <linux/module.h> +#include <linux/scatterlist.h> +#include <linux/sched.h> +#include <linux/slab.h>

+#include <media/videobuf2-core.h> +#include <media/videobuf2-memops.h>

+struct vb2_dc_buf {

• struct device *dev;
• void *vaddr;
• unsigned long size;
• dma_addr_t dma_addr;
• struct sg_table *dma_sgt;
• enum dma_data_direction dma_dir;
• /* MMAP related */
• struct vb2_vmarea_handler handler;
• atomic_t refcount;
• struct dma_buf *dma_buf;
• struct sg_table *sgt_base;
• /* USERPTR related */
• struct vm_area_struct *vma;
• /* DMABUF related */
• struct dma_buf_attachment *db_attach;

+};

+/*********************************************/ +/* scatterlist table functions */ +/*********************************************/

+static struct sg_table *vb2_dc_pages_to_sgt(struct page **pages,

• unsigned long n_pages, size_t offset, size_t offset2)

+{

• struct sg_table *sgt;
• int i, j; /* loop counters */
• int cur_page, chunks;
• int ret;
• struct scatterlist *s;
• sgt = kzalloc(sizeof *sgt, GFP_KERNEL);
• if (!sgt)

• return ERR_PTR(-ENOMEM);
  

• /* compute number of chunks */
• chunks = 1;
• for (i = 1; i < n_pages; ++i)

• if (pages[i] != pages[i - 1] + 1)
  

• 	++chunks;
  

• ret = sg_alloc_table(sgt, chunks, GFP_KERNEL);
• if (ret) {

• kfree(sgt);
  

• return ERR_PTR(-ENOMEM);
  

• }
• /* merging chunks and putting them into the scatterlist */
• cur_page = 0;
• for_each_sg(sgt->sgl, s, sgt->orig_nents, i) {

• size_t size = PAGE_SIZE;
  

• for (j = cur_page + 1; j < n_pages; ++j) {
  

• 	if (pages[j] != pages[j - 1] + 1)
  

• 		break;
  

• 	size += PAGE_SIZE;
  

• }
  

• /* cut offset if chunk starts at the first page */
  

• if (cur_page == 0)
  

• 	size -= offset;
  

• /* cut offset2 if chunk ends at the last page */
  

• if (j == n_pages)
  

• 	size -= offset2;
  

• sg_set_page(s, pages[cur_page], size, offset);
  

• offset = 0;
  

• cur_page = j;
  

• }
• return sgt;

+}

+static void vb2_dc_release_sgtable(struct sg_table *sgt) +{

• sg_free_table(sgt);
• kfree(sgt);

+}

+static void vb2_dc_put_sgtable(struct sg_table *sgt, int dirty) +{

• struct scatterlist *s;
• int i, j;
• for_each_sg(sgt->sgl, s, sgt->nents, i) {

• struct page *page = sg_page(s);
  

• int n_pages = PAGE_ALIGN(s->offset + s->length) >> PAGE_SHIFT;
  

• for (j = 0; j < n_pages; ++j, ++page) {
  

• 	if (dirty)
  

• 		set_page_dirty_lock(page);
  

• 	put_page(page);
  

• }
  

• }
• vb2_dc_release_sgtable(sgt);

+}

+static unsigned long vb2_dc_get_contiguous_size(struct sg_table *sgt) +{

• struct scatterlist *s;
• dma_addr_t expected = sg_dma_address(sgt->sgl);
• int i;
• unsigned long size = 0;
• for_each_sg(sgt->sgl, s, sgt->nents, i) {

• if (sg_dma_address(s) != expected)
  

• 	break;
  

• expected = sg_dma_address(s) + sg_dma_len(s);
  

• size += sg_dma_len(s);
  

• }
• return size;

+}

+/*********************************************/ +/* callbacks for all buffers */ +/*********************************************/

+static void *vb2_dc_cookie(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• return &buf->dma_addr;

+}

+static void *vb2_dc_vaddr(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• return buf->vaddr;

+}

+static unsigned int vb2_dc_num_users(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• return atomic_read(&buf->refcount);

+}

+static void vb2_dc_prepare(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• struct sg_table *sgt = buf->dma_sgt;
• if (!sgt)

• return;
  

• dma_sync_sg_for_device(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir);

+}

+static void vb2_dc_finish(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• struct sg_table *sgt = buf->dma_sgt;
• if (!sgt)

• return;
  

• dma_sync_sg_for_cpu(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir);

+}

+/*********************************************/ +/* callbacks for MMAP buffers */ +/*********************************************/

+static void vb2_dc_put(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• if (!atomic_dec_and_test(&buf->refcount))

• return;
  

• if (buf->dma_buf)

• dma_buf_put(buf->dma_buf);
  

• vb2_dc_release_sgtable(buf->sgt_base);
• dma_free_coherent(buf->dev, buf->size, buf->vaddr,

• buf->dma_addr);
  

• kfree(buf);

+}

+static void *vb2_dc_alloc(void *alloc_ctx, unsigned long size) +{

• struct device *dev = alloc_ctx;
• struct vb2_dc_buf *buf;
• int ret;
• int n_pages;
• struct page **pages = NULL;
• buf = kzalloc(sizeof *buf, GFP_KERNEL);
• if (!buf)

• return ERR_PTR(-ENOMEM);
  

• buf->dev = dev;
• buf->size = size;
• buf->vaddr = dma_alloc_coherent(buf->dev, buf->size, &buf->dma_addr,

• GFP_KERNEL);
  

• ret = -ENOMEM;
• if (!buf->vaddr) {

• dev_err(dev, "dma_alloc_coherent of size %ld failed\n",
  

• 	size);
  

• goto fail_buf;
  

• }
• WARN_ON((unsigned long)buf->vaddr & ~PAGE_MASK);
• WARN_ON(buf->dma_addr & ~PAGE_MASK);
• n_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
• pages = kmalloc(n_pages * sizeof pages[0], GFP_KERNEL);
• if (!pages) {

• printk(KERN_ERR "failed to alloc page table\n");
  

• goto fail_dma;
  

• }
• ret = dma_get_pages(dev, buf->vaddr, buf->dma_addr, pages, n_pages);
• if (ret < 0) {

• printk(KERN_ERR "failed to get buffer pages from DMA API\n");
  

• goto fail_pages;
  

• }
• if (ret != n_pages) {

• ret = -EFAULT;
  

• printk(KERN_ERR "failed to get all pages from DMA API\n");
  

• goto fail_pages;
  

• }
• buf->sgt_base = vb2_dc_pages_to_sgt(pages, n_pages, 0, 0);
• if (IS_ERR(buf->sgt_base)) {

• ret = PTR_ERR(buf->sgt_base);
  

• printk(KERN_ERR "failed to prepare sg table\n");
  

• goto fail_pages;
  

• }
• /* pages are no longer needed */
• kfree(pages);
• buf->handler.refcount = &buf->refcount;
• buf->handler.put = vb2_dc_put;
• buf->handler.arg = buf;
• atomic_inc(&buf->refcount);
• return buf;

+fail_pages:

• kfree(pages);

+fail_dma:

• dma_free_coherent(buf->dev, buf->size, buf->vaddr, buf->dma_addr);

+fail_buf:

• kfree(buf);
• return ERR_PTR(ret);

+}

+static int vb2_dc_mmap(void *buf_priv, struct vm_area_struct *vma) +{

• struct vb2_dc_buf *buf = buf_priv;
• int ret;
• /*

• * dma_mmap_* uses vm_pgoff as in-buffer offset, but we want to
  

• * map whole buffer
  

• */
  

• vma->vm_pgoff = 0;
• ret = dma_mmap_writecombine(buf->dev, vma, buf->vaddr,

• buf->dma_addr, buf->size);
  

• if (ret) {

• printk(KERN_ERR "Remapping memory failed, error: %d\n", ret);
  

• return ret;
  

• }
• vma->vm_flags |= VM_DONTEXPAND | VM_RESERVED;
• vma->vm_private_data = &buf->handler;
• vma->vm_ops = &vb2_common_vm_ops;
• vma->vm_ops->open(vma);
• printk(KERN_DEBUG "%s: mapped dma addr 0x%08lx at 0x%08lx, size %ld\n",

• __func__, (unsigned long)buf->dma_addr, vma->vm_start,
  

• buf->size);
  

• return 0;

+}

+/*********************************************/ +/* DMABUF ops for exporters */ +/*********************************************/

+struct vb2_dc_attachment {

• struct sg_table sgt;
• enum dma_data_direction dir;

+};

+static int vb2_dc_dmabuf_ops_attach(struct dma_buf *dbuf, struct device *dev,

• struct dma_buf_attachment *dbuf_attach)

+{

• /* nothing to be done */
• return 0;

+}

+static void vb2_dc_dmabuf_ops_detach(struct dma_buf *dbuf,

• struct dma_buf_attachment *db_attach)

+{

• struct vb2_dc_attachment *attach = db_attach->priv;
• struct sg_table *sgt;
• if (!attach)

• return;
  

• sgt = &attach->sgt;
• dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->nents, attach->dir);
• sg_free_table(sgt);
• kfree(attach);
• db_attach->priv = NULL;

+}

+static struct sg_table *vb2_dc_dmabuf_ops_map(

• struct dma_buf_attachment *db_attach, enum dma_data_direction dir)

+{

• struct dma_buf *dbuf = db_attach->dmabuf;
• struct vb2_dc_buf *buf = dbuf->priv;
• struct vb2_dc_attachment *attach = db_attach->priv;
• struct sg_table *sgt;
• struct scatterlist *rd, *wr;
• int i, ret;
• /* return previously mapped sg table */
• if (attach)

• return &attach->sgt;
  

• attach = kzalloc(sizeof *attach, GFP_KERNEL);
• if (!attach)

• return ERR_PTR(-ENOMEM);
  

• sgt = &attach->sgt;
• attach->dir = dir;
• /* copying the buf->base_sgt to attachment */
• ret = sg_alloc_table(sgt, buf->sgt_base->orig_nents, GFP_KERNEL);
• if (ret) {

• kfree(attach);
  

• return ERR_PTR(-ENOMEM);
  

• }
• rd = buf->sgt_base->sgl;
• wr = sgt->sgl;
• for (i = 0; i < sgt->orig_nents; ++i) {

• sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
  

• rd = sg_next(rd);
  

• wr = sg_next(wr);
  

• }
• /* mapping new sglist to the client */
• ret = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents, dir);
• if (ret <= 0) {

• printk(KERN_ERR "failed to map scatterlist\n");
  

• sg_free_table(sgt);
  

• kfree(attach);
  

• return ERR_PTR(-EIO);
  

• }
• db_attach->priv = attach;
• return sgt;

+}

+static void vb2_dc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,

• struct sg_table *sgt)

+{

• /* nothing to be done here */

+}

+static void vb2_dc_dmabuf_ops_release(struct dma_buf *dbuf) +{

• /* drop reference obtained in vb2_dc_get_dmabuf */
• vb2_dc_put(dbuf->priv);

+}

+static struct dma_buf_ops vb2_dc_dmabuf_ops = {

• .attach = vb2_dc_dmabuf_ops_attach,
• .detach = vb2_dc_dmabuf_ops_detach,
• .map_dma_buf = vb2_dc_dmabuf_ops_map,
• .unmap_dma_buf = vb2_dc_dmabuf_ops_unmap,
• .release = vb2_dc_dmabuf_ops_release,

+};

+static struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• struct dma_buf *dbuf;
• if (buf->dma_buf)

• return buf->dma_buf;
  

• /* dmabuf keeps reference to vb2 buffer */
• atomic_inc(&buf->refcount);
• dbuf = dma_buf_export(buf, &vb2_dc_dmabuf_ops, buf->size, 0);
• if (IS_ERR(dbuf)) {

• atomic_dec(&buf->refcount);
  

• return NULL;
  

• }
• buf->dma_buf = dbuf;
• return dbuf;

+}

+/*********************************************/ +/* callbacks for USERPTR buffers */ +/*********************************************/

+static inline int vma_is_io(struct vm_area_struct *vma) +{

• return !!(vma->vm_flags & (VM_IO | VM_PFNMAP));

+}

+static int vb2_dc_get_pages(unsigned long start, struct page **pages,

• int n_pages, struct vm_area_struct **copy_vma, int write)

+{

• struct vm_area_struct *vma;
• int n = 0; /* number of get pages */
• int ret = -EFAULT;
• /* entering critical section for mm access */
• down_read(&current->mm->mmap_sem);
• vma = find_vma(current->mm, start);
• if (!vma) {

• printk(KERN_ERR "no vma for address %lu\n", start);
  

• goto cleanup;
  

• }
• if (vma_is_io(vma)) {

• unsigned long pfn;
  

• if (vma->vm_end - start < n_pages * PAGE_SIZE) {
  

• 	printk(KERN_ERR "vma is too small\n");
  

• 	goto cleanup;
  

• }
  

• for (n = 0; n < n_pages; ++n, start += PAGE_SIZE) {
  

• 	ret = follow_pfn(vma, start, &pfn);
  

• 	if (ret) {
  

• 		printk(KERN_ERR "no page for address %lu\n",
  

• 			start);
  

• 		goto cleanup;
  

• 	}
  

• 	pages[n] = pfn_to_page(pfn);
  

• 	get_page(pages[n]);
  

• }
  

• } else {

• n = get_user_pages(current, current->mm, start & PAGE_MASK,
  

• 	n_pages, write, 1, pages, NULL);
  

• if (n != n_pages) {
  

• 	printk(KERN_ERR "got only %d of %d user pages\n",
  

• 		n, n_pages);
  

• 	goto cleanup;
  

• }
  

• }
• *copy_vma = vb2_get_vma(vma);
• if (!*copy_vma) {

• printk(KERN_ERR "failed to copy vma\n");
  

• ret = -ENOMEM;
  

• goto cleanup;
  

• }
• /* leaving critical section for mm access */
• up_read(&current->mm->mmap_sem);
• return 0;

+cleanup:

• up_read(&current->mm->mmap_sem);
• /* putting user pages if used, can be done wothout the lock */
• while (n)

• put_page(pages[--n]);
  

• return ret;

+}

+static void vb2_dc_put_userptr(void *buf_priv) +{

• struct vb2_dc_buf *buf = buf_priv;
• struct sg_table *sgt = buf->dma_sgt;
• dma_unmap_sg(buf->dev, sgt->sgl, sgt->orig_nents, buf->dma_dir);
• vb2_dc_put_sgtable(sgt, !vma_is_io(buf->vma));
• vb2_put_vma(buf->vma);
• kfree(buf);

+}

+static void *vb2_dc_get_userptr(void *alloc_ctx, unsigned long vaddr,

• unsigned long size, int write)

+{

• struct vb2_dc_buf *buf;
• unsigned long start, end, offset, offset2;
• struct page **pages;
• int n_pages;
• int ret = 0;
• struct sg_table *sgt;
• unsigned long contig_size;
• buf = kzalloc(sizeof *buf, GFP_KERNEL);
• if (!buf)

• return ERR_PTR(-ENOMEM);
  

• buf->dev = alloc_ctx;
• buf->dma_dir = write ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
• start = (unsigned long)vaddr & PAGE_MASK;
• offset = (unsigned long)vaddr & ~PAGE_MASK;
• end = PAGE_ALIGN((unsigned long)vaddr + size);
• offset2 = end - (unsigned long)vaddr - size;
• n_pages = (end - start) >> PAGE_SHIFT;
• pages = kmalloc(n_pages * sizeof pages[0], GFP_KERNEL);
• if (!pages) {

• ret = -ENOMEM;
  

• printk(KERN_ERR "failed to allocate pages table\n");
  

• goto fail_buf;
  

• }
• /* extract page list from userspace mapping */
• ret = vb2_dc_get_pages(start, pages, n_pages, &buf->vma, write);
• if (ret) {

• printk(KERN_ERR "failed to get user pages\n");
  

• goto fail_pages;
  

• }
• sgt = vb2_dc_pages_to_sgt(pages, n_pages, offset, offset2);
• if (!sgt) {

• printk(KERN_ERR "failed to create scatterlist table\n");
  

• ret = -ENOMEM;
  

• goto fail_get_pages;
  

• }
• /* pages are no longer needed */
• kfree(pages);
• pages = NULL;
• sgt->nents = dma_map_sg(buf->dev, sgt->sgl, sgt->orig_nents,

• buf->dma_dir);
  

• if (sgt->nents <= 0) {

• printk(KERN_ERR "failed to map scatterlist\n");
  

• ret = -EIO;
  

• goto fail_sgt;
  

• }
• contig_size = vb2_dc_get_contiguous_size(sgt);
• if (contig_size < size) {

• printk(KERN_ERR "contiguous mapping is too small %lu/%lu\n",
  

• 	contig_size, size);
  

• ret = -EFAULT;
  

• goto fail_map_sg;
  

• }
• buf->dma_addr = sg_dma_address(sgt->sgl);
• buf->size = size;
• buf->dma_sgt = sgt;
• atomic_inc(&buf->refcount);
• return buf;

+fail_map_sg:

• dma_unmap_sg(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir);

+fail_sgt:

• vb2_dc_put_sgtable(sgt, 0);

+fail_get_pages:

• while (pages && n_pages)

• put_page(pages[--n_pages]);
  

• vb2_put_vma(buf->vma);

+fail_pages:

• kfree(pages); /* kfree is NULL-proof */

+fail_buf:

• kfree(buf);
• return ERR_PTR(ret);

+}

+/*********************************************/ +/* callbacks for DMABUF buffers */ +/*********************************************/

+static int vb2_dc_map_dmabuf(void *mem_priv) +{

• struct vb2_dc_buf *buf = mem_priv;
• struct sg_table *sgt;
• unsigned long contig_size;
• int ret = 0;
• if (WARN_ON(!buf->db_attach)) {

• printk(KERN_ERR "trying to pin a non attached buffer\n");
  

• return -EINVAL;
  

• }
• if (WARN_ON(buf->dma_sgt)) {

• printk(KERN_ERR "dmabuf buffer is already pinned\n");
  

• return 0;
  

• }
• /* get the associated scatterlist for this buffer */
• sgt = dma_buf_map_attachment(buf->db_attach, buf->dma_dir);
• if (IS_ERR_OR_NULL(sgt)) {

• printk(KERN_ERR "Error getting dmabuf scatterlist\n");
  

• return -EINVAL;
  

• }
• /* checking if dmabuf is big enough to store contiguous chunk */
• contig_size = vb2_dc_get_contiguous_size(sgt);
• if (contig_size < buf->size) {

• printk(KERN_ERR "contiguous chunk of dmabuf is too small\n");
  

• ret = -EFAULT;
  

• goto fail_map;
  

• }
• buf->dma_addr = sg_dma_address(sgt->sgl);
• buf->dma_sgt = sgt;
• return 0;

+fail_map:

• dma_buf_unmap_attachment(buf->db_attach, sgt);
• return ret;

+}

+static void vb2_dc_unmap_dmabuf(void *mem_priv) +{

• struct vb2_dc_buf *buf = mem_priv;
• struct sg_table *sgt = buf->dma_sgt;
• if (WARN_ON(!buf->db_attach)) {

• printk(KERN_ERR "trying to unpin a not attached buffer\n");
  

• return;
  

• }
• if (WARN_ON(!sgt)) {

• printk(KERN_ERR "dmabuf buffer is already unpinned\n");
  

• return;
  

• }
• dma_buf_unmap_attachment(buf->db_attach, sgt);
• buf->dma_addr = 0;
• buf->dma_sgt = NULL;

+}

+static void vb2_dc_detach_dmabuf(void *mem_priv) +{

• struct vb2_dc_buf *buf = mem_priv;
• if (buf->dma_addr)

• vb2_dc_unmap_dmabuf(buf);
  

• /* detach this attachment */
• dma_buf_detach(buf->db_attach->dmabuf, buf->db_attach);
• kfree(buf);

+}

+static void *vb2_dc_attach_dmabuf(void *alloc_ctx, struct dma_buf *dbuf,

• unsigned long size, int write)

+{

• struct vb2_dc_buf *buf;
• struct dma_buf_attachment *dba;
• if (dbuf->size < size)

• return ERR_PTR(-EFAULT);
  

• buf = kzalloc(sizeof *buf, GFP_KERNEL);
• if (!buf)

• return ERR_PTR(-ENOMEM);
  

• buf->dev = alloc_ctx;
• /* create attachment for the dmabuf with the user device */
• dba = dma_buf_attach(dbuf, buf->dev);
• if (IS_ERR(dba)) {

• printk(KERN_ERR "failed to attach dmabuf\n");
  

• kfree(buf);
  

• return dba;
  

• }
• buf->dma_dir = write ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
• buf->size = size;
• buf->db_attach = dba;
• return buf;

+}

+/*********************************************/ +/* DMA CONTIG exported functions */ +/*********************************************/

+const struct vb2_mem_ops vb2_dma_contig_memops = {

• .alloc = vb2_dc_alloc,
• .put = vb2_dc_put,
• .get_dmabuf = vb2_dc_get_dmabuf,
• .cookie = vb2_dc_cookie,
• .vaddr = vb2_dc_vaddr,
• .mmap = vb2_dc_mmap,
• .get_userptr = vb2_dc_get_userptr,
• .put_userptr = vb2_dc_put_userptr,
• .prepare = vb2_dc_prepare,
• .finish = vb2_dc_finish,
• .map_dmabuf = vb2_dc_map_dmabuf,
• .unmap_dmabuf = vb2_dc_unmap_dmabuf,
• .attach_dmabuf = vb2_dc_attach_dmabuf,
• .detach_dmabuf = vb2_dc_detach_dmabuf,
• .num_users = vb2_dc_num_users,

+}; +EXPORT_SYMBOL_GPL(vb2_dma_contig_memops);

+void *vb2_dma_contig_init_ctx(struct device *dev) +{

• return dev;

+} +EXPORT_SYMBOL_GPL(vb2_dma_contig_init_ctx);

+void vb2_dma_contig_cleanup_ctx(void *alloc_ctx) +{ +} +EXPORT_SYMBOL_GPL(vb2_dma_contig_cleanup_ctx);

+MODULE_DESCRIPTION("DMA-contig memory handling routines for videobuf2"); +MODULE_AUTHOR("Pawel Osciak pawel@osciak.com"); +MODULE_LICENSE("GPL");

Hi Laurent,

Thank you for finding a bug in vb2-core.

Regards, Tomasz Stanislawski

On 01/23/2012 03:35 PM, Laurent Pinchart wrote:

The vb2_get_vma() function is called by videobuf2-dma-contig. Export it.

Signed-off-by: Laurent Pinchartlaurent.pinchart@ideasonboard.com

drivers/media/video/videobuf2-memops.c | 1 + 1 files changed, 1 insertions(+), 0 deletions(-)

Hi Thomas,

The following patch is needed to compile videobuf2-dma-contig as a module.

diff --git a/drivers/media/video/videobuf2-memops.c b/drivers/media/video/videobuf2-memops.c index 71a7a78..718f70e 100644 --- a/drivers/media/video/videobuf2-memops.c +++ b/drivers/media/video/videobuf2-memops.c @@ -55,6 +55,7 @@ struct vm_area_struct *vb2_get_vma(struct vm_area_struct *vma)

return vma_copy; } +EXPORT_SYMBOL_GPL(vb2_get_vma);

/**

• vb2_put_userptr() - release a userspace virtual memory area