2 * Coda multi-standard codec IP
4 * Copyright (C) 2012 Vista Silicon S.L.
5 * Javier Martin, <javier.martin@vista-silicon.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 #include <linux/clk.h>
15 #include <linux/debugfs.h>
16 #include <linux/delay.h>
17 #include <linux/firmware.h>
18 #include <linux/gcd.h>
19 #include <linux/genalloc.h>
20 #include <linux/interrupt.h>
22 #include <linux/irq.h>
23 #include <linux/kfifo.h>
24 #include <linux/module.h>
25 #include <linux/of_device.h>
26 #include <linux/platform_device.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/slab.h>
29 #include <linux/videodev2.h>
31 #include <linux/platform_data/media/coda.h>
32 #include <linux/reset.h>
34 #include <media/v4l2-ctrls.h>
35 #include <media/v4l2-device.h>
36 #include <media/v4l2-event.h>
37 #include <media/v4l2-ioctl.h>
38 #include <media/v4l2-mem2mem.h>
39 #include <media/videobuf2-v4l2.h>
40 #include <media/videobuf2-dma-contig.h>
41 #include <media/videobuf2-vmalloc.h>
45 #define CODA_NAME "coda"
47 #define CODADX6_MAX_INSTANCES 4
48 #define CODA_MAX_FORMATS 4
50 #define CODA_ISRAM_SIZE (2048 * 2)
55 #define S_ALIGN 1 /* multiple of 2 */
56 #define W_ALIGN 1 /* multiple of 2 */
57 #define H_ALIGN 1 /* multiple of 2 */
59 #define fh_to_ctx(__fh) container_of(__fh, struct coda_ctx, fh)
62 module_param(coda_debug
, int, 0644);
63 MODULE_PARM_DESC(coda_debug
, "Debug level (0-2)");
65 static int disable_tiling
;
66 module_param(disable_tiling
, int, 0644);
67 MODULE_PARM_DESC(disable_tiling
, "Disable tiled frame buffers");
69 void coda_write(struct coda_dev
*dev
, u32 data
, u32 reg
)
71 v4l2_dbg(2, coda_debug
, &dev
->v4l2_dev
,
72 "%s: data=0x%x, reg=0x%x\n", __func__
, data
, reg
);
73 writel(data
, dev
->regs_base
+ reg
);
76 unsigned int coda_read(struct coda_dev
*dev
, u32 reg
)
80 data
= readl(dev
->regs_base
+ reg
);
81 v4l2_dbg(2, coda_debug
, &dev
->v4l2_dev
,
82 "%s: data=0x%x, reg=0x%x\n", __func__
, data
, reg
);
86 void coda_write_base(struct coda_ctx
*ctx
, struct coda_q_data
*q_data
,
87 struct vb2_v4l2_buffer
*buf
, unsigned int reg_y
)
89 u32 base_y
= vb2_dma_contig_plane_dma_addr(&buf
->vb2_buf
, 0);
92 switch (q_data
->fourcc
) {
93 case V4L2_PIX_FMT_NV12
:
94 case V4L2_PIX_FMT_YUV420
:
96 base_cb
= base_y
+ q_data
->bytesperline
* q_data
->height
;
97 base_cr
= base_cb
+ q_data
->bytesperline
* q_data
->height
/ 4;
99 case V4L2_PIX_FMT_YVU420
:
100 /* Switch Cb and Cr for YVU420 format */
101 base_cr
= base_y
+ q_data
->bytesperline
* q_data
->height
;
102 base_cb
= base_cr
+ q_data
->bytesperline
* q_data
->height
/ 4;
104 case V4L2_PIX_FMT_YUV422P
:
105 base_cb
= base_y
+ q_data
->bytesperline
* q_data
->height
;
106 base_cr
= base_cb
+ q_data
->bytesperline
* q_data
->height
/ 2;
109 coda_write(ctx
->dev
, base_y
, reg_y
);
110 coda_write(ctx
->dev
, base_cb
, reg_y
+ 4);
111 coda_write(ctx
->dev
, base_cr
, reg_y
+ 8);
114 #define CODA_CODEC(mode, src_fourcc, dst_fourcc, max_w, max_h) \
115 { mode, src_fourcc, dst_fourcc, max_w, max_h }
118 * Arrays of codecs supported by each given version of Coda:
122 * Use V4L2_PIX_FMT_YUV420 as placeholder for all supported YUV 4:2:0 variants
124 static const struct coda_codec codadx6_codecs
[] = {
125 CODA_CODEC(CODADX6_MODE_ENCODE_H264
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_H264
, 720, 576),
126 CODA_CODEC(CODADX6_MODE_ENCODE_MP4
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_MPEG4
, 720, 576),
129 static const struct coda_codec coda7_codecs
[] = {
130 CODA_CODEC(CODA7_MODE_ENCODE_H264
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_H264
, 1280, 720),
131 CODA_CODEC(CODA7_MODE_ENCODE_MP4
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_MPEG4
, 1280, 720),
132 CODA_CODEC(CODA7_MODE_ENCODE_MJPG
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_JPEG
, 8192, 8192),
133 CODA_CODEC(CODA7_MODE_DECODE_H264
, V4L2_PIX_FMT_H264
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
134 CODA_CODEC(CODA7_MODE_DECODE_MP4
, V4L2_PIX_FMT_MPEG4
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
135 CODA_CODEC(CODA7_MODE_DECODE_MJPG
, V4L2_PIX_FMT_JPEG
, V4L2_PIX_FMT_YUV420
, 8192, 8192),
138 static const struct coda_codec coda9_codecs
[] = {
139 CODA_CODEC(CODA9_MODE_ENCODE_H264
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_H264
, 1920, 1088),
140 CODA_CODEC(CODA9_MODE_ENCODE_MP4
, V4L2_PIX_FMT_YUV420
, V4L2_PIX_FMT_MPEG4
, 1920, 1088),
141 CODA_CODEC(CODA9_MODE_DECODE_H264
, V4L2_PIX_FMT_H264
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
142 CODA_CODEC(CODA9_MODE_DECODE_MP4
, V4L2_PIX_FMT_MPEG4
, V4L2_PIX_FMT_YUV420
, 1920, 1088),
145 struct coda_video_device
{
147 enum coda_inst_type type
;
148 const struct coda_context_ops
*ops
;
150 u32 src_formats
[CODA_MAX_FORMATS
];
151 u32 dst_formats
[CODA_MAX_FORMATS
];
154 static const struct coda_video_device coda_bit_encoder
= {
155 .name
= "coda-encoder",
156 .type
= CODA_INST_ENCODER
,
157 .ops
= &coda_bit_encode_ops
,
169 static const struct coda_video_device coda_bit_jpeg_encoder
= {
170 .name
= "coda-jpeg-encoder",
171 .type
= CODA_INST_ENCODER
,
172 .ops
= &coda_bit_encode_ops
,
177 V4L2_PIX_FMT_YUV422P
,
184 static const struct coda_video_device coda_bit_decoder
= {
185 .name
= "coda-decoder",
186 .type
= CODA_INST_DECODER
,
187 .ops
= &coda_bit_decode_ops
,
199 static const struct coda_video_device coda_bit_jpeg_decoder
= {
200 .name
= "coda-jpeg-decoder",
201 .type
= CODA_INST_DECODER
,
202 .ops
= &coda_bit_decode_ops
,
210 V4L2_PIX_FMT_YUV422P
,
214 static const struct coda_video_device
*codadx6_video_devices
[] = {
218 static const struct coda_video_device
*coda7_video_devices
[] = {
219 &coda_bit_jpeg_encoder
,
220 &coda_bit_jpeg_decoder
,
225 static const struct coda_video_device
*coda9_video_devices
[] = {
231 * Normalize all supported YUV 4:2:0 formats to the value used in the codec
234 static u32
coda_format_normalize_yuv(u32 fourcc
)
237 case V4L2_PIX_FMT_NV12
:
238 case V4L2_PIX_FMT_YUV420
:
239 case V4L2_PIX_FMT_YVU420
:
240 case V4L2_PIX_FMT_YUV422P
:
241 return V4L2_PIX_FMT_YUV420
;
247 static const struct coda_codec
*coda_find_codec(struct coda_dev
*dev
,
248 int src_fourcc
, int dst_fourcc
)
250 const struct coda_codec
*codecs
= dev
->devtype
->codecs
;
251 int num_codecs
= dev
->devtype
->num_codecs
;
254 src_fourcc
= coda_format_normalize_yuv(src_fourcc
);
255 dst_fourcc
= coda_format_normalize_yuv(dst_fourcc
);
256 if (src_fourcc
== dst_fourcc
)
259 for (k
= 0; k
< num_codecs
; k
++) {
260 if (codecs
[k
].src_fourcc
== src_fourcc
&&
261 codecs
[k
].dst_fourcc
== dst_fourcc
)
271 static void coda_get_max_dimensions(struct coda_dev
*dev
,
272 const struct coda_codec
*codec
,
273 int *max_w
, int *max_h
)
275 const struct coda_codec
*codecs
= dev
->devtype
->codecs
;
276 int num_codecs
= dev
->devtype
->num_codecs
;
284 for (k
= 0, w
= 0, h
= 0; k
< num_codecs
; k
++) {
285 w
= max(w
, codecs
[k
].max_w
);
286 h
= max(h
, codecs
[k
].max_h
);
296 const struct coda_video_device
*to_coda_video_device(struct video_device
*vdev
)
298 struct coda_dev
*dev
= video_get_drvdata(vdev
);
299 unsigned int i
= vdev
- dev
->vfd
;
301 if (i
>= dev
->devtype
->num_vdevs
)
304 return dev
->devtype
->vdevs
[i
];
307 const char *coda_product_name(int product
)
319 snprintf(buf
, sizeof(buf
), "(0x%04x)", product
);
325 * V4L2 ioctl() operations.
327 static int coda_querycap(struct file
*file
, void *priv
,
328 struct v4l2_capability
*cap
)
330 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
332 strlcpy(cap
->driver
, CODA_NAME
, sizeof(cap
->driver
));
333 strlcpy(cap
->card
, coda_product_name(ctx
->dev
->devtype
->product
),
335 strlcpy(cap
->bus_info
, "platform:" CODA_NAME
, sizeof(cap
->bus_info
));
336 cap
->device_caps
= V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
337 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
342 static int coda_enum_fmt(struct file
*file
, void *priv
,
343 struct v4l2_fmtdesc
*f
)
345 struct video_device
*vdev
= video_devdata(file
);
346 const struct coda_video_device
*cvd
= to_coda_video_device(vdev
);
349 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
350 formats
= cvd
->src_formats
;
351 else if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
352 formats
= cvd
->dst_formats
;
356 if (f
->index
>= CODA_MAX_FORMATS
|| formats
[f
->index
] == 0)
359 f
->pixelformat
= formats
[f
->index
];
364 static int coda_g_fmt(struct file
*file
, void *priv
,
365 struct v4l2_format
*f
)
367 struct coda_q_data
*q_data
;
368 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
370 q_data
= get_q_data(ctx
, f
->type
);
374 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
375 f
->fmt
.pix
.pixelformat
= q_data
->fourcc
;
376 f
->fmt
.pix
.width
= q_data
->width
;
377 f
->fmt
.pix
.height
= q_data
->height
;
378 f
->fmt
.pix
.bytesperline
= q_data
->bytesperline
;
380 f
->fmt
.pix
.sizeimage
= q_data
->sizeimage
;
381 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_JPEG
)
382 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
384 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
389 static int coda_try_pixelformat(struct coda_ctx
*ctx
, struct v4l2_format
*f
)
391 struct coda_q_data
*q_data
;
395 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
396 formats
= ctx
->cvd
->src_formats
;
397 else if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
398 formats
= ctx
->cvd
->dst_formats
;
402 for (i
= 0; i
< CODA_MAX_FORMATS
; i
++) {
403 if (formats
[i
] == f
->fmt
.pix
.pixelformat
) {
404 f
->fmt
.pix
.pixelformat
= formats
[i
];
409 /* Fall back to currently set pixelformat */
410 q_data
= get_q_data(ctx
, f
->type
);
411 f
->fmt
.pix
.pixelformat
= q_data
->fourcc
;
416 static unsigned int coda_estimate_sizeimage(struct coda_ctx
*ctx
, u32 sizeimage
,
417 u32 width
, u32 height
)
420 * This is a rough estimate for sensible compressed buffer
421 * sizes (between 1 and 16 bits per pixel). This could be
422 * improved by better format specific worst case estimates.
424 return round_up(clamp(sizeimage
, width
* height
/ 8,
425 width
* height
* 2), PAGE_SIZE
);
428 static int coda_try_fmt(struct coda_ctx
*ctx
, const struct coda_codec
*codec
,
429 struct v4l2_format
*f
)
431 struct coda_dev
*dev
= ctx
->dev
;
432 unsigned int max_w
, max_h
;
433 enum v4l2_field field
;
435 field
= f
->fmt
.pix
.field
;
436 if (field
== V4L2_FIELD_ANY
)
437 field
= V4L2_FIELD_NONE
;
438 else if (V4L2_FIELD_NONE
!= field
)
441 /* V4L2 specification suggests the driver corrects the format struct
442 * if any of the dimensions is unsupported */
443 f
->fmt
.pix
.field
= field
;
445 coda_get_max_dimensions(dev
, codec
, &max_w
, &max_h
);
446 v4l_bound_align_image(&f
->fmt
.pix
.width
, MIN_W
, max_w
, W_ALIGN
,
447 &f
->fmt
.pix
.height
, MIN_H
, max_h
, H_ALIGN
,
450 switch (f
->fmt
.pix
.pixelformat
) {
451 case V4L2_PIX_FMT_NV12
:
452 case V4L2_PIX_FMT_YUV420
:
453 case V4L2_PIX_FMT_YVU420
:
455 * Frame stride must be at least multiple of 8,
456 * but multiple of 16 for h.264 or JPEG 4:2:x
458 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
459 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
460 f
->fmt
.pix
.height
* 3 / 2;
462 case V4L2_PIX_FMT_YUV422P
:
463 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
464 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
465 f
->fmt
.pix
.height
* 2;
467 case V4L2_PIX_FMT_JPEG
:
468 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
470 case V4L2_PIX_FMT_H264
:
471 case V4L2_PIX_FMT_MPEG4
:
472 f
->fmt
.pix
.bytesperline
= 0;
473 f
->fmt
.pix
.sizeimage
= coda_estimate_sizeimage(ctx
,
474 f
->fmt
.pix
.sizeimage
,
485 static int coda_try_fmt_vid_cap(struct file
*file
, void *priv
,
486 struct v4l2_format
*f
)
488 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
489 const struct coda_q_data
*q_data_src
;
490 const struct coda_codec
*codec
;
491 struct vb2_queue
*src_vq
;
494 ret
= coda_try_pixelformat(ctx
, f
);
498 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
501 * If the source format is already fixed, only allow the same output
504 src_vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
505 if (vb2_is_streaming(src_vq
)) {
506 f
->fmt
.pix
.width
= q_data_src
->width
;
507 f
->fmt
.pix
.height
= q_data_src
->height
;
510 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
512 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
513 codec
= coda_find_codec(ctx
->dev
, q_data_src
->fourcc
,
514 f
->fmt
.pix
.pixelformat
);
518 ret
= coda_try_fmt(ctx
, codec
, f
);
522 /* The h.264 decoder only returns complete 16x16 macroblocks */
523 if (codec
&& codec
->src_fourcc
== V4L2_PIX_FMT_H264
) {
524 f
->fmt
.pix
.width
= f
->fmt
.pix
.width
;
525 f
->fmt
.pix
.height
= round_up(f
->fmt
.pix
.height
, 16);
526 f
->fmt
.pix
.bytesperline
= round_up(f
->fmt
.pix
.width
, 16);
527 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
*
528 f
->fmt
.pix
.height
* 3 / 2;
534 static int coda_try_fmt_vid_out(struct file
*file
, void *priv
,
535 struct v4l2_format
*f
)
537 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
538 struct coda_dev
*dev
= ctx
->dev
;
539 const struct coda_q_data
*q_data_dst
;
540 const struct coda_codec
*codec
;
543 ret
= coda_try_pixelformat(ctx
, f
);
547 switch (f
->fmt
.pix
.colorspace
) {
548 case V4L2_COLORSPACE_REC709
:
549 case V4L2_COLORSPACE_JPEG
:
552 if (f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_JPEG
)
553 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_JPEG
;
555 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_REC709
;
558 q_data_dst
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
559 codec
= coda_find_codec(dev
, f
->fmt
.pix
.pixelformat
, q_data_dst
->fourcc
);
561 return coda_try_fmt(ctx
, codec
, f
);
564 static int coda_s_fmt(struct coda_ctx
*ctx
, struct v4l2_format
*f
)
566 struct coda_q_data
*q_data
;
567 struct vb2_queue
*vq
;
569 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
573 q_data
= get_q_data(ctx
, f
->type
);
577 if (vb2_is_busy(vq
)) {
578 v4l2_err(&ctx
->dev
->v4l2_dev
, "%s queue busy\n", __func__
);
582 q_data
->fourcc
= f
->fmt
.pix
.pixelformat
;
583 q_data
->width
= f
->fmt
.pix
.width
;
584 q_data
->height
= f
->fmt
.pix
.height
;
585 q_data
->bytesperline
= f
->fmt
.pix
.bytesperline
;
586 q_data
->sizeimage
= f
->fmt
.pix
.sizeimage
;
587 q_data
->rect
.left
= 0;
588 q_data
->rect
.top
= 0;
589 q_data
->rect
.width
= f
->fmt
.pix
.width
;
590 q_data
->rect
.height
= f
->fmt
.pix
.height
;
592 switch (f
->fmt
.pix
.pixelformat
) {
593 case V4L2_PIX_FMT_NV12
:
594 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
595 ctx
->tiled_map_type
= GDI_TILED_FRAME_MB_RASTER_MAP
;
599 /* else fall through */
600 case V4L2_PIX_FMT_YUV420
:
601 case V4L2_PIX_FMT_YVU420
:
602 ctx
->tiled_map_type
= GDI_LINEAR_FRAME_MAP
;
608 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
609 "Setting format for type %d, wxh: %dx%d, fmt: %d\n",
610 f
->type
, q_data
->width
, q_data
->height
, q_data
->fourcc
);
615 static int coda_s_fmt_vid_cap(struct file
*file
, void *priv
,
616 struct v4l2_format
*f
)
618 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
621 ret
= coda_try_fmt_vid_cap(file
, priv
, f
);
625 return coda_s_fmt(ctx
, f
);
628 static int coda_s_fmt_vid_out(struct file
*file
, void *priv
,
629 struct v4l2_format
*f
)
631 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
632 struct v4l2_format f_cap
;
635 ret
= coda_try_fmt_vid_out(file
, priv
, f
);
639 ret
= coda_s_fmt(ctx
, f
);
643 ctx
->colorspace
= f
->fmt
.pix
.colorspace
;
645 memset(&f_cap
, 0, sizeof(f_cap
));
646 f_cap
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
647 coda_g_fmt(file
, priv
, &f_cap
);
648 f_cap
.fmt
.pix
.width
= f
->fmt
.pix
.width
;
649 f_cap
.fmt
.pix
.height
= f
->fmt
.pix
.height
;
651 ret
= coda_try_fmt_vid_cap(file
, priv
, &f_cap
);
655 return coda_s_fmt(ctx
, &f_cap
);
658 static int coda_reqbufs(struct file
*file
, void *priv
,
659 struct v4l2_requestbuffers
*rb
)
661 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
664 ret
= v4l2_m2m_reqbufs(file
, ctx
->fh
.m2m_ctx
, rb
);
669 * Allow to allocate instance specific per-context buffers, such as
670 * bitstream ringbuffer, slice buffer, work buffer, etc. if needed.
672 if (rb
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
&& ctx
->ops
->reqbufs
)
673 return ctx
->ops
->reqbufs(ctx
, rb
);
678 static int coda_qbuf(struct file
*file
, void *priv
,
679 struct v4l2_buffer
*buf
)
681 struct coda_ctx
*ctx
= fh_to_ctx(priv
);
683 return v4l2_m2m_qbuf(file
, ctx
->fh
.m2m_ctx
, buf
);
686 static bool coda_buf_is_end_of_stream(struct coda_ctx
*ctx
,
687 struct vb2_v4l2_buffer
*buf
)
689 struct vb2_queue
*src_vq
;
691 src_vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
693 return ((ctx
->bit_stream_param
& CODA_BIT_STREAM_END_FLAG
) &&
694 (buf
->sequence
== (ctx
->qsequence
- 1)));
697 void coda_m2m_buf_done(struct coda_ctx
*ctx
, struct vb2_v4l2_buffer
*buf
,
698 enum vb2_buffer_state state
)
700 const struct v4l2_event eos_event
= {
701 .type
= V4L2_EVENT_EOS
704 if (coda_buf_is_end_of_stream(ctx
, buf
)) {
705 buf
->flags
|= V4L2_BUF_FLAG_LAST
;
707 v4l2_event_queue_fh(&ctx
->fh
, &eos_event
);
710 v4l2_m2m_buf_done(buf
, state
);
713 static int coda_g_selection(struct file
*file
, void *fh
,
714 struct v4l2_selection
*s
)
716 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
717 struct coda_q_data
*q_data
;
718 struct v4l2_rect r
, *rsel
;
720 q_data
= get_q_data(ctx
, s
->type
);
726 r
.width
= q_data
->width
;
727 r
.height
= q_data
->height
;
728 rsel
= &q_data
->rect
;
731 case V4L2_SEL_TGT_CROP_DEFAULT
:
732 case V4L2_SEL_TGT_CROP_BOUNDS
:
735 case V4L2_SEL_TGT_CROP
:
736 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
739 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
740 case V4L2_SEL_TGT_COMPOSE_PADDED
:
743 case V4L2_SEL_TGT_COMPOSE
:
744 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
745 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
757 static int coda_try_decoder_cmd(struct file
*file
, void *fh
,
758 struct v4l2_decoder_cmd
*dc
)
760 if (dc
->cmd
!= V4L2_DEC_CMD_STOP
)
763 if (dc
->flags
& V4L2_DEC_CMD_STOP_TO_BLACK
)
766 if (!(dc
->flags
& V4L2_DEC_CMD_STOP_IMMEDIATELY
) && (dc
->stop
.pts
!= 0))
772 static int coda_decoder_cmd(struct file
*file
, void *fh
,
773 struct v4l2_decoder_cmd
*dc
)
775 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
778 ret
= coda_try_decoder_cmd(file
, fh
, dc
);
782 /* Ignore decoder stop command silently in encoder context */
783 if (ctx
->inst_type
!= CODA_INST_DECODER
)
786 /* Set the stream-end flag on this context */
787 coda_bit_stream_end_flag(ctx
);
789 v4l2_m2m_try_schedule(ctx
->fh
.m2m_ctx
);
794 static int coda_g_parm(struct file
*file
, void *fh
, struct v4l2_streamparm
*a
)
796 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
797 struct v4l2_fract
*tpf
;
799 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
802 a
->parm
.output
.capability
= V4L2_CAP_TIMEPERFRAME
;
803 tpf
= &a
->parm
.output
.timeperframe
;
804 tpf
->denominator
= ctx
->params
.framerate
& CODA_FRATE_RES_MASK
;
805 tpf
->numerator
= 1 + (ctx
->params
.framerate
>>
806 CODA_FRATE_DIV_OFFSET
);
812 * Approximate timeperframe v4l2_fract with values that can be written
813 * into the 16-bit CODA_FRATE_DIV and CODA_FRATE_RES fields.
815 static void coda_approximate_timeperframe(struct v4l2_fract
*timeperframe
)
817 struct v4l2_fract s
= *timeperframe
;
818 struct v4l2_fract f0
;
819 struct v4l2_fract f1
= { 1, 0 };
820 struct v4l2_fract f2
= { 0, 1 };
821 unsigned int i
, div
, s_denominator
;
823 /* Lower bound is 1/65535 */
824 if (s
.numerator
== 0 || s
.denominator
/ s
.numerator
> 65535) {
825 timeperframe
->numerator
= 1;
826 timeperframe
->denominator
= 65535;
830 /* Upper bound is 65536/1, map everything above to infinity */
831 if (s
.denominator
== 0 || s
.numerator
/ s
.denominator
> 65536) {
832 timeperframe
->numerator
= 1;
833 timeperframe
->denominator
= 0;
837 /* Reduce fraction to lowest terms */
838 div
= gcd(s
.numerator
, s
.denominator
);
841 s
.denominator
/= div
;
844 if (s
.numerator
<= 65536 && s
.denominator
< 65536) {
849 /* Find successive convergents from continued fraction expansion */
850 while (f2
.numerator
<= 65536 && f2
.denominator
< 65536) {
854 /* Stop when f2 exactly equals timeperframe */
855 if (s
.numerator
== 0)
858 i
= s
.denominator
/ s
.numerator
;
860 f2
.numerator
= f0
.numerator
+ i
* f1
.numerator
;
861 f2
.denominator
= f0
.denominator
+ i
* f2
.denominator
;
863 s_denominator
= s
.numerator
;
864 s
.numerator
= s
.denominator
% s
.numerator
;
865 s
.denominator
= s_denominator
;
871 static uint32_t coda_timeperframe_to_frate(struct v4l2_fract
*timeperframe
)
873 return ((timeperframe
->numerator
- 1) << CODA_FRATE_DIV_OFFSET
) |
874 timeperframe
->denominator
;
877 static int coda_s_parm(struct file
*file
, void *fh
, struct v4l2_streamparm
*a
)
879 struct coda_ctx
*ctx
= fh_to_ctx(fh
);
880 struct v4l2_fract
*tpf
;
882 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
885 tpf
= &a
->parm
.output
.timeperframe
;
886 coda_approximate_timeperframe(tpf
);
887 ctx
->params
.framerate
= coda_timeperframe_to_frate(tpf
);
892 static int coda_subscribe_event(struct v4l2_fh
*fh
,
893 const struct v4l2_event_subscription
*sub
)
897 return v4l2_event_subscribe(fh
, sub
, 0, NULL
);
899 return v4l2_ctrl_subscribe_event(fh
, sub
);
903 static const struct v4l2_ioctl_ops coda_ioctl_ops
= {
904 .vidioc_querycap
= coda_querycap
,
906 .vidioc_enum_fmt_vid_cap
= coda_enum_fmt
,
907 .vidioc_g_fmt_vid_cap
= coda_g_fmt
,
908 .vidioc_try_fmt_vid_cap
= coda_try_fmt_vid_cap
,
909 .vidioc_s_fmt_vid_cap
= coda_s_fmt_vid_cap
,
911 .vidioc_enum_fmt_vid_out
= coda_enum_fmt
,
912 .vidioc_g_fmt_vid_out
= coda_g_fmt
,
913 .vidioc_try_fmt_vid_out
= coda_try_fmt_vid_out
,
914 .vidioc_s_fmt_vid_out
= coda_s_fmt_vid_out
,
916 .vidioc_reqbufs
= coda_reqbufs
,
917 .vidioc_querybuf
= v4l2_m2m_ioctl_querybuf
,
919 .vidioc_qbuf
= coda_qbuf
,
920 .vidioc_expbuf
= v4l2_m2m_ioctl_expbuf
,
921 .vidioc_dqbuf
= v4l2_m2m_ioctl_dqbuf
,
922 .vidioc_create_bufs
= v4l2_m2m_ioctl_create_bufs
,
924 .vidioc_streamon
= v4l2_m2m_ioctl_streamon
,
925 .vidioc_streamoff
= v4l2_m2m_ioctl_streamoff
,
927 .vidioc_g_selection
= coda_g_selection
,
929 .vidioc_try_decoder_cmd
= coda_try_decoder_cmd
,
930 .vidioc_decoder_cmd
= coda_decoder_cmd
,
932 .vidioc_g_parm
= coda_g_parm
,
933 .vidioc_s_parm
= coda_s_parm
,
935 .vidioc_subscribe_event
= coda_subscribe_event
,
936 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
940 * Mem-to-mem operations.
943 static void coda_device_run(void *m2m_priv
)
945 struct coda_ctx
*ctx
= m2m_priv
;
946 struct coda_dev
*dev
= ctx
->dev
;
948 queue_work(dev
->workqueue
, &ctx
->pic_run_work
);
951 static void coda_pic_run_work(struct work_struct
*work
)
953 struct coda_ctx
*ctx
= container_of(work
, struct coda_ctx
, pic_run_work
);
954 struct coda_dev
*dev
= ctx
->dev
;
957 mutex_lock(&ctx
->buffer_mutex
);
958 mutex_lock(&dev
->coda_mutex
);
960 ret
= ctx
->ops
->prepare_run(ctx
);
961 if (ret
< 0 && ctx
->inst_type
== CODA_INST_DECODER
) {
962 mutex_unlock(&dev
->coda_mutex
);
963 mutex_unlock(&ctx
->buffer_mutex
);
964 /* job_finish scheduled by prepare_decode */
968 if (!wait_for_completion_timeout(&ctx
->completion
,
969 msecs_to_jiffies(1000))) {
970 dev_err(&dev
->plat_dev
->dev
, "CODA PIC_RUN timeout\n");
975 } else if (!ctx
->aborting
) {
976 ctx
->ops
->finish_run(ctx
);
979 if ((ctx
->aborting
|| (!ctx
->streamon_cap
&& !ctx
->streamon_out
)) &&
980 ctx
->ops
->seq_end_work
)
981 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
983 mutex_unlock(&dev
->coda_mutex
);
984 mutex_unlock(&ctx
->buffer_mutex
);
986 v4l2_m2m_job_finish(ctx
->dev
->m2m_dev
, ctx
->fh
.m2m_ctx
);
989 static int coda_job_ready(void *m2m_priv
)
991 struct coda_ctx
*ctx
= m2m_priv
;
992 int src_bufs
= v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
);
995 * For both 'P' and 'key' frame cases 1 picture
996 * and 1 frame are needed. In the decoder case,
997 * the compressed frame can be in the bitstream.
999 if (!src_bufs
&& ctx
->inst_type
!= CODA_INST_DECODER
) {
1000 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1001 "not ready: not enough video buffers.\n");
1005 if (!v4l2_m2m_num_dst_bufs_ready(ctx
->fh
.m2m_ctx
)) {
1006 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1007 "not ready: not enough video capture buffers.\n");
1011 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
) {
1012 bool stream_end
= ctx
->bit_stream_param
&
1013 CODA_BIT_STREAM_END_FLAG
;
1014 int num_metas
= ctx
->num_metas
;
1016 if (ctx
->hold
&& !src_bufs
) {
1017 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1018 "%d: not ready: on hold for more buffers.\n",
1023 if (!stream_end
&& (num_metas
+ src_bufs
) < 2) {
1024 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1025 "%d: not ready: need 2 buffers available (%d, %d)\n",
1026 ctx
->idx
, num_metas
, src_bufs
);
1031 if (!src_bufs
&& !stream_end
&&
1032 (coda_get_bitstream_payload(ctx
) < 512)) {
1033 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1034 "%d: not ready: not enough bitstream data (%d).\n",
1035 ctx
->idx
, coda_get_bitstream_payload(ctx
));
1040 if (ctx
->aborting
) {
1041 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1042 "not ready: aborting\n");
1046 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1052 static void coda_job_abort(void *priv
)
1054 struct coda_ctx
*ctx
= priv
;
1058 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1062 static void coda_lock(void *m2m_priv
)
1064 struct coda_ctx
*ctx
= m2m_priv
;
1065 struct coda_dev
*pcdev
= ctx
->dev
;
1067 mutex_lock(&pcdev
->dev_mutex
);
1070 static void coda_unlock(void *m2m_priv
)
1072 struct coda_ctx
*ctx
= m2m_priv
;
1073 struct coda_dev
*pcdev
= ctx
->dev
;
1075 mutex_unlock(&pcdev
->dev_mutex
);
1078 static const struct v4l2_m2m_ops coda_m2m_ops
= {
1079 .device_run
= coda_device_run
,
1080 .job_ready
= coda_job_ready
,
1081 .job_abort
= coda_job_abort
,
1083 .unlock
= coda_unlock
,
1086 static void set_default_params(struct coda_ctx
*ctx
)
1088 unsigned int max_w
, max_h
, usize
, csize
;
1090 ctx
->codec
= coda_find_codec(ctx
->dev
, ctx
->cvd
->src_formats
[0],
1091 ctx
->cvd
->dst_formats
[0]);
1092 max_w
= min(ctx
->codec
->max_w
, 1920U);
1093 max_h
= min(ctx
->codec
->max_h
, 1088U);
1094 usize
= max_w
* max_h
* 3 / 2;
1095 csize
= coda_estimate_sizeimage(ctx
, usize
, max_w
, max_h
);
1097 ctx
->params
.codec_mode
= ctx
->codec
->mode
;
1098 ctx
->colorspace
= V4L2_COLORSPACE_REC709
;
1099 ctx
->params
.framerate
= 30;
1101 /* Default formats for output and input queues */
1102 ctx
->q_data
[V4L2_M2M_SRC
].fourcc
= ctx
->cvd
->src_formats
[0];
1103 ctx
->q_data
[V4L2_M2M_DST
].fourcc
= ctx
->cvd
->dst_formats
[0];
1104 ctx
->q_data
[V4L2_M2M_SRC
].width
= max_w
;
1105 ctx
->q_data
[V4L2_M2M_SRC
].height
= max_h
;
1106 ctx
->q_data
[V4L2_M2M_DST
].width
= max_w
;
1107 ctx
->q_data
[V4L2_M2M_DST
].height
= max_h
;
1108 if (ctx
->codec
->src_fourcc
== V4L2_PIX_FMT_YUV420
) {
1109 ctx
->q_data
[V4L2_M2M_SRC
].bytesperline
= max_w
;
1110 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
= usize
;
1111 ctx
->q_data
[V4L2_M2M_DST
].bytesperline
= 0;
1112 ctx
->q_data
[V4L2_M2M_DST
].sizeimage
= csize
;
1114 ctx
->q_data
[V4L2_M2M_SRC
].bytesperline
= 0;
1115 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
= csize
;
1116 ctx
->q_data
[V4L2_M2M_DST
].bytesperline
= max_w
;
1117 ctx
->q_data
[V4L2_M2M_DST
].sizeimage
= usize
;
1119 ctx
->q_data
[V4L2_M2M_SRC
].rect
.width
= max_w
;
1120 ctx
->q_data
[V4L2_M2M_SRC
].rect
.height
= max_h
;
1121 ctx
->q_data
[V4L2_M2M_DST
].rect
.width
= max_w
;
1122 ctx
->q_data
[V4L2_M2M_DST
].rect
.height
= max_h
;
1125 * Since the RBC2AXI logic only supports a single chroma plane,
1126 * macroblock tiling only works for to NV12 pixel format.
1128 ctx
->tiled_map_type
= GDI_LINEAR_FRAME_MAP
;
1134 static int coda_queue_setup(struct vb2_queue
*vq
,
1135 unsigned int *nbuffers
, unsigned int *nplanes
,
1136 unsigned int sizes
[], void *alloc_ctxs
[])
1138 struct coda_ctx
*ctx
= vb2_get_drv_priv(vq
);
1139 struct coda_q_data
*q_data
;
1142 q_data
= get_q_data(ctx
, vq
->type
);
1143 size
= q_data
->sizeimage
;
1148 /* Set to vb2-dma-contig allocator context, ignored by vb2-vmalloc */
1149 alloc_ctxs
[0] = ctx
->dev
->alloc_ctx
;
1151 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1152 "get %d buffer(s) of size %d each.\n", *nbuffers
, size
);
1157 static int coda_buf_prepare(struct vb2_buffer
*vb
)
1159 struct coda_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
1160 struct coda_q_data
*q_data
;
1162 q_data
= get_q_data(ctx
, vb
->vb2_queue
->type
);
1164 if (vb2_plane_size(vb
, 0) < q_data
->sizeimage
) {
1165 v4l2_warn(&ctx
->dev
->v4l2_dev
,
1166 "%s data will not fit into plane (%lu < %lu)\n",
1167 __func__
, vb2_plane_size(vb
, 0),
1168 (long)q_data
->sizeimage
);
1175 static void coda_buf_queue(struct vb2_buffer
*vb
)
1177 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
1178 struct coda_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
1179 struct vb2_queue
*vq
= vb
->vb2_queue
;
1180 struct coda_q_data
*q_data
;
1182 q_data
= get_q_data(ctx
, vb
->vb2_queue
->type
);
1185 * In the decoder case, immediately try to copy the buffer into the
1186 * bitstream ringbuffer and mark it as ready to be dequeued.
1188 if (ctx
->bitstream
.size
&& vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1190 * For backwards compatibility, queuing an empty buffer marks
1193 if (vb2_get_plane_payload(vb
, 0) == 0)
1194 coda_bit_stream_end_flag(ctx
);
1195 mutex_lock(&ctx
->bitstream_mutex
);
1196 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vbuf
);
1197 if (vb2_is_streaming(vb
->vb2_queue
))
1198 coda_fill_bitstream(ctx
, true);
1199 mutex_unlock(&ctx
->bitstream_mutex
);
1201 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vbuf
);
1205 int coda_alloc_aux_buf(struct coda_dev
*dev
, struct coda_aux_buf
*buf
,
1206 size_t size
, const char *name
, struct dentry
*parent
)
1208 buf
->vaddr
= dma_alloc_coherent(&dev
->plat_dev
->dev
, size
, &buf
->paddr
,
1211 v4l2_err(&dev
->v4l2_dev
,
1212 "Failed to allocate %s buffer of size %u\n",
1219 if (name
&& parent
) {
1220 buf
->blob
.data
= buf
->vaddr
;
1221 buf
->blob
.size
= size
;
1222 buf
->dentry
= debugfs_create_blob(name
, 0644, parent
,
1225 dev_warn(&dev
->plat_dev
->dev
,
1226 "failed to create debugfs entry %s\n", name
);
1232 void coda_free_aux_buf(struct coda_dev
*dev
,
1233 struct coda_aux_buf
*buf
)
1236 dma_free_coherent(&dev
->plat_dev
->dev
, buf
->size
,
1237 buf
->vaddr
, buf
->paddr
);
1240 debugfs_remove(buf
->dentry
);
1245 static int coda_start_streaming(struct vb2_queue
*q
, unsigned int count
)
1247 struct coda_ctx
*ctx
= vb2_get_drv_priv(q
);
1248 struct v4l2_device
*v4l2_dev
= &ctx
->dev
->v4l2_dev
;
1249 struct coda_q_data
*q_data_src
, *q_data_dst
;
1250 struct vb2_v4l2_buffer
*buf
;
1253 q_data_src
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
1254 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1255 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
) {
1256 /* copy the buffers that were queued before streamon */
1257 mutex_lock(&ctx
->bitstream_mutex
);
1258 coda_fill_bitstream(ctx
, false);
1259 mutex_unlock(&ctx
->bitstream_mutex
);
1261 if (coda_get_bitstream_payload(ctx
) < 512) {
1272 ctx
->streamon_out
= 1;
1279 ctx
->streamon_cap
= 1;
1282 /* Don't start the coda unless both queues are on */
1283 if (!(ctx
->streamon_out
& ctx
->streamon_cap
))
1286 q_data_dst
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
1287 if ((q_data_src
->width
!= q_data_dst
->width
&&
1288 round_up(q_data_src
->width
, 16) != q_data_dst
->width
) ||
1289 (q_data_src
->height
!= q_data_dst
->height
&&
1290 round_up(q_data_src
->height
, 16) != q_data_dst
->height
)) {
1291 v4l2_err(v4l2_dev
, "can't convert %dx%d to %dx%d\n",
1292 q_data_src
->width
, q_data_src
->height
,
1293 q_data_dst
->width
, q_data_dst
->height
);
1298 /* Allow BIT decoder device_run with no new buffers queued */
1299 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
)
1300 v4l2_m2m_set_src_buffered(ctx
->fh
.m2m_ctx
, true);
1302 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1304 ctx
->codec
= coda_find_codec(ctx
->dev
, q_data_src
->fourcc
,
1305 q_data_dst
->fourcc
);
1307 v4l2_err(v4l2_dev
, "couldn't tell instance type.\n");
1312 if (q_data_dst
->fourcc
== V4L2_PIX_FMT_JPEG
)
1313 ctx
->params
.gop_size
= 1;
1314 ctx
->gopcounter
= ctx
->params
.gop_size
- 1;
1316 ret
= ctx
->ops
->start_streaming(ctx
);
1317 if (ctx
->inst_type
== CODA_INST_DECODER
) {
1327 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1328 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1329 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1331 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1332 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_QUEUED
);
1337 static void coda_stop_streaming(struct vb2_queue
*q
)
1339 struct coda_ctx
*ctx
= vb2_get_drv_priv(q
);
1340 struct coda_dev
*dev
= ctx
->dev
;
1341 struct vb2_v4l2_buffer
*buf
;
1342 unsigned long flags
;
1345 stop
= ctx
->streamon_out
&& ctx
->streamon_cap
;
1347 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1348 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1349 "%s: output\n", __func__
);
1350 ctx
->streamon_out
= 0;
1352 coda_bit_stream_end_flag(ctx
);
1356 while ((buf
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
)))
1357 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1359 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
,
1360 "%s: capture\n", __func__
);
1361 ctx
->streamon_cap
= 0;
1364 ctx
->sequence_offset
= 0;
1366 while ((buf
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
)))
1367 v4l2_m2m_buf_done(buf
, VB2_BUF_STATE_ERROR
);
1371 struct coda_buffer_meta
*meta
;
1373 if (ctx
->ops
->seq_end_work
) {
1374 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1375 flush_work(&ctx
->seq_end_work
);
1377 spin_lock_irqsave(&ctx
->buffer_meta_lock
, flags
);
1378 while (!list_empty(&ctx
->buffer_meta_list
)) {
1379 meta
= list_first_entry(&ctx
->buffer_meta_list
,
1380 struct coda_buffer_meta
, list
);
1381 list_del(&meta
->list
);
1385 spin_unlock_irqrestore(&ctx
->buffer_meta_lock
, flags
);
1386 kfifo_init(&ctx
->bitstream_fifo
,
1387 ctx
->bitstream
.vaddr
, ctx
->bitstream
.size
);
1388 ctx
->runcounter
= 0;
1392 if (!ctx
->streamon_out
&& !ctx
->streamon_cap
)
1393 ctx
->bit_stream_param
&= ~CODA_BIT_STREAM_END_FLAG
;
1396 static const struct vb2_ops coda_qops
= {
1397 .queue_setup
= coda_queue_setup
,
1398 .buf_prepare
= coda_buf_prepare
,
1399 .buf_queue
= coda_buf_queue
,
1400 .start_streaming
= coda_start_streaming
,
1401 .stop_streaming
= coda_stop_streaming
,
1402 .wait_prepare
= vb2_ops_wait_prepare
,
1403 .wait_finish
= vb2_ops_wait_finish
,
1406 static int coda_s_ctrl(struct v4l2_ctrl
*ctrl
)
1408 struct coda_ctx
*ctx
=
1409 container_of(ctrl
->handler
, struct coda_ctx
, ctrls
);
1411 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1412 "s_ctrl: id = %d, val = %d\n", ctrl
->id
, ctrl
->val
);
1415 case V4L2_CID_HFLIP
:
1417 ctx
->params
.rot_mode
|= CODA_MIR_HOR
;
1419 ctx
->params
.rot_mode
&= ~CODA_MIR_HOR
;
1421 case V4L2_CID_VFLIP
:
1423 ctx
->params
.rot_mode
|= CODA_MIR_VER
;
1425 ctx
->params
.rot_mode
&= ~CODA_MIR_VER
;
1427 case V4L2_CID_MPEG_VIDEO_BITRATE
:
1428 ctx
->params
.bitrate
= ctrl
->val
/ 1000;
1430 case V4L2_CID_MPEG_VIDEO_GOP_SIZE
:
1431 ctx
->params
.gop_size
= ctrl
->val
;
1433 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
:
1434 ctx
->params
.h264_intra_qp
= ctrl
->val
;
1436 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
:
1437 ctx
->params
.h264_inter_qp
= ctrl
->val
;
1439 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP
:
1440 ctx
->params
.h264_min_qp
= ctrl
->val
;
1442 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP
:
1443 ctx
->params
.h264_max_qp
= ctrl
->val
;
1445 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
:
1446 ctx
->params
.h264_deblk_alpha
= ctrl
->val
;
1448 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
:
1449 ctx
->params
.h264_deblk_beta
= ctrl
->val
;
1451 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
:
1452 ctx
->params
.h264_deblk_enabled
= (ctrl
->val
==
1453 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1455 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
:
1456 ctx
->params
.mpeg4_intra_qp
= ctrl
->val
;
1458 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
:
1459 ctx
->params
.mpeg4_inter_qp
= ctrl
->val
;
1461 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
:
1462 ctx
->params
.slice_mode
= ctrl
->val
;
1464 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
:
1465 ctx
->params
.slice_max_mb
= ctrl
->val
;
1467 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
:
1468 ctx
->params
.slice_max_bits
= ctrl
->val
* 8;
1470 case V4L2_CID_MPEG_VIDEO_HEADER_MODE
:
1472 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
:
1473 ctx
->params
.intra_refresh
= ctrl
->val
;
1475 case V4L2_CID_JPEG_COMPRESSION_QUALITY
:
1476 coda_set_jpeg_compression_quality(ctx
, ctrl
->val
);
1478 case V4L2_CID_JPEG_RESTART_INTERVAL
:
1479 ctx
->params
.jpeg_restart_interval
= ctrl
->val
;
1481 case V4L2_CID_MPEG_VIDEO_VBV_DELAY
:
1482 ctx
->params
.vbv_delay
= ctrl
->val
;
1484 case V4L2_CID_MPEG_VIDEO_VBV_SIZE
:
1485 ctx
->params
.vbv_size
= min(ctrl
->val
* 8192, 0x7fffffff);
1488 v4l2_dbg(1, coda_debug
, &ctx
->dev
->v4l2_dev
,
1489 "Invalid control, id=%d, val=%d\n",
1490 ctrl
->id
, ctrl
->val
);
1497 static const struct v4l2_ctrl_ops coda_ctrl_ops
= {
1498 .s_ctrl
= coda_s_ctrl
,
1501 static void coda_encode_ctrls(struct coda_ctx
*ctx
)
1503 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1504 V4L2_CID_MPEG_VIDEO_BITRATE
, 0, 32767000, 1000, 0);
1505 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1506 V4L2_CID_MPEG_VIDEO_GOP_SIZE
, 1, 60, 1, 16);
1507 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1508 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
, 0, 51, 1, 25);
1509 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1510 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
, 0, 51, 1, 25);
1511 if (ctx
->dev
->devtype
->product
!= CODA_960
) {
1512 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1513 V4L2_CID_MPEG_VIDEO_H264_MIN_QP
, 0, 51, 1, 12);
1515 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1516 V4L2_CID_MPEG_VIDEO_H264_MAX_QP
, 0, 51, 1, 51);
1517 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1518 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
, 0, 15, 1, 0);
1519 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1520 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
, 0, 15, 1, 0);
1521 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1522 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
,
1523 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED
, 0x0,
1524 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
);
1525 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1526 V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
, 1, 31, 1, 2);
1527 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1528 V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
, 1, 31, 1, 2);
1529 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1530 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
,
1531 V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES
, 0x0,
1532 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE
);
1533 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1534 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
, 1, 0x3fffffff, 1, 1);
1535 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1536 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
, 1, 0x3fffffff, 1,
1538 v4l2_ctrl_new_std_menu(&ctx
->ctrls
, &coda_ctrl_ops
,
1539 V4L2_CID_MPEG_VIDEO_HEADER_MODE
,
1540 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
,
1541 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE
),
1542 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
);
1543 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1544 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
, 0,
1545 1920 * 1088 / 256, 1, 0);
1546 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1547 V4L2_CID_MPEG_VIDEO_VBV_DELAY
, 0, 0x7fff, 1, 0);
1549 * The maximum VBV size value is 0x7fffffff bits,
1550 * one bit less than 262144 KiB
1552 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1553 V4L2_CID_MPEG_VIDEO_VBV_SIZE
, 0, 262144, 1, 0);
1556 static void coda_jpeg_encode_ctrls(struct coda_ctx
*ctx
)
1558 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1559 V4L2_CID_JPEG_COMPRESSION_QUALITY
, 5, 100, 1, 50);
1560 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1561 V4L2_CID_JPEG_RESTART_INTERVAL
, 0, 100, 1, 0);
1564 static int coda_ctrls_setup(struct coda_ctx
*ctx
)
1566 v4l2_ctrl_handler_init(&ctx
->ctrls
, 2);
1568 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1569 V4L2_CID_HFLIP
, 0, 1, 1, 0);
1570 v4l2_ctrl_new_std(&ctx
->ctrls
, &coda_ctrl_ops
,
1571 V4L2_CID_VFLIP
, 0, 1, 1, 0);
1572 if (ctx
->inst_type
== CODA_INST_ENCODER
) {
1573 if (ctx
->cvd
->dst_formats
[0] == V4L2_PIX_FMT_JPEG
)
1574 coda_jpeg_encode_ctrls(ctx
);
1576 coda_encode_ctrls(ctx
);
1579 if (ctx
->ctrls
.error
) {
1580 v4l2_err(&ctx
->dev
->v4l2_dev
,
1581 "control initialization error (%d)",
1586 return v4l2_ctrl_handler_setup(&ctx
->ctrls
);
1589 static int coda_queue_init(struct coda_ctx
*ctx
, struct vb2_queue
*vq
)
1592 vq
->ops
= &coda_qops
;
1593 vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
1594 vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
1595 vq
->lock
= &ctx
->dev
->dev_mutex
;
1596 /* One way to indicate end-of-stream for coda is to set the
1597 * bytesused == 0. However by default videobuf2 handles bytesused
1598 * equal to 0 as a special case and changes its value to the size
1599 * of the buffer. Set the allow_zero_bytesused flag, so
1600 * that videobuf2 will keep the value of bytesused intact.
1602 vq
->allow_zero_bytesused
= 1;
1604 return vb2_queue_init(vq
);
1607 int coda_encoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1608 struct vb2_queue
*dst_vq
)
1612 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1613 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1614 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
1616 ret
= coda_queue_init(priv
, src_vq
);
1620 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1621 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1622 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1624 return coda_queue_init(priv
, dst_vq
);
1627 int coda_decoder_queue_init(void *priv
, struct vb2_queue
*src_vq
,
1628 struct vb2_queue
*dst_vq
)
1632 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1633 src_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
| VB2_USERPTR
;
1634 src_vq
->mem_ops
= &vb2_vmalloc_memops
;
1636 ret
= coda_queue_init(priv
, src_vq
);
1640 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1641 dst_vq
->io_modes
= VB2_DMABUF
| VB2_MMAP
;
1642 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
1644 return coda_queue_init(priv
, dst_vq
);
1647 static int coda_next_free_instance(struct coda_dev
*dev
)
1649 int idx
= ffz(dev
->instance_mask
);
1652 (dev
->devtype
->product
== CODA_DX6
&& idx
> CODADX6_MAX_INSTANCES
))
1662 static int coda_open(struct file
*file
)
1664 struct video_device
*vdev
= video_devdata(file
);
1665 struct coda_dev
*dev
= video_get_drvdata(vdev
);
1666 struct coda_ctx
*ctx
= NULL
;
1671 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
1675 idx
= coda_next_free_instance(dev
);
1680 set_bit(idx
, &dev
->instance_mask
);
1682 name
= kasprintf(GFP_KERNEL
, "context%d", idx
);
1685 goto err_coda_name_init
;
1688 ctx
->debugfs_entry
= debugfs_create_dir(name
, dev
->debugfs_root
);
1691 ctx
->cvd
= to_coda_video_device(vdev
);
1692 ctx
->inst_type
= ctx
->cvd
->type
;
1693 ctx
->ops
= ctx
->cvd
->ops
;
1694 ctx
->use_bit
= !ctx
->cvd
->direct
;
1695 init_completion(&ctx
->completion
);
1696 INIT_WORK(&ctx
->pic_run_work
, coda_pic_run_work
);
1697 if (ctx
->ops
->seq_end_work
)
1698 INIT_WORK(&ctx
->seq_end_work
, ctx
->ops
->seq_end_work
);
1699 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
1700 file
->private_data
= &ctx
->fh
;
1701 v4l2_fh_add(&ctx
->fh
);
1704 switch (dev
->devtype
->product
) {
1706 ctx
->frame_mem_ctrl
= 1 << 12;
1715 /* Power up and upload firmware if necessary */
1716 ret
= pm_runtime_get_sync(&dev
->plat_dev
->dev
);
1718 v4l2_err(&dev
->v4l2_dev
, "failed to power up: %d\n", ret
);
1722 ret
= clk_prepare_enable(dev
->clk_per
);
1726 ret
= clk_prepare_enable(dev
->clk_ahb
);
1730 set_default_params(ctx
);
1731 ctx
->fh
.m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
,
1732 ctx
->ops
->queue_init
);
1733 if (IS_ERR(ctx
->fh
.m2m_ctx
)) {
1734 ret
= PTR_ERR(ctx
->fh
.m2m_ctx
);
1736 v4l2_err(&dev
->v4l2_dev
, "%s return error (%d)\n",
1741 ret
= coda_ctrls_setup(ctx
);
1743 v4l2_err(&dev
->v4l2_dev
, "failed to setup coda controls\n");
1744 goto err_ctrls_setup
;
1747 ctx
->fh
.ctrl_handler
= &ctx
->ctrls
;
1749 mutex_init(&ctx
->bitstream_mutex
);
1750 mutex_init(&ctx
->buffer_mutex
);
1751 INIT_LIST_HEAD(&ctx
->buffer_meta_list
);
1752 spin_lock_init(&ctx
->buffer_meta_lock
);
1755 list_add(&ctx
->list
, &dev
->instances
);
1758 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Created instance %d (%p)\n",
1764 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1766 clk_disable_unprepare(dev
->clk_ahb
);
1768 clk_disable_unprepare(dev
->clk_per
);
1770 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1772 v4l2_fh_del(&ctx
->fh
);
1773 v4l2_fh_exit(&ctx
->fh
);
1774 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1781 static int coda_release(struct file
*file
)
1783 struct coda_dev
*dev
= video_drvdata(file
);
1784 struct coda_ctx
*ctx
= fh_to_ctx(file
->private_data
);
1786 v4l2_dbg(1, coda_debug
, &dev
->v4l2_dev
, "Releasing instance %p\n",
1789 if (ctx
->inst_type
== CODA_INST_DECODER
&& ctx
->use_bit
)
1790 coda_bit_stream_end_flag(ctx
);
1792 /* If this instance is running, call .job_abort and wait for it to end */
1793 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
1795 /* In case the instance was not running, we still need to call SEQ_END */
1796 if (ctx
->ops
->seq_end_work
) {
1797 queue_work(dev
->workqueue
, &ctx
->seq_end_work
);
1798 flush_work(&ctx
->seq_end_work
);
1802 list_del(&ctx
->list
);
1805 if (ctx
->dev
->devtype
->product
== CODA_DX6
)
1806 coda_free_aux_buf(dev
, &ctx
->workbuf
);
1808 v4l2_ctrl_handler_free(&ctx
->ctrls
);
1809 clk_disable_unprepare(dev
->clk_ahb
);
1810 clk_disable_unprepare(dev
->clk_per
);
1811 pm_runtime_put_sync(&dev
->plat_dev
->dev
);
1812 v4l2_fh_del(&ctx
->fh
);
1813 v4l2_fh_exit(&ctx
->fh
);
1814 clear_bit(ctx
->idx
, &dev
->instance_mask
);
1815 if (ctx
->ops
->release
)
1816 ctx
->ops
->release(ctx
);
1817 debugfs_remove_recursive(ctx
->debugfs_entry
);
1823 static const struct v4l2_file_operations coda_fops
= {
1824 .owner
= THIS_MODULE
,
1826 .release
= coda_release
,
1827 .poll
= v4l2_m2m_fop_poll
,
1828 .unlocked_ioctl
= video_ioctl2
,
1829 .mmap
= v4l2_m2m_fop_mmap
,
1832 static int coda_hw_init(struct coda_dev
*dev
)
1838 ret
= clk_prepare_enable(dev
->clk_per
);
1842 ret
= clk_prepare_enable(dev
->clk_ahb
);
1847 reset_control_reset(dev
->rstc
);
1850 * Copy the first CODA_ISRAM_SIZE in the internal SRAM.
1851 * The 16-bit chars in the code buffer are in memory access
1852 * order, re-sort them to CODA order for register download.
1853 * Data in this SRAM survives a reboot.
1855 p
= (u16
*)dev
->codebuf
.vaddr
;
1856 if (dev
->devtype
->product
== CODA_DX6
) {
1857 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1858 data
= CODA_DOWN_ADDRESS_SET(i
) |
1859 CODA_DOWN_DATA_SET(p
[i
^ 1]);
1860 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1863 for (i
= 0; i
< (CODA_ISRAM_SIZE
/ 2); i
++) {
1864 data
= CODA_DOWN_ADDRESS_SET(i
) |
1865 CODA_DOWN_DATA_SET(p
[round_down(i
, 4) +
1867 coda_write(dev
, data
, CODA_REG_BIT_CODE_DOWN
);
1871 /* Clear registers */
1872 for (i
= 0; i
< 64; i
++)
1873 coda_write(dev
, 0, CODA_REG_BIT_CODE_BUF_ADDR
+ i
* 4);
1875 /* Tell the BIT where to find everything it needs */
1876 if (dev
->devtype
->product
== CODA_960
||
1877 dev
->devtype
->product
== CODA_7541
) {
1878 coda_write(dev
, dev
->tempbuf
.paddr
,
1879 CODA_REG_BIT_TEMP_BUF_ADDR
);
1880 coda_write(dev
, 0, CODA_REG_BIT_BIT_STREAM_PARAM
);
1882 coda_write(dev
, dev
->workbuf
.paddr
,
1883 CODA_REG_BIT_WORK_BUF_ADDR
);
1885 coda_write(dev
, dev
->codebuf
.paddr
,
1886 CODA_REG_BIT_CODE_BUF_ADDR
);
1887 coda_write(dev
, 0, CODA_REG_BIT_CODE_RUN
);
1889 /* Set default values */
1890 switch (dev
->devtype
->product
) {
1892 coda_write(dev
, CODADX6_STREAM_BUF_PIC_FLUSH
,
1893 CODA_REG_BIT_STREAM_CTRL
);
1896 coda_write(dev
, CODA7_STREAM_BUF_PIC_FLUSH
,
1897 CODA_REG_BIT_STREAM_CTRL
);
1899 if (dev
->devtype
->product
== CODA_960
)
1900 coda_write(dev
, 1 << 12, CODA_REG_BIT_FRAME_MEM_CTRL
);
1902 coda_write(dev
, 0, CODA_REG_BIT_FRAME_MEM_CTRL
);
1904 if (dev
->devtype
->product
!= CODA_DX6
)
1905 coda_write(dev
, 0, CODA7_REG_BIT_AXI_SRAM_USE
);
1907 coda_write(dev
, CODA_INT_INTERRUPT_ENABLE
,
1908 CODA_REG_BIT_INT_ENABLE
);
1910 /* Reset VPU and start processor */
1911 data
= coda_read(dev
, CODA_REG_BIT_CODE_RESET
);
1912 data
|= CODA_REG_RESET_ENABLE
;
1913 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1915 data
&= ~CODA_REG_RESET_ENABLE
;
1916 coda_write(dev
, data
, CODA_REG_BIT_CODE_RESET
);
1917 coda_write(dev
, CODA_REG_RUN_ENABLE
, CODA_REG_BIT_CODE_RUN
);
1919 clk_disable_unprepare(dev
->clk_ahb
);
1920 clk_disable_unprepare(dev
->clk_per
);
1925 clk_disable_unprepare(dev
->clk_per
);
1930 static int coda_register_device(struct coda_dev
*dev
, int i
)
1932 struct video_device
*vfd
= &dev
->vfd
[i
];
1934 if (i
>= dev
->devtype
->num_vdevs
)
1937 strlcpy(vfd
->name
, dev
->devtype
->vdevs
[i
]->name
, sizeof(vfd
->name
));
1938 vfd
->fops
= &coda_fops
;
1939 vfd
->ioctl_ops
= &coda_ioctl_ops
;
1940 vfd
->release
= video_device_release_empty
,
1941 vfd
->lock
= &dev
->dev_mutex
;
1942 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1943 vfd
->vfl_dir
= VFL_DIR_M2M
;
1944 video_set_drvdata(vfd
, dev
);
1946 /* Not applicable, use the selection API instead */
1947 v4l2_disable_ioctl(vfd
, VIDIOC_CROPCAP
);
1948 v4l2_disable_ioctl(vfd
, VIDIOC_G_CROP
);
1949 v4l2_disable_ioctl(vfd
, VIDIOC_S_CROP
);
1951 return video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
1954 static void coda_fw_callback(const struct firmware
*fw
, void *context
)
1956 struct coda_dev
*dev
= context
;
1957 struct platform_device
*pdev
= dev
->plat_dev
;
1961 v4l2_err(&dev
->v4l2_dev
, "firmware request failed\n");
1965 /* allocate auxiliary per-device code buffer for the BIT processor */
1966 ret
= coda_alloc_aux_buf(dev
, &dev
->codebuf
, fw
->size
, "codebuf",
1971 /* Copy the whole firmware image to the code buffer */
1972 memcpy(dev
->codebuf
.vaddr
, fw
->data
, fw
->size
);
1973 release_firmware(fw
);
1975 ret
= coda_hw_init(dev
);
1977 v4l2_err(&dev
->v4l2_dev
, "HW initialization failed\n");
1981 ret
= coda_check_firmware(dev
);
1985 dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
1986 if (IS_ERR(dev
->alloc_ctx
)) {
1987 v4l2_err(&dev
->v4l2_dev
, "Failed to alloc vb2 context\n");
1991 dev
->m2m_dev
= v4l2_m2m_init(&coda_m2m_ops
);
1992 if (IS_ERR(dev
->m2m_dev
)) {
1993 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
1997 for (i
= 0; i
< dev
->devtype
->num_vdevs
; i
++) {
1998 ret
= coda_register_device(dev
, i
);
2000 v4l2_err(&dev
->v4l2_dev
,
2001 "Failed to register %s video device: %d\n",
2002 dev
->devtype
->vdevs
[i
]->name
, ret
);
2007 v4l2_info(&dev
->v4l2_dev
, "codec registered as /dev/video[%d-%d]\n",
2008 dev
->vfd
[0].num
, dev
->vfd
[i
- 1].num
);
2010 pm_runtime_put_sync(&pdev
->dev
);
2015 video_unregister_device(&dev
->vfd
[i
]);
2016 v4l2_m2m_release(dev
->m2m_dev
);
2018 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
2020 pm_runtime_put_sync(&pdev
->dev
);
2023 static int coda_firmware_request(struct coda_dev
*dev
)
2025 char *fw
= dev
->devtype
->firmware
;
2027 dev_dbg(&dev
->plat_dev
->dev
, "requesting firmware '%s' for %s\n", fw
,
2028 coda_product_name(dev
->devtype
->product
));
2030 return request_firmware_nowait(THIS_MODULE
, true,
2031 fw
, &dev
->plat_dev
->dev
, GFP_KERNEL
, dev
, coda_fw_callback
);
2034 enum coda_platform
{
2041 static const struct coda_devtype coda_devdata
[] = {
2043 .firmware
= "v4l-codadx6-imx27.bin",
2044 .product
= CODA_DX6
,
2045 .codecs
= codadx6_codecs
,
2046 .num_codecs
= ARRAY_SIZE(codadx6_codecs
),
2047 .vdevs
= codadx6_video_devices
,
2048 .num_vdevs
= ARRAY_SIZE(codadx6_video_devices
),
2049 .workbuf_size
= 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE
* 8 * 1024,
2050 .iram_size
= 0xb000,
2053 .firmware
= "v4l-coda7541-imx53.bin",
2054 .product
= CODA_7541
,
2055 .codecs
= coda7_codecs
,
2056 .num_codecs
= ARRAY_SIZE(coda7_codecs
),
2057 .vdevs
= coda7_video_devices
,
2058 .num_vdevs
= ARRAY_SIZE(coda7_video_devices
),
2059 .workbuf_size
= 128 * 1024,
2060 .tempbuf_size
= 304 * 1024,
2061 .iram_size
= 0x14000,
2064 .firmware
= "v4l-coda960-imx6q.bin",
2065 .product
= CODA_960
,
2066 .codecs
= coda9_codecs
,
2067 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2068 .vdevs
= coda9_video_devices
,
2069 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2070 .workbuf_size
= 80 * 1024,
2071 .tempbuf_size
= 204 * 1024,
2072 .iram_size
= 0x21000,
2075 .firmware
= "v4l-coda960-imx6dl.bin",
2076 .product
= CODA_960
,
2077 .codecs
= coda9_codecs
,
2078 .num_codecs
= ARRAY_SIZE(coda9_codecs
),
2079 .vdevs
= coda9_video_devices
,
2080 .num_vdevs
= ARRAY_SIZE(coda9_video_devices
),
2081 .workbuf_size
= 80 * 1024,
2082 .tempbuf_size
= 204 * 1024,
2083 .iram_size
= 0x20000,
2087 static struct platform_device_id coda_platform_ids
[] = {
2088 { .name
= "coda-imx27", .driver_data
= CODA_IMX27
},
2091 MODULE_DEVICE_TABLE(platform
, coda_platform_ids
);
2094 static const struct of_device_id coda_dt_ids
[] = {
2095 { .compatible
= "fsl,imx27-vpu", .data
= &coda_devdata
[CODA_IMX27
] },
2096 { .compatible
= "fsl,imx53-vpu", .data
= &coda_devdata
[CODA_IMX53
] },
2097 { .compatible
= "fsl,imx6q-vpu", .data
= &coda_devdata
[CODA_IMX6Q
] },
2098 { .compatible
= "fsl,imx6dl-vpu", .data
= &coda_devdata
[CODA_IMX6DL
] },
2101 MODULE_DEVICE_TABLE(of
, coda_dt_ids
);
2104 static int coda_probe(struct platform_device
*pdev
)
2106 const struct of_device_id
*of_id
=
2107 of_match_device(of_match_ptr(coda_dt_ids
), &pdev
->dev
);
2108 const struct platform_device_id
*pdev_id
;
2109 struct coda_platform_data
*pdata
= pdev
->dev
.platform_data
;
2110 struct device_node
*np
= pdev
->dev
.of_node
;
2111 struct gen_pool
*pool
;
2112 struct coda_dev
*dev
;
2113 struct resource
*res
;
2116 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
2120 pdev_id
= of_id
? of_id
->data
: platform_get_device_id(pdev
);
2123 dev
->devtype
= of_id
->data
;
2124 } else if (pdev_id
) {
2125 dev
->devtype
= &coda_devdata
[pdev_id
->driver_data
];
2128 goto err_v4l2_register
;
2131 spin_lock_init(&dev
->irqlock
);
2132 INIT_LIST_HEAD(&dev
->instances
);
2134 dev
->plat_dev
= pdev
;
2135 dev
->clk_per
= devm_clk_get(&pdev
->dev
, "per");
2136 if (IS_ERR(dev
->clk_per
)) {
2137 dev_err(&pdev
->dev
, "Could not get per clock\n");
2138 return PTR_ERR(dev
->clk_per
);
2141 dev
->clk_ahb
= devm_clk_get(&pdev
->dev
, "ahb");
2142 if (IS_ERR(dev
->clk_ahb
)) {
2143 dev_err(&pdev
->dev
, "Could not get ahb clock\n");
2144 return PTR_ERR(dev
->clk_ahb
);
2147 /* Get memory for physical registers */
2148 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
2149 dev
->regs_base
= devm_ioremap_resource(&pdev
->dev
, res
);
2150 if (IS_ERR(dev
->regs_base
))
2151 return PTR_ERR(dev
->regs_base
);
2154 irq
= platform_get_irq_byname(pdev
, "bit");
2156 irq
= platform_get_irq(pdev
, 0);
2158 dev_err(&pdev
->dev
, "failed to get irq resource\n");
2162 ret
= devm_request_threaded_irq(&pdev
->dev
, irq
, NULL
, coda_irq_handler
,
2163 IRQF_ONESHOT
, dev_name(&pdev
->dev
), dev
);
2165 dev_err(&pdev
->dev
, "failed to request irq: %d\n", ret
);
2169 dev
->rstc
= devm_reset_control_get_optional(&pdev
->dev
, NULL
);
2170 if (IS_ERR(dev
->rstc
)) {
2171 ret
= PTR_ERR(dev
->rstc
);
2172 if (ret
== -ENOENT
|| ret
== -ENOSYS
) {
2175 dev_err(&pdev
->dev
, "failed get reset control: %d\n",
2181 /* Get IRAM pool from device tree or platform data */
2182 pool
= of_gen_pool_get(np
, "iram", 0);
2184 pool
= gen_pool_get(pdata
->iram_dev
, NULL
);
2186 dev_err(&pdev
->dev
, "iram pool not available\n");
2189 dev
->iram_pool
= pool
;
2191 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
2195 mutex_init(&dev
->dev_mutex
);
2196 mutex_init(&dev
->coda_mutex
);
2198 dev
->debugfs_root
= debugfs_create_dir("coda", NULL
);
2199 if (!dev
->debugfs_root
)
2200 dev_warn(&pdev
->dev
, "failed to create debugfs root\n");
2202 /* allocate auxiliary per-device buffers for the BIT processor */
2203 if (dev
->devtype
->product
== CODA_DX6
) {
2204 ret
= coda_alloc_aux_buf(dev
, &dev
->workbuf
,
2205 dev
->devtype
->workbuf_size
, "workbuf",
2208 goto err_v4l2_register
;
2211 if (dev
->devtype
->tempbuf_size
) {
2212 ret
= coda_alloc_aux_buf(dev
, &dev
->tempbuf
,
2213 dev
->devtype
->tempbuf_size
, "tempbuf",
2216 goto err_v4l2_register
;
2219 dev
->iram
.size
= dev
->devtype
->iram_size
;
2220 dev
->iram
.vaddr
= gen_pool_dma_alloc(dev
->iram_pool
, dev
->iram
.size
,
2222 if (!dev
->iram
.vaddr
) {
2223 dev_warn(&pdev
->dev
, "unable to alloc iram\n");
2225 memset(dev
->iram
.vaddr
, 0, dev
->iram
.size
);
2226 dev
->iram
.blob
.data
= dev
->iram
.vaddr
;
2227 dev
->iram
.blob
.size
= dev
->iram
.size
;
2228 dev
->iram
.dentry
= debugfs_create_blob("iram", 0644,
2233 dev
->workqueue
= alloc_workqueue("coda", WQ_UNBOUND
| WQ_MEM_RECLAIM
, 1);
2234 if (!dev
->workqueue
) {
2235 dev_err(&pdev
->dev
, "unable to alloc workqueue\n");
2237 goto err_v4l2_register
;
2240 platform_set_drvdata(pdev
, dev
);
2243 * Start activated so we can directly call coda_hw_init in
2244 * coda_fw_callback regardless of whether CONFIG_PM is
2245 * enabled or whether the device is associated with a PM domain.
2247 pm_runtime_get_noresume(&pdev
->dev
);
2248 pm_runtime_set_active(&pdev
->dev
);
2249 pm_runtime_enable(&pdev
->dev
);
2251 return coda_firmware_request(dev
);
2254 v4l2_device_unregister(&dev
->v4l2_dev
);
2258 static int coda_remove(struct platform_device
*pdev
)
2260 struct coda_dev
*dev
= platform_get_drvdata(pdev
);
2263 for (i
= 0; i
< ARRAY_SIZE(dev
->vfd
); i
++) {
2264 if (video_get_drvdata(&dev
->vfd
[i
]))
2265 video_unregister_device(&dev
->vfd
[i
]);
2268 v4l2_m2m_release(dev
->m2m_dev
);
2269 pm_runtime_disable(&pdev
->dev
);
2271 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
2272 v4l2_device_unregister(&dev
->v4l2_dev
);
2273 destroy_workqueue(dev
->workqueue
);
2274 if (dev
->iram
.vaddr
)
2275 gen_pool_free(dev
->iram_pool
, (unsigned long)dev
->iram
.vaddr
,
2277 coda_free_aux_buf(dev
, &dev
->codebuf
);
2278 coda_free_aux_buf(dev
, &dev
->tempbuf
);
2279 coda_free_aux_buf(dev
, &dev
->workbuf
);
2280 debugfs_remove_recursive(dev
->debugfs_root
);
2285 static int coda_runtime_resume(struct device
*dev
)
2287 struct coda_dev
*cdev
= dev_get_drvdata(dev
);
2290 if (dev
->pm_domain
&& cdev
->codebuf
.vaddr
) {
2291 ret
= coda_hw_init(cdev
);
2293 v4l2_err(&cdev
->v4l2_dev
, "HW initialization failed\n");
2300 static const struct dev_pm_ops coda_pm_ops
= {
2301 SET_RUNTIME_PM_OPS(NULL
, coda_runtime_resume
, NULL
)
2304 static struct platform_driver coda_driver
= {
2305 .probe
= coda_probe
,
2306 .remove
= coda_remove
,
2309 .of_match_table
= of_match_ptr(coda_dt_ids
),
2312 .id_table
= coda_platform_ids
,
2315 module_platform_driver(coda_driver
);
2317 MODULE_LICENSE("GPL");
2318 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
2319 MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver");